Changeset 2967476

code-injection/trunk/code-injection.php

-                      r2943916
+                      r2967476
  * Plugin URI: https://github.com/Rmanaf/wp-code-injection
  * Description: This plugin allows you to effortlessly create custom ads for your website. Inject code snippets in HTML, CSS, and JavaScript, write and run custom plugins on-the-fly, and take your website's capabilities to the next level.
  * Version: 2.4.13
+ * Version: 2.4.14
  * Author: Rmanaf
  * Author URI: https://profiles.wordpress.org/rmanaf/
 …
 define('__CI_URL__', plugin_dir_url(__FILE__));
 define('__CI_PATH__', plugin_dir_path(__FILE__));
 define('__CI_VERSION__', '2.4.13');
+define('__CI_VERSION__', '2.4.14');
 // Require the necessary files for the plugin
 …
 require_once __DIR__ . '/includes/class-widget.php';
 require_once __DIR__ . '/includes/class-code-type.php';
+require_once __DIR__ . '/includes/class-block.php';
 require_once __DIR__ . '/includes/class-core.php';

code-injection/trunk/includes/class-asset-manager.php

-                      r2939201
+                      r2967476
 namespace ci;
+/**
+ * The AssetManager class handles the enqueuing of styles and scripts required for the Code Injection plugin's functionality.
+ * It registers and enqueues various styles and scripts for both the admin panel and specific plugin features. The class is
+ * responsible for loading code editor styles, Monaco editor scripts, tag editor styles and scripts, essential plugin scripts,
+ * and custom styles for the plugin settings page. It also localizes script data to provide necessary variables to JavaScript
+ * functions. The class aids in maintaining the presentation and interactivity of the plugin's user interface.
+ *
+ * @since 2.4.2
+ */
 class AssetManager
+{
+    private static $CI_LOCALIZE_OBJ = '_ci';
     /**
+     * Initialize the Asset Manager
+     *
+     * Registers and enqueues necessary styles and scripts for the Code Injection plugin's functionality.
+     *
      * @since 2.4.2
      */
     static function init()
+    {
+        add_action('admin_enqueue_scripts', array(__CLASS__, 'enqueue_scripts'), 50);
+        add_action('admin_enqueue_scripts', array(__CLASS__, '_enqueue_scripts'), 50);
+        add_action('enqueue_block_editor_assets', array(__CLASS__, '_enqueue_block_editor_assets'));
+    }
 …
     /**
+     * Enqueue Scripts and Styles
+     *
+     * Handles the enqueuing of scripts and styles for the Code Injection plugin's functionality. This includes loading
+     * code editor styles, scripts, Monaco editor, tag editor styles and scripts, and plugin-specific styles and scripts
+     * based on whether the plugin's settings page is being accessed or not.
+     *
+     * @access private
      * @since 2.2.8
      */
     static function enqueue_scripts()
+    static function _enqueue_scripts()
+    {
+        // Array of localized texts for internationalization
         $texts = array(
             "The File is too large. Do you want to proceed?",
 …
         );
+        // Internationalization for JavaScript
         $i18n = array(
             'code-injection' => array(
 …
         );
+        // Register custom styles and scripts
         wp_register_style('ci-custom-code-editor', Helpers::get_asset_url('/css/code-editor.css'), array(), __CI_VERSION__, 'all');
         wp_register_script('ci-monaco-editor-loader', 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.21.2/min/vs/loader.min.js', array('jquery'), null, true);
         wp_register_script('ci-editor', Helpers::get_asset_url('/js/code-editor.js'), array(), __CI_VERSION__, false);
+        // Enqueue essential scripts
         wp_enqueue_script('ci-essentials', Helpers::get_asset_url('/js/essentials.js'), array('jquery'), __CI_VERSION__, true);
+        wp_localize_script('ci-essentials', "_ci", array(
+        // Localize essential scripts with relevant data
+        wp_localize_script('ci-essentials', self::$CI_LOCALIZE_OBJ , apply_filters('ci_localize_obj' , array(
             'ajax_url'      => admin_url('admin-ajax.php'),
             "ajax_nonce"    => wp_create_nonce("code-injection-ajax-nonce"),
             "is_rtl"        => is_rtl() ? "true" : "false",
             "i18n"          => $i18n
         ));
+        )));
+        // Enqueue plugin-specific styles
         wp_enqueue_style('ci-styles', Helpers::get_asset_url('/css/wp-code-injection-admin.css'), array(), __CI_VERSION__, 'all');
+        // Enqueue additional styles and scripts for settings page
         if (Helpers::is_settings_page()) {
-            // tag-editor styles
             wp_enqueue_style('ci-tag-editor', Helpers::get_asset_url('/css/jquery.tag-editor.css'), array(), __CI_VERSION__, 'all');
-            // tag-editor scripts
             wp_enqueue_script('ci-caret', Helpers::get_asset_url('/js/jquery.caret.min.js'), array('jquery'), __CI_VERSION__, false);
             wp_enqueue_script('ci-tag-editor', Helpers::get_asset_url('/js/jquery.tag-editor.min.js'), array('jquery', 'ci-caret'), __CI_VERSION__, false);
-            // admin settings scripts
             wp_enqueue_script('ci-code-injection', Helpers::get_asset_url('/js/wp-ci-general-settings.js'), array('jquery'), __CI_VERSION__, true);
+        }
 …
     /**
+     * @access private
+     * @since 2.4.14
+     */
+    static function _enqueue_block_editor_assets() {
+        $deps   = array('wp-blocks', 'wp-element', 'wp-data', 'wp-components');
+        $src    = Helpers::get_asset_url('/js/block.js');
+        wp_enqueue_script('ci-inject-block' , $src ,  $deps , __CI_VERSION__ , true);
+    }
+    /**
+     * Enqueue Editor Scripts and Styles
+     *
+     * Enqueues styles and scripts specifically for the code editor component.
+     *
      * @since 2.4.2
      */
 …
         wp_enqueue_script('ci-editor');
+    }
+}

code-injection/trunk/includes/class-barchart.php

-                      r2943916
+                      r2967476
 namespace ci;
+/**
+ * Barchart Class
+ *
+ * This class generates a simple bar chart SVG representation based on provided data and dimensions.
+ *
+ * @since 2.4.5
+ */
 class Barchart
+{
+    private $data = [];
+    private $data = array();
     private $width = 0;
     private $height = 0;
     private $gap = 1;
+    /**
+     * Constructor
+     *
+     * @param array $data   Data for the chart.
+     * @param int   $w      Width of the chart.
+     * @param int   $h      Height of the chart.
+     * @param int   $g      Gap between bars.
+     */
     function __construct($data, $w, $h, $g = 1)
+    {
 …
     /**
+     * Render the Barchart
+     *
+     * Generates and outputs an SVG representation of the barchart.
+     *
      * @since 2.4.5
      */
 …
+    {
+        // Find the maximum value in the data to calculate the yScale
         $max = 0;
+        $index = 0;
+        if (count($this->data) > 0) {
+        if (!empty($this->data)) {
             $max = max(array_map(function ($item) {
                 return intval($item["value"]);
 …
+        }
-        $yScale = $max / $this->height;
+        $length = count($this->data);
+        // Calculate the yScale to determine the scaling of the bars
+        $yScale = ($this->height > 0) ? $max / $this->height : 0;
+        $barWidth = ($this->width / $length) - $this->gap;
+        // Calculate the width of each bar
+        $barWidth = ($this->width / count($this->data)) - $this->gap;
+        // Calculate the total height of the SVG including margins
         $svgHeight = $this->height + 25;
+        // Start generating the SVG
         echo "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" " .
             "xmlns:xlink=\"http://www.w3.org/1999/xlink\" " .
 …
+        // Generate horizontal grid lines
         foreach ([0, $this->height / 2, $this->height] as $y) {
             echo "<g>" .
 …
+        foreach ($this->data as $d) {
+        // Generate bars for each data point
+        foreach ($this->data as $index => $d) {
+            $num        = intval(isset($d['value']) ? $d['value'] : 0);
+            $tooltip    = isset($d['index']) ? $d['index'] : '';
+            // Extract the value and tooltip from the data
+            $num = intval(isset($d['value']) ? $d['value'] : 0);
+            $tooltip = isset($d['index']) ? $d['index'] : '';
+            if ($yScale > 0) {
+                $height = $num / $yScale;
+            } else {
+                $height = $num;
+            }
+            // Calculate the height of the bar based on the yScale
+            $height = ($yScale > 0) ? $num / $yScale : $num;
+            // Calculate the x and y coordinates for the bar and related elements
             $x = ($index * ($barWidth + $this->gap));
             $y = $this->height - $height;
             $lineX = ($barWidth / 2) + $x;
             $tooltipY = $this->height + 12;
             $tooltipX = min([max([$lineX, 9]), $this->width - 9]);
+            // Generate tooltip markup if a tooltip is available
+            $tooltipMarkup = '';
             if (!empty($tooltip)) {
+                $tooltip = "<g class=\"tooltip\" style=\"transform:translate({$tooltipX}px,{$tooltipY}px);\">" .
+                $tooltipMarkup = "<g class=\"tooltip\" style=\"transform:translate({$tooltipX}px,{$tooltipY}px);\">" .
                     "<circle class=\"bg\" r=\"9\" fill=\"#333\" />" .
                     "<text dy=\".35em\" x=\"0\" y=\"0\" text-anchor=\"middle\" class=\"count\" fill=\"#fff\">$tooltip</text>" .
 …
+            }
+            // Output SVG elements for the bar and related components
             echo "<g class=\"bar\">" .
                 "<line class=\"grid\" x1=\"$lineX\" y1=\"0\" x2=\"$lineX\" y2=\"$this->height\" stroke-width=\"4\" />" .
                 "<rect y=\"$y\" x=\"$x\" width=\"$barWidth\" height=\"$height\" />" .
                 $tooltip .
+                $tooltipMarkup .
                 "</g>";
-            $index++;
+        }
+        // Close the SVG element
         echo "</svg>";
+    }

code-injection/trunk/includes/class-code-type.php

-                      r2939201
+                      r2967476
         $length = intval(date('t', mktime(0, 0, 0, $month, 1, $year)));
         $bcDataHolder = array_fill(0, $length, [
+        $bcDataHolder = array_fill(0, $length, array(
             "value" => 0
         ]);
+        ));
         $bcDataHolder = array_map(function ($item) {
             $index = $item + 1;
             return [
+            return array(
                 "value" => 0,
                 "index" => $index < 10 ? "0$index" : $index
             ];
+            );
         }, array_keys($bcDataHolder));
 …
         foreach ($bcData as $d) {
             $bcDataHolder[intval($d['day']) - 1] = [
+            $bcDataHolder[intval($d['day']) - 1] = array(
                 "value" => $d["total_hits"],
                 "index" => $d["day"] < 10 ? "0{$d["day"]}" : $d["day"]
             ];
+            );
+        }
 …
             return;
         $taxonomies = ['code_category'];
+        $taxonomies = array('code_category');
         foreach ($taxonomies as $taxonomy_slug) {
 …
             $status = get_post_status($post);
             $needles = [$post->post_title, '”', '“'];
+            $needles = array($post->post_title, '”', '“');
             if (isset($actions['edit'])) {
 …
+    {
         $code_lables = [
+        $code_lables = array(
             'name' => esc_html__('Codes', "code-injection"),
             'singular_name' => esc_html__('Code', "code-injection"),
 …
             'not_found_in_trash ' => esc_html__('No codes found in Trash', "code-injection"),
             'all_items' => esc_html__('All Codes', "code-injection")
         ];
+        );
 …
             'code_category',
             'code',
+            [
+            array(
                 'show_admin_column' => true,
                 'public' => false,
 …
                 'rewrite' => false,
                 'hierarchical' => true
+            ]
+            )
         );
 …
         register_post_type(
             'Code',
+            [
+            array(
                 'menu_icon' => 'dashicons-editor-code',
                 'labels' => $code_lables,
 …
                 'exclude_from_search' => true,
                 'publicly_queryable' => false,
                 'supports' => ['author', 'revisions', 'title', 'editor'],
+                'supports' => array('author', 'revisions', 'title', 'editor'),
                 'capability_type' => ['code', 'codes'],
                 'can_export' => true,
                 'map_meta_cap' => true
+            ]
+            )
         );
+    }
 …
+    {
+        $columns = [];
+        $columns['id'] = esc_html__("Code", "code-injection");
+        $columns['info'] = esc_html__("Info", "code-injection");
+        $columns['statistics'] = esc_html__("Hits", "code-injection");
+        return $columns;
+        return array(
+            'id' => esc_html__("Code", "code-injection"),
+            'info' => esc_html__("Info", "code-injection"),
+            'statistics' => esc_html__("Hits", "code-injection")
+        );
+    }

code-injection/trunk/includes/class-core.php

-                      r2939201
+                      r2967476
 namespace ci;
+/**
+ * Core Class for Code Injection Plugin
+ *
+ * The Core class serves as the central orchestrator for the Code Injection plugin. It provides the backbone structure
+ * for the plugin's functionalities by organizing and managing its various components and actions. This class encapsulates
+ * the main operations of the plugin and initializes key features such as code type management, database setup, user roles,
+ * metabox handling, asset management, shortcodes, options, and more. It also hooks into appropriate WordPress actions and
+ * filters to ensure proper functioning throughout different stages of the WordPress lifecycle.
+ */
 class Core
+{
     /**
+     * Setup Plugin Components and Actions
+     *
+     * This method initializes various components and actions of the plugin by calling their respective init methods.
+     * It sets up the core functionalities of the plugin such as code type management, database setup, user roles,
+     * metabox handling, asset management, shortcodes, options, and more. Additionally, it hooks into various actions
+     * and filters, ensuring that the plugin functions as intended during different stages of WordPress execution.
+     *
      * @since 2.4.12
      */
     static function setup()
+    {
+        // Initialize code type management
         CodeType::init();
+        // Initialize database-related functionality
         Database::init();
+        // Initialize user roles and capabilities
         Roles::init();
+        // Initialize metabox handling for posts
         Metabox::init();
+        // Initialize asset management for styles and scripts
         AssetManager::init();
+        // Initialize custom shortcodes for the plugin
         Shortcodes::init();
+        // Initialize options management
         Options::init();
+        Block::init();
+        // Hook to load plugins at the plugins_loaded action
         add_action('plugins_loaded', array(__CLASS__, '_load_plugins'));
+        // Hook to check and handle raw content requests
         add_action("template_redirect", array(__CLASS__, '_check_raw_content'));
+        add_action('widgets_init', array(__CLASS__, 'widgets_init'));
+        add_action('plugins_loaded', array(__CLASS__, 'load_plugin_textdomain'));
+        // check "Unsafe" settings
+        // Hook to register and initialize custom widgets
+        add_action('widgets_init', array(__CLASS__, '_widgets_init'));
+        // Hook to load the plugin's text domain for translations
+        add_action('plugins_loaded', array(__CLASS__, '_load_plugin_textdomain'));
+        // Check if "Unsafe" settings for shortcodes in widgets are enabled
         if (get_option('ci_unsafe_widgets_shortcodes', 0)) {
+            // Apply filters to allow shortcodes in widgets
             add_filter('widget_text', 'shortcode_unautop');
             add_filter('widget_text', 'do_shortcode');
+        }
+        register_activation_hook(__CI_FILE__, array(__CLASS__, 'activate'));
+        register_deactivation_hook(__CI_FILE__, array(__CLASS__, 'deactivate'));
+    }
+    /**
+     * @since 2.4.12
+     */
+    static function load_plugin_textdomain()
+    {
+        // Register activation and deactivation hooks for the plugin
+        register_activation_hook(__CI_FILE__, array(__CLASS__, '_plugin_activate'));
+        register_deactivation_hook(__CI_FILE__, array(__CLASS__, '_plugin_deactivate'));
+    }
+    /**
+     * Load Plugin Text Domain for Localization
+     *
+     * This method is responsible for loading the plugin's text domain for localization purposes.
+     * It allows translations to be loaded from the "languages" directory within the plugin.
+     *
+     * @access private
+     * @since 2.4.12
+     */
+    static function _load_plugin_textdomain()
+    {
+        // Load the text domain for translation
         load_plugin_textdomain("code-injection", FALSE, basename(dirname(__CI_FILE__)) . '/languages/');
+    }
 …
     /**
+     * Load and Execute Unsafe Plugins
+     *
+     * This private method loads and executes potentially unsafe plugins when the appropriate settings are enabled.
+     * It retrieves plugin codes from the database, filters and processes them based on certain conditions, then
+     * executes them using `eval()`. The execution is controlled by options and conditions defined in the database.
+     *
+     * @access private
      * @since 2.2.9
-     * @access private
      */
     static function _load_plugins()
 …
         global $wpdb;
+        // Check if PHP-based unsafe widgets are allowed
         $use_php = get_option('ci_unsafe_widgets_php', false);
         if (!$use_php) {
+            return;
+        }
+            return; // If not allowed, exit early
+        }
+        // Check if ignoring keys for unsafe widgets
         $ignore_keys = get_option('ci_unsafe_ignore_keys', false);
+        // Get keys that trigger activation
         $keys = get_option('ci_unsafe_keys', '');
+        // Retrieve all plugin codes from the database
         $codes = Database::get_codes();
+        // Filter and process plugins based on conditions
         $plugins = array_filter($codes, function ($element) use ($ignore_keys, $keys) {
 …
             extract($options);
+            // Check if the code is intended to be a plugin
             $is_plugin = isset($code_is_plugin) && $code_is_plugin == '1';
+            // Check if the code should be publicly queryable
             $is_public = isset($code_is_publicly_queryable) && $code_is_publicly_queryable == '1';
+            // If code_enabled is not set, default to false
             if (!isset($code_enabled)) {
                 $code_enabled = false;
+            }
+            // Check the code's status
             if (!CodeType::check_code_status($element)) {
                 return false;
+            }
+                return false; // Skip codes with invalid status
+            }
+            // Skip codes that are publicly queryable
             if ($is_public) {
                 return false;
+            }
+            // Skip non-plugin codes or disabled plugins
             if (!$is_plugin || $code_enabled == false) {
                 return false;
+            }
+            // If ignoring keys, include all plugins
             if ($ignore_keys) {
                 return true;
+            }
+            // Check if activator key is in the specified keys
             return isset($code_activator_key) && in_array($code_activator_key, $instance->extract_keys($keys));
         });
+        // Execute and enable filtered plugins
         foreach ($plugins as $p) {
+            // Get code options and disable the plugin initially
             $code_options = Metabox::get_code_options($p->ID);
             $code_options['code_enabled'] = false;
+            // Update code options to disable the plugin
             update_post_meta($p->ID, "code_options", $code_options);
+            // Execute the plugin code using eval()
             eval("?" . ">" . $p->post_content);
+            // Enable the plugin in code options
             $code_options['code_enabled'] = true;
             update_post_meta($p->ID, "code_options", $code_options);
+        }
+    }
+    /**
+     * @since 2.4.12
+     * @access private
+    }
+    /**
+     * Checks and processes raw content for code injection.
+     *
+     * This method checks if the request is targeting the home page or front page and if the "raw" parameter is set.
+     * It processes and serves raw code content with appropriate headers and caching directives.
+     *
+     * @access private
+     * @since 2.4.12
      */
     static function _check_raw_content()
+    {
+        global $wpdb;
+        // Check if the request is on the home page or front page
         if (!is_home() && !is_front_page()) {
             return;
+        }
+        // Check if "raw" parameter is set in the request
         if (!isset($_GET["raw"])) {
             return;
+        }
+        $id = $_GET["raw"];
+        $query = "SELECT $wpdb->posts.*, $wpdb->postmeta.*
+                    FROM $wpdb->posts, $wpdb->postmeta
+                    WHERE $wpdb->posts.ID = $wpdb->postmeta.post_id
+                    AND $wpdb->postmeta.meta_key = 'code_options'
+                    AND $wpdb->posts.post_type = 'code'
+                    AND $wpdb->posts.post_title = '$id'";
+        $results = $wpdb->get_results($query, OBJECT);
+        if (empty($results)) {
+            // Code not found
+        // Get the code ID from the "raw" parameter
+        $codeId = sanitize_text_field($_GET["raw"]);
+        // Retrieve code information based on the ID
+        $code = Database::get_code_by_title($codeId);
+        // Check if code exists
+        if (!$code) {
+            // Record activity for code not found
             Database::record_activity(0, null, 2);
+            return;
+        }
+        $code = $results[0];
+            return;
+        }
+        // Check if code type is authorized
         if (!CodeType::check_code_status($code)) {
+            // Unauthorized Request
+            Database::record_activity(0, $id, 6, $code->ID);
+            return;
+        }
+            // Record activity for unauthorized request
+            Database::record_activity(0, $codeId, 6, $code->ID);
+            return;
+        }
+        // Extract options from code metadata
         $options = maybe_unserialize($code->meta_value);
         extract($options);
+        $active = isset($code_enabled) && $code_enabled == '1';
+        $is_plugin =  isset($code_is_plugin) && $code_is_plugin == '1';
+        $is_public =  isset($code_is_publicly_queryable) && $code_is_publicly_queryable == '1';
+        $no_cache = isset($code_no_cache) && $code_no_cache == '1';
+        if (!$active || $is_plugin || !$is_public) {
+            return;
+        }
+        $render_shortcodes = get_option('ci_code_injection_allow_shortcode', false);
+        Database::record_activity(0, $id, 0, $code->ID);
+        // Determine code status based on options
+        $isActive = isset($code_enabled) && $code_enabled == '1';
+        $isPlugin = isset($code_is_plugin) && $code_is_plugin == '1';
+        $isPublic = isset($code_is_publicly_queryable) && $code_is_publicly_queryable == '1';
+        $noCache = isset($code_no_cache) && $code_no_cache == '1';
+        // Check if code should be processed further
+        if (!$isActive || $isPlugin || !$isPublic) {
+            return;
+        }
+        // Check if shortcodes should be rendered
+        $renderShortcodes = get_option('ci_code_injection_allow_shortcode', false);
+        // Record activity for successful code request
+        Database::record_activity(0, $codeId, 0, $code->ID);
+        // Set appropriate content-type header
         header("Content-Type: $code_content_type; charset=UTF-8", true);
         if ($no_cache) {
+        // Set caching headers based on options
+        if ($noCache) {
             header("Pragma: no-cache", true);
             header("Cache-Control: no-cache, must-revalidate, max-age=0", true);
             header("Expires: Sat, 26 Jul 1997 05:00:00 GMT", true);
         } else {
+            $cache_max_age = get_option('ci_code_injection_cache_max_age', '84600');
+            $cacheMaxAge = get_option('ci_code_injection_cache_max_age', '84600');
             header("Pragma: public", true);
+            header("Cache-Control: max-age=$cache_max_age, public, no-transform", true);
+            header('Expires: ' . gmdate('D, d M Y H:i:s', time() + $cache_max_age) . ' GMT', true);
+        }
+        if ($render_shortcodes) {
+            header("Cache-Control: max-age=$cacheMaxAge, public, no-transform", true);
+            header('Expires: ' . gmdate('D, d M Y H:i:s', time() + $cacheMaxAge) . ' GMT', true);
+        }
+        // Output processed code content and exit
+        if ($renderShortcodes) {
             exit(do_shortcode($code->post_content));
         } else {
             exit($code->post_content);
+        }
+    }
+    /**
+     * @since 2.4.12
+     */
+    static function widgets_init()
+    {
+    }
+    /**
+     * Initialize and register custom widgets.
+     *
+     * This private method is responsible for registering custom widgets during WordPress widget initialization.
+     *
+     * @access private
+     * @since 2.4.12
+     */
+    static function _widgets_init()
+    {
+        // Register the custom widget defined in the Widget class
         register_widget(Widget::class);
+    }
 …
     /**
+     * @since 2.4.12
+     */
+    static function activate()
+    {
+     * Activate Plugin Functionality and Flush Rewrite Rules
+     *
+     * This private method is called when the plugin is activated. It performs necessary actions to ensure
+     * that the plugin's functionality is activated and that rewrite rules are updated to handle new URLs.
+     *
+     * @access private
+     * @since 2.4.12
+     */
+    static function _plugin_activate()
+    {
+        // Flush rewrite rules to update URL handling after activation
         flush_rewrite_rules();
+    }
 …
     /**
+     * @since 2.4.12
+     */
+    static function deactivate()
+    {
+     * Deactivate plugin functionality.
+     *
+     * This private method is responsible for deactivating the plugin's functionality when the plugin is deactivated.
+     * It performs various cleanup actions, including flushing rewrite rules, deleting plugin-related options,
+     * and removing a custom role.
+     *
+     * @access private
+     * @since 2.4.12
+     */
+    static function _plugin_deactivate()
+    {
+        // Flush rewrite rules to update URL handling after deactivation
         flush_rewrite_rules();
+        // Delete plugin-related options from the database
         delete_option('ci_code_injection_db_version');
         delete_option('ci_code_injection_role_version');
+        // Remove the custom "developer" role
         remove_role('developer');
+    }
+}

code-injection/trunk/includes/class-database.php

-                      r2939201
+                      r2967476
 namespace ci;
+use DateInterval;
+use DateTime;
+use DateInterval,  DateTime;
+/**
+ * The Database class handles interactions with the database for tracking and reporting activities.
+ *
+ * This class is responsible for managing database interactions related to tracking and reporting
+ * activities within the context of the code snippet tracking system. It encapsulates various
+ * functions that generate SQL queries for retrieving activity reports and recording activity events.
+ * The class utilizes DateInterval and DateTime objects for handling time calculations and formatting.
+ *
+ * @namespace ci
+ * @since 2.2.6
+ */
 class Database
+{
+    /**
+     * The name of the database table used for storing activity records.
+     *
+     * This constant property stores the name of the database table where activity records
+     * are stored for tracking purposes. The table is used to record various details about
+     * activity events, such as timestamps, IP addresses, post IDs, and error statuses.
+     *
+     * @since 2.2.6
+     */
     const table_activities_name = 'ci_activities';
+    /**
+     * The option name for storing the database version.
+     *
+     * This constant property represents the option name used to store the version of the
+     * database schema. It is utilized to keep track of the database schema version and
+     * facilitate updates when needed.
+     *
+     * @since 2.2.6
+     */
     const db_version_option     = 'ci_db_version';
+    /**
+     * An array of error messages for different error codes.
+     *
+     * This constant property holds an array of error messages associated with specific
+     * error codes. The array provides human-readable explanations for different types
+     * of errors that can occur during activity tracking and reporting.
+     *
+     * @since 2.2.6
+     */
     const db_errors             = array(
             '',                                   // 0 no error
             'PHP scripts are disabled',           // 1
             'Code not found',                     // 2
             'Infinite Loop',                      // 3
             'An unexpected error occurred',       // 4
             'Key not found',                      // 5
             'Unauthorized Request',               // 6
+        '',                                   // 0: No error
+        'PHP scripts are disabled',           // 1
+        'Code not found',                     // 2
+        'Infinite Loop',                      // 3
+        'An unexpected error occurred',       // 4
+        'Key not found',                      // 5
+        'Unauthorized Request',               // 6
     );
+    private static $db_shortcodes_types = ['HTML', 'PHP'];
+    /**
+    private static $db_shortcodes_types = array('HTML', 'PHP');
+    /**
+     * Initializes the plugin by performing necessary setup actions.
+     *
+     * This static function serves as the initialization point for the plugin. It is called
+     * upon plugin activation or when required during the plugin's lifecycle. The primary
+     * purpose of this function is to ensure the proper setup of the plugin's components.
+     * It accomplishes this by invoking the 'check_db' method, which verifies and updates
+     * the plugin's database schema as needed to maintain compatibility.
+     *
      * @since 2.4.12
      */
     static function init()
+    {
+        // Perform the necessary setup actions, including checking and updating the database
         self::check_db();
+    }
 …
+    /**
+    /**
+     * Checks and updates the custom database table used by the plugin.
+     *
+     * This private function is responsible for verifying and updating the database
+     * schema to ensure compatibility with the plugin's version. It compares the stored
+     * database version with the current version of the plugin. If the versions match,
+     * no action is taken. If they differ, the function creates or updates a custom
+     * database table with necessary columns. This table is used to store activity log
+     * entries associated with various events triggered by the plugin.
+     *
      * @since 2.2.6
      */
     private static function check_db()
+    {
+        global $wpdb;
+        $dbv = get_option(self::db_version_option, '');
+        if ($dbv == __CI_VERSION__) {
+            return;
+        global $wpdb;
+        // Retrieve the stored database version from options
+        $stored_db_version = get_option(self::db_version_option, '');
+        // Compare database version with the current plugin version
+        if ($stored_db_version === __CI_VERSION__) {
+            return; // No action needed if versions match
+        }
+        // Define the custom table name for storing activity log entries
         $table_name = self::table_activities_name;
+        // Get charset collation for creating the table
         $charset_collate = $wpdb->get_charset_collate();
+        $sql = "CREATE TABLE $table_name (
+        // SQL query for creating the custom table with required columns
+        $sql = "
+            CREATE TABLE $table_name (
                 id mediumint(9) NOT NULL AUTO_INCREMENT,
                 blog smallint,
 …
                 error smallint,
                 PRIMARY KEY  (id)
+                ) $charset_collate;";
+            ) $charset_collate;
+        ";
+        // Include necessary WordPress upgrade functions
         require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
+        // Execute the SQL query and update the table schema
         dbDelta($sql);
+        update_option(self::db_version_option , __CI_VERSION__);
+    }
+    /**
+        // Update the stored database version option with the current version
+        update_option(self::db_version_option, __CI_VERSION__);
+    }
+    /**
+     * Retrieves an array of code snippets with associated metadata.
+     *
+     * This static function queries the WordPress database to retrieve an array of code
+     * snippet posts along with their associated metadata. It retrieves posts that have
+     * the 'code' post type, have a meta key 'code_options', and have a post date earlier
+     * than the current date and time. The retrieved results are ordered in descending order
+     * based on the post date.
+     *
      * @since 2.4.8
+     *
+     * @return array An array of objects containing code snippet post data and metadata.
      */
     static function get_codes()
 …
         global $wpdb;
+        // Define the table names and placeholders
+        $posts_table = $wpdb->posts;
+        $postmeta_table = $wpdb->postmeta;
+        $code_options_meta_key = 'code_options';
+        $code_post_type = 'code';
+        // Construct the SQL query to retrieve code snippets
+        $query = $wpdb->prepare(
+            "SELECT $posts_table.*, $postmeta_table.*
+            FROM $posts_table, $postmeta_table
+            WHERE $posts_table.ID = $postmeta_table.post_id
+            AND $postmeta_table.meta_key = %s
+            AND $posts_table.post_type = %s
+            AND $posts_table.post_date < NOW()
+            ORDER BY $posts_table.post_date DESC",
+            $code_options_meta_key,
+            $code_post_type
+        );
+        // Execute the query and fetch results as an array of objects
+        return $wpdb->get_results($query);
+    }
+    /**
+     * Retrieves a code snippet by its title.
+     *
+     * This function queries the WordPress database to retrieve a code snippet
+     * post based on the provided title. It fetches both post and postmeta
+     * information associated with the given title.
+     *
+     * @since 2.4.14
+     *
+     * @param string $title The title of the code snippet to retrieve.
+     * @return object|null An object containing the code snippet's post and postmeta data as properties,
+     *                    or null if no matching snippet is found.
+     */
+    static function get_code_by_title($title)
+    {
+        global $wpdb;
+        // Construct the SQL query to retrieve the code snippet by title
         $query = "SELECT $wpdb->posts.*, $wpdb->postmeta.*
                 FROM $wpdb->posts, $wpdb->postmeta
                 WHERE $wpdb->posts.ID = $wpdb->postmeta.post_id
                 AND $wpdb->postmeta.meta_key = 'code_options'
+                AND $wpdb->posts.post_title = '$title'
                 AND $wpdb->posts.post_type = 'code'
+                AND $wpdb->posts.post_date < NOW()
+                ORDER BY $wpdb->posts.post_date DESC";
+        return $wpdb->get_results($query, OBJECT);
+    }
+    /**
+                LIMIT 1";
+        // Execute the query and fetch a single row as an object
+        $row = $wpdb->get_row($query);
+        // If no matching snippet is found, return null
+        if (!$row) {
+            return null;
+        }
+        return $row;
+    }
+    /**
+     * Retrieves a code snippet by its unique slug.
+     *
+     * This function queries the WordPress database to retrieve a code snippet
+     * post based on the provided unique slug. It fetches both post and postmeta
+     * information associated with the given slug.
+     *
      * @since 2.4.8
+     *
+     * @param string $slug The unique slug of the code snippet to retrieve.
+     * @return object|null An object containing the code snippet's post and postmeta data as properties,
+     *                    or null if no matching snippet is found.
      */
     static function get_code_by_slug($slug)
+    {
+        global $wpdb;
+        global $wpdb;
+        // Construct the SQL query to retrieve the code snippet by slug
         $query = "SELECT $wpdb->posts.*, $wpdb->postmeta.*
                 FROM $wpdb->posts, $wpdb->postmeta
 …
                 LIMIT 1";
+        $posts = $wpdb->get_results($query, ARRAY_A);
+        if (empty($posts)) {
+        // Execute the query and fetch a single row as an object
+        $row = $wpdb->get_row($query);
+        // If no matching snippet is found, return null
+        if (!$row) {
             return null;
+        }
+        return $posts[0];
+    }
+    /**
+        return $row;
+    }
+    /**
+     * Records an activity event in the database for tracking purposes.
+     *
+     * This static function is responsible for recording activity events in the database
+     * for tracking purposes. It records various details such as the event type, associated
+     * code snippet, error status, and relevant identifiers like IP address, post ID, blog ID,
+     * and user ID. The function first checks whether the event should be tracked based on
+     * provided conditions. If tracking is enabled, the function inserts a new activity record
+     * into the database table, capturing key information about the event.
+     *
      * @since 2.2.6
+     *
+     * @param int $type The type of activity event (0 for HTML, CSS, JavaScript, 1 for PHP, etc.).
+     * @param string|null $code The code snippet associated with the activity.
+     * @param int $error The error status (0 for no error, 1 for error).
+     * @param int|null $id The post ID or identifier associated with the event (used in specific cases).
      */
     static function record_activity($type = 0, $code = null, $error = 0, $id = null)
+    {
         global $wpdb, $post;
+        if ($code != null && $type == 0 && $id != null) {
+        // Check if tracking is required based on provided conditions
+        if ($code !== null && $type === 0 && $id !== null) {
             $co = Metabox::get_code_options($id);
+            if ($co['code_tracking'] == false) {
+                return;
+            if (!$co['code_tracking']) {
+                return; // No tracking needed
+            }
+        }
+        $ip         = Helpers::get_ip_address();
+        // Capture essential information for the activity record
+        $ip = Helpers::get_ip_address();
         $table_name = self::table_activities_name;
+        $time       = current_time('mysql', 1);
+        $start      = new DateTime($time);
+        $blog       = get_current_blog_id();
+        $user       = get_current_user_id();
+        $time = current_time('mysql', 1);
+        $start = new DateTime($time);
+        $blog = get_current_blog_id();
+        $user = get_current_user_id();
         $start->sub(new DateInterval("PT10S"));
+        $start_date       = $start->format('Y-m-d H:i:s');
+        $post_param       = isset($post->ID) && is_single() ? $post->ID : null;
+        $post_query_param = is_null($post_param)  ? "`post` IS NULL" : "`post` = '$post_param'";
+        $ip_query_param   =  is_null($ip)  ? "`ip` IS NULL" : "`ip` = '$ip'";
+        $query  =  "SELECT COUNT(*) FROM `$table_name` WHERE
+                            $ip_query_param AND
+                            `type` = '$type' AND
+                            `blog` = '$blog' AND
+                            `user` = '$user' AND
+                            $post_query_param AND
+                            `code` = '$code' AND
+                            `time` BETWEEN '$start_date' AND '$time'";
+        $start_date = $start->format('Y-m-d H:i:s');
+        $post_param = isset($post->ID) && is_single() ? $post->ID : null;
+        $post_query_param = is_null($post_param) ? "`post` IS NULL" : "`post` = '$post_param'";
+        $ip_query_param = is_null($ip) ? "`ip` IS NULL" : "`ip` = '$ip'";
+        // Construct and execute query to check if similar event was recorded recently
+        $query = $wpdb->prepare("
+            SELECT COUNT(*)
+            FROM `$table_name`
+            WHERE $ip_query_param
+            AND `type` = %d
+            AND `blog` = %d
+            AND `user` = %d
+            AND $post_query_param
+            AND `code` = %s
+            AND `time` BETWEEN %s AND %s",
+            $type, $blog, $user, $code, $start_date, $time
+        );
         $count = $wpdb->get_var($query);
+        if ($count == 0) {
+            /**
+             * type 0 for HTML, CSS and, javascript
+             * type 1 for PHP
+             */
+        // If no similar event was recently recorded, insert the activity record
+        if ($count === 0) {
+            // Insert the activity record into the database
             $wpdb->insert(
                 self::table_activities_name,
+                [
+                array(
                     'time'  => $time,
                     'ip'    => $ip,
 …
                     'code'  => $code,
                     'error' => $error
+                ]
+                )
             );
+        }
 …
+    /**
+    /**
+     * Generates a SQL query for retrieving a weekly activity report for a specific code snippet.
+     *
+     * This static function constructs a SQL query for retrieving a weekly activity report
+     * for a given code snippet within a specified time range. The query calculates metrics
+     * such as unique hits, total hits, and total errors for each day of the week and each hour
+     * of the day within the specified range. The report is organized by weekday and hour,
+     * providing insights into the snippet's activity patterns.
+     *
      * @since 2.4.5
+     *
+     * @param int $post_id The ID of the code snippet post.
+     * @param DateTime $start The start date of the report's time range.
+     * @param DateTime $end The end date of the report's time range.
+     * @return string A SQL query for generating the weekly activity report.
      */
     static function get_weekly_report_query($post_id, $start, $end)
+    {
+        global $wpdb;
         $table_name = self::table_activities_name;
+        // get post title
+        // Convert the start and end dates to MySQL format
+        $start = $start->format('Y-m-d H:i:s');
+        $end   = $end->format('Y-m-d H:i:s');
+        // Get the title of the code snippet based on its post ID
         $post = get_post($post_id);
         $code = $post->post_title;
+        // convert dates to mysql format
+        // Construct and return the SQL query for generating the weekly report
+        return $wpdb->prepare(
+            "
+            SELECT time, DAYOFWEEK(time) AS weekday, HOUR(time) AS hour,
+                COUNT(DISTINCT ip) AS unique_hits,
+                COUNT(*) AS total_hits,
+                SUM(CASE WHEN error != '' THEN 1 ELSE 0 END) AS total_errors
+            FROM $table_name
+            WHERE code = %s AND (time BETWEEN %s AND %s)
+            GROUP BY weekday, hour",
+            $code,
+            $start,
+            $end
+        );
+    }
+    /**
+     * Generates a SQL query for retrieving a monthly activity report for a specific code snippet.
+     *
+     * This static function constructs a SQL query for retrieving a monthly activity report
+     * for a given code snippet within a specified time range. The query calculates metrics
+     * such as unique hits, total hits, and total errors for each day within the specified range.
+     * The report is organized by month and day, providing insights into the snippet's activity.
+     *
+     * @since 2.4.5
+     *
+     * @param int $post_id The ID of the code snippet post.
+     * @param DateTime $start The start date of the report's time range.
+     * @param DateTime $end The end date of the report's time range.
+     * @return string A SQL query for generating the monthly activity report.
+     */
+    static function get_monthly_report_query($post_id, $start, $end)
+    {
+        global $wpdb;
+        $table_name = self::table_activities_name;
+        // Convert the start and end dates to MySQL format
         $start = $start->format('Y-m-d H:i:s');
         $end   = $end->format('Y-m-d H:i:s');
+        return "SELECT time, WEEKDAY(time) weekday, HOUR(time) hour,
+                        COUNT(DISTINCT ip) unique_hits,
+                        COUNT(*) total_hits,
+                        SUM(case when error = '' then 0 else 1 end) total_errors
+                        FROM $table_name
+                        WHERE code='$code' AND (time BETWEEN '$start' AND '$end')
+                        GROUP BY weekday, hour";
+    }
+    /**
+     * @since 2.4.5
+     */
+    static function get_monthly_report_query($post_id, $start, $end)
+    {
+        $table_name = self::table_activities_name;
+        // get post title
+        $post = get_post($post_id);
+        $code = $post->post_title;
+        // convert dates to mysql format
+        $start = $start->format('Y-m-d H:i:s');
+        $end   = $end->format('Y-m-d H:i:s');
+        return "SELECT time, MONTHNAME(time) month, DAYOFMONTH(time) day,
+                        COUNT(DISTINCT ip) unique_hits,
+                        COUNT(*) total_hits,
+                        SUM(case when error = '' then 0 else 1 end) total_errors
+                        FROM $table_name
+                        WHERE code='$code' AND (time BETWEEN '$start' AND '$end')
+                        GROUP BY month, day";
+    }
+        // Construct and return the SQL query for generating the monthly report
+        return $wpdb->prepare(
+            "
+            SELECT time, MONTHNAME(time) AS month, DAYOFMONTH(time) AS day,
+                COUNT(DISTINCT ip) AS unique_hits,
+                COUNT(*) AS total_hits,
+                SUM(CASE WHEN error != '' THEN 1 ELSE 0 END) AS total_errors
+            FROM $table_name
+            WHERE code = (SELECT post_title FROM $wpdb->posts WHERE ID = %d) AND (time BETWEEN %s AND %s)
+            GROUP BY month, day",
+            $post_id,
+            $start,
+            $end
+        );
+    }
+}

code-injection/trunk/includes/class-heatmap.php

-                      r2939201
+                      r2967476
 namespace ci;
+/**
+ * A class for rendering a heatmap visualization.
+ *
+ * This class generates and displays a heatmap based on provided data.
+ * @since 2.2.6
+ */
 class Heatmap
+{
-    private $data = [];
+    private $dowmap = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+    private $data = array();
+    private $dowmap = array('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');
+    /**
+     * Constructor for initializing the Heatmap with data.
+     *
+     * @param array $data An array containing heatmap data.
+     */
     function __construct($data)
+    {
         $this->data = $data;
+    }
     /**
+     * Render the heatmap.
+     *
+     * This function generates and displays the heatmap visualization based on the provided data.
+     *
      * @since 2.2.6
      */
     function render()
+    {
+        // Determine the maximum value for color scaling
         $max = 10;
+        if (count($this->data) > 0) {
+        if (!empty($this->data)) {
             $max = max(array_map(function ($item) {
                 return intval($item["total_hits"]);
 …
         echo "<div class=\"gdcp-heatmap-container\">";
+        // Generate rows for each day of the week
         foreach (range(0, 6) as $weekday) {
             echo "<div class=\"gdcp-heatmap-row\">";
+            // Display the day of the week abbreviation
             if ($weekday % 2 != 0) {
                 echo "<span class=\"dow\">{$this->dowmap[$weekday]}</span>";
 …
+            }
+            // Generate cells for each hour of the day
             foreach (range(0, 24) as $hour) {
 …
                     $hits = intval($data[0]["total_hits"]);
                     $plural = $hits > 1;
 …
                     $time = date_i18n("M j, H:i", strtotime($data[0]["time"]));
+?>
+                    <div class="gdcp-heatmap-cell" style="background-color: <?php echo $color; ?>;">
+                        <p class="info">
+                            <strong><?php echo $hits . ($plural ? " hits - " : " hit - "); ?></strong><span><?php echo $time; ?><span>
+                                    <i class="arrow-down"></i>
+                        </p>
+                    </div>
+<?php
+                    // Display heatmap cell with hit information
+                    echo "<div class=\"gdcp-heatmap-cell\" style=\"background-color: $color;\">";
+                    echo "<p class=\"info\"><strong>$hits " . ($plural ? "hits - " : "hit - ") . "</strong><span>$time</span><i class=\"arrow-down\"></i></p>";
+                    echo "</div>";
                 } else {
                     echo "<div class='gdcp-heatmap-cell'></div>";
+                }
 …
+    }
     /**
+     * Generate a visual representation of the heatmap color scale.
+     *
+     * @return string A string containing HTML markup for the color scale.
      * @since 2.2.6
      */
     static function map()
+    {
         $result = "<span class=\"gdcp-chart-colors\">";
         foreach (range(0, 9) as $i) {
             $color = self::get_color($i, 9);
+            $result = $result . "<i class=\"gradient\" style=\"background-color: $color;\" ></i>";
+            $result .= "<i class=\"gradient\" style=\"background-color: $color;\"></i>";
+        }
         $result = $result . "</span>";
+        $result .= "</span>";
         return $result;
 …
     /**
+     * Generate a color based on the value and maximum value for color scaling.
+     *
+     * @param int $value The value for which to generate a color.
+     * @param int $max The maximum value for color scaling.
+     * @return string A color in HSL format.
      * @since 2.2.6
      */
     static function get_color($value, $max)
+    {
         $h = (1.0 - ($value / $max)) * 240;
         return "hsl(" . $h . ", 100%, 50%)";
+    }

code-injection/trunk/includes/class-helpers.php

-                      r2939201
+                      r2967476
  */
 namespace ci;
+/**
+ * The Helpers class provides utility functions for various tasks within the code tracking system.
+ *
+ * This class offers a collection of static utility functions that are used across the code tracking system.
+ * These functions assist in tasks such as determining the type of page being displayed, checking if a specific
+ * page is an edit page, identifying settings pages, retrieving the user's IP address, and obtaining asset URLs.
+ *
+ * @namespace ci
+ * @since 2.4.12
+ */
 class Helpers
+{
 …
     /**
+     * Checks if the current page is related to managing code snippets.
+     *
+     * This static function determines whether the current page is associated with code snippet management.
+     * It checks if the current page is either a new code creation page or an edit page for an existing code snippet.
+     * The function examines the page type using the internal `is_edit_page` function, and additionally checks
+     * if the post type matches 'code' to confirm that it's a code management page.
+     *
+     * @return bool True if the current page is a code management page, false otherwise.
+     *
      * @since 2.4.12
      */
 …
+    {
+        // Check if it's a new code creation page
         if (self::is_edit_page('new')) {
             if (isset($_GET['post_type']) && $_GET['post_type'] == 'code') {
 …
+        }
+        // Check if it's an edit page for an existing code snippet
         if (self::is_edit_page('edit')) {
             global $post;
             if ('code' == get_post_type($post)) {
                 return true;
+            }
+        }
+        }
+        // If neither edit nor new code page, or post type is not 'code', it's not a code management page
         return false;
+    }
+    /**
+    }
+    /**
+     * Checks if the current page is an edit or new post creation page within the admin area.
+     *
+     * This static function determines whether the current page is an edit page or a new post creation page
+     * within the WordPress admin area. It accepts an optional parameter to specify the type of page to check:
+     * 'edit' for edit page and 'new' for new post creation page. The function examines the global variable `$pagenow`
+     * to identify the current page and compares it with relevant page slugs to determine if the page matches the type.
+     *
+     * @param string|null $new_edit Specifies the type of page to check ('edit' for edit page, 'new' for new post creation page).
+     * @return bool True if the current page is an edit or new post creation page, false otherwise.
+     *
      * @since 2.4.12
      */
 …
         global $pagenow;
+        // Check if it's within the admin area
         if (!is_admin()) {
             return false;
+        }
+        if ($new_edit == "edit") {
+            return in_array($pagenow, array('post.php'));
+        }
+        if ($new_edit == "new") {
+            return in_array($pagenow, array('post-new.php'));
+        }
+        return in_array($pagenow, array('post.php', 'post-new.php'));
+    }
+    /**
+        switch ($new_edit) {
+            // Check if it's an edit page
+            case "edit":
+                return in_array($pagenow, array('post.php'));
+            // Check if it's a new post creation page
+            case "new":
+                return in_array($pagenow, array('post-new.php'));
+            // Check if it's either an edit or new post creation page
+            default:
+                return in_array($pagenow, array('post.php', 'post-new.php'));
+        }
+    }
+    /**
+     * Checks if the current page is a settings page within the WordPress admin area.
+     *
+     * This static function determines if the current page is a settings page within the WordPress admin area.
+     * It checks if the `get_current_screen` function exists, and if not, assumes it's not a settings page.
+     * If the function exists, it retrieves the current screen object and examines the screen ID to determine
+     * if it corresponds to the target settings screen ID, 'ci-general'.
+     *
+     * @return bool True if the current page is a settings page, false otherwise.
+     *
      * @since 2.4.12
      */
     static function is_settings_page()
+    {
+        // Define the target settings screen ID
+        $TARGET_SCREEN_ID = 'ci-general';
+        // Check if the required function exists
         if (!function_exists('get_current_screen')) {
             return false;
+        }
+        // Retrieve the current screen object
         $screen = get_current_screen();
+        return strpos($screen->id , 'ci-general') !== false;
+    }
+    /**
+        // Check if the screen ID matches the target settings screen ID
+        return $screen->id === $TARGET_SCREEN_ID;
+    }
+    /**
+     * Retrieves the user's IP address from various possible sources.
+     *
+     * This static function retrieves the user's IP address from a list of potential headers and server variables
+     * that might contain the IP address. It iterates through these sources, validates the IP addresses,
+     * and returns the first valid IP address found. If no valid IP address is found, it returns "Unknown".
+     *
+     * @return string The user's IP address if found, otherwise "Unknown".
+     *
      * @since 2.4.12
      */
     static function get_ip_address()
+    {
         foreach ([
+        // List of possible headers and server variables containing the IP address
+        $ip_sources = [
             'HTTP_CLIENT_IP',
             'HTTP_X_FORWARDED_FOR',
 …
             'HTTP_FORWARDED',
             'REMOTE_ADDR'
+        ] as $key) {
+            if (array_key_exists($key, $_SERVER) === true) {
+                foreach (explode(',', $_SERVER[$key]) as $ip) {
+        ];
+        // Iterate through each source to find the user's IP address
+        foreach ($ip_sources as $source) {
+            if (array_key_exists($source, $_SERVER)) {
+                foreach (explode(',', $_SERVER[$source]) as $ip) {
                     $ip = trim($ip);
+                    // Validate the IP address and exclude private and reserved ranges
                     if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE) !== false) {
                         return $ip ?: "Unknown";
+                        return $ip ?: "Unknown"; // Return the IP address or "Unknown"
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * @since 2.4.12
+     */
+    static function get_asset_url($path)
+    {
+        return plugins_url("/assets/" . rtrim(ltrim($path, "/"), "/"), __CI_FILE__);
+    }
+        return "Unknown"; // Return "Unknown" if no valid IP address is found
+    }
+    /**
+     * Retrieves the URL of an asset using the provided relative path.
+     *
+     * This static function constructs the URL for an asset using the provided relative path within the plugin's assets directory.
+     * It appends the provided path to the assets directory path, ensuring proper formatting by utilizing the `trailingslashit` function.
+     * The resulting URL is based on the WordPress `plugins_url` function and the plugin's main file constant `__CI_FILE__`.
+     *
+     * @param string $relative_path The relative path of the asset within the plugin's assets directory.
+     * @return string The complete URL of the asset.
+     *
+     * @since 2.4.12
+     */
+    static function get_asset_url($relative_path)
+    {
+        // Construct the URL by appending the relative path to the assets directory path
+        $assets_dir_path = trailingslashit("/assets/");
+        $asset_url = plugins_url($assets_dir_path . ltrim($relative_path, "/"), __CI_FILE__);
+        return $asset_url;
+    }
+}

code-injection/trunk/includes/class-metabox.php

-                      r2939201
+                      r2967476
     static function init()
+    {
+        add_action('add_meta_boxes',  array(__CLASS__, 'add_meta_box'));
+        add_action('save_post',  array(__CLASS__, 'save_post'));
+    }
+    /**
+        add_action('add_meta_boxes',  array(__CLASS__, '_add_meta_box'));
+        add_action('save_post',  array(__CLASS__, '_save_post'));
+    }
+    /**
+     * @access private
      * @since 2.2.8
      */
     static function add_meta_box()
+    static function _add_meta_box()
+    {
 …
     /**
+     * @access private
      * @since 2.2.8
      */
     static function save_post($id)
+    static function _save_post($id)
+    {

code-injection/trunk/includes/class-options.php

-                      r2939201
+                      r2967476
 namespace ci;
+/**
+ * A class for managing plugin options and settings.
+ *
+ * This class handles the registration of settings, options, and the settings page.
+ *
+ * @since 2.4.12
+ */
 class Options
+{
+    const option_group = 'ci-general';
+    /**
+    const option_group = 'ci-general'; // The option group used for registering settings
+    /**
+     * Initialize the Options class by adding necessary action hooks.
+     *
+     * This function is called when the class is loaded and adds action hooks to initialize the admin settings page and menu.
+     *
      * @since 2.4.12
      */
     static function init()
+    {
+        add_action('admin_init', array( __CLASS__ , '_admin_init'));
+        add_action('admin_menu', array( __CLASS__ , '_admin_menu'));
+    }
+    /**
+        add_action('admin_init', array(__CLASS__, '_admin_init'));
+        add_action('admin_menu', array(__CLASS__, '_admin_menu'));
+    }
+    /**
+     * Get the array of unsafe keys from the option.
+     *
+     * @return array An array of unsafe keys.
      * @since 2.4.12
      */
 …
+    }
+    /**
+    /**
+     * Extract keys from a comma-separated string.
+     *
+     * @param string $text The comma-separated string containing keys.
+     * @return array An array of keys.
      * @since 2.4.12
      */
 …
+    }
+    /**
+     * @since 2.4.12
+     * @access private
+     */
+    static function _admin_menu(){
+    /**
+     * Add the plugin settings page to the admin menu.
+     *
+     * @since 2.4.12
+     * @access private
+     */
+    static function _admin_menu()
+    {
         add_submenu_page(
             'options-general.php',
 …
             __('Code Injection', 'code-injection'),
             'manage_options',
             self::option_group ,
             array(__CLASS__ , '_settings_page_cb')
+            self::option_group,
+            array(__CLASS__, '_settings_page_cb')
         );
+    }
     /**
+    }
+    /**
+     * Initialize the admin settings and register settings sections and fields.
+     *
      * @since 2.4.12
      * @access private
 …
     static function _admin_init()
+    {
+        // Settings Section
+        // Register a settings section
         add_settings_section('wp_code_injection_plugin', "", "__return_false", self::option_group);
         // register code settings
+        // Register code-related settings
         register_setting(self::option_group, 'ci_code_injection_cache_max_age', ['default' => '84600']);
-        // register "CI" settings
         register_setting(self::option_group, 'ci_code_injection_allow_shortcode', ['default' => false]);
         // register "Unsafe" settings
+        // Register unsafe-related settings
         register_setting(self::option_group, 'ci_unsafe_widgets_shortcodes', ['default' => false]);
         register_setting(self::option_group, 'ci_unsafe_keys', ['default' => '']);
 …
         register_setting(self::option_group, 'ci_unsafe_ignore_keys', ['default' => false]);
         self::add_settings_field('ci_code_injection_cache_max_age', '84600',  esc_html__("Code Options", "code-injection"));
+        // Add settings fields
+        self::add_settings_field('ci_code_injection_cache_max_age', '84600', esc_html__("Code Options", "code-injection"));
         self::add_settings_field('ci_code_injection_allow_shortcode', false, esc_html__("Shortcodes", "code-injection"));
         self::add_settings_field('ci_unsafe_widgets_shortcodes', false);
         self::add_settings_field('ci_unsafe_widgets_php', false);
         self::add_settings_field('ci_unsafe_ignore_keys', false,  esc_html__("Activator Keys", "code-injection"));
+        self::add_settings_field('ci_unsafe_ignore_keys', false, esc_html__("Activator Keys", "code-injection"));
         self::add_settings_field('ci_unsafe_keys');
+    }
 …
     /**
+     * @since 2.4.12
+     * @access private
+     */
+    static function _settings_section_cb()
+    {
+    }
+    /**
+     * Render the settings page content.
+     *
+     * This function is called to render the plugin settings page in the WordPress admin.
+     * It displays the registered settings sections and fields.
+     *
      * @since 2.4.12
      * @access private
 …
     /**
+     * @since 2.4.12
+     * Add a settings field to the options page.
+     *
+     * This function adds a settings field to the plugin options page in the WordPress admin.
+     * It allows users to input values or make selections for various plugin settings.
+     *
+     * @param string $id The unique identifier for the setting.
+     * @param mixed $default The default value for the setting.
+     * @param string $title The title of the settings field.
+     * @param string $section The settings section to which the field belongs.
+     * @param string $page The option group identifier.
+     * @since 2.4.12
+     * @access private
      */
     private static function add_settings_field($id, $default = '', $title = '', $section = 'wp_code_injection_plugin', $page = self::option_group)
 …
     /**
+     * Generate a checkbox input for settings.
+     *
+     * This function generates a checkbox input field for the plugin settings.
+     * It allows users to enable or disable certain plugin features.
+     *
+     * @param string $key The option key.
+     * @param bool $value The current value of the checkbox.
+     * @param string $description The description of the checkbox.
      * @since 2.4.12
      */
 …
+    /**
+    /**
+     * Render the settings field callback.
+     *
+     * This function renders the content of a settings field callback.
+     * It generates different types of inputs based on the field type.
+     *
+     * @param array $args The arguments for the settings field.
      * @since 2.4.12
      * @access private
 …
+    {
         $key        = $args['label_for'];
         $default    = isset($args['default']) ? $args['default'] : '';
         $value      = get_option($key, $default);
+        $key = $args['label_for'];
+        $default = isset($args['default']) ? $args['default'] : '';
+        $value = get_option($key, $default);
         switch ($key) {
             case 'ci_code_injection_cache_max_age':
                 printf('<p>%1$s</p>', esc_html__('Cache max-age (Seconds)', 'code-injection'));
                 printf('<input class="regular-text" type="number" value="%1$s" id="%2$s" name="%2$s" />', $value, $key);
+                printf('<p class="description">e.g.&nbsp;&nbsp;&nbsp;&nbsp;%1$s</p>', $default);
+                break;
+                printf('<p class="description">%1$s</p>', esc_html__('e.g. 84600', 'code-injection'));
+                break;
             case 'ci_unsafe_keys':
+                printf('<p class="ack-head-wrapper"><span class="ack-header"><strong>%1$s</strong></span><a class="button ack-new" href="javascript:void(0);" id="ci_generate_key">%2$s</a></p>', esc_html__("Keys:", "code-injection"), esc_html__("Generate Key", "code-injection"));
+                printf('<p><textarea data-placeholder="%1$s" class="large-text code" id="%2$s" name="%2$s">%3$s</textarea></p>', esc_html__("Enter Keys:", "code-injection"), $key, $value);
+                printf('<p class="description">e.g.&nbsp;&nbsp;&nbsp;&nbsp;key-2im2a5ex4,&nbsp;&nbsp;key-6dp7mwt05 ...</p>', $default);
+                break;
+                printf('<p class="ack-head-wrapper"><span class="ack-header"><strong>%1$s</strong></span><a class="button ack-new" href="javascript:void(0);" id="ci_generate_key">%2$s</a></p>',
+                    esc_html__("Keys:", "code-injection"), esc_html__("Generate Key", "code-injection"));
+                printf('<p><textarea data-placeholder="%1$s" class="large-text code" id="%2$s" name="%2$s">%3$s</textarea></p>',
+                    esc_html__("Enter Keys:", "code-injection"), $key, $value);
+                printf('<p class="description">%1$s</p>', esc_html__('e.g. key-2im2a5ex4, key-6dp7mwt05 ...', 'code-injection'));
+                break;
             case 'ci_code_injection_allow_shortcode':
                 self::checkbox($key, $value, esc_html__("Allow nested shortcodes", "code-injection"));
+                break;
+                break;
             case 'ci_unsafe_ignore_keys':
                 self::checkbox($key, $value, esc_html__("Ignore activator keys", "code-injection"));
+                break;
+                break;
             case 'ci_unsafe_widgets_shortcodes':
                 self::checkbox($key, $value, esc_html__("Allow shortcodes in the Custom HTML widget", "code-injection"));
+                break;
+                break;
             case 'ci_unsafe_widgets_php':
                 self::checkbox($key, $value, sprintf(esc_html__("Enable %s shortcode", "code-injection"), "<code>[unsafe key='']</code>"));
+                printf(
+                    '<p class="description">%1$s</p>',
+                printf('<p class="description">%1$s</p>',
                     sprintf(
                         esc_html__('See %1$s for more information.', "code-injection"),
 …
+                    )
                 );
                 break;
+        }

code-injection/trunk/includes/class-roles.php

-                      r2939201
+                      r2967476
 namespace ci;
+/**
+ * Manages custom roles and capabilities related to the Code Injection plugin.
+ *
+ * This class handles the registration and updates of custom user roles and capabilities for the Code Injection plugin.
+ * It ensures that the 'Developer' role is properly registered with specific capabilities required for the plugin's functionality.
+ *
+ * @since 2.4.12
+ */
 class Roles
+{
+    /**
+     * Initializes custom roles and capabilities.
+     *
+     * Registers actions to perform role registration and capability updates.
+     *
+     * @since 2.4.12
+     */
+    public static function init()
+    {
+        add_action('admin_init', array(__CLASS__, '_register_developer_role'));
+        add_action('admin_init', array(__CLASS__, '_update_capabilities'));
+    }
     /**
+     * Registers the 'Developer' custom role and sets its capabilities.
+     *
+     * This method registers the 'Developer' role with specific capabilities required for the Code Injection plugin.
+     *
+     * @access private
+     *
      * @since 2.4.12
      */
+    static function init(){
+        add_action('admin_init' , array(__CLASS__ , '_register_roles'));
+        add_action('admin_init' , array(__CLASS__ , '_update_caps'));
+    }
+    static function _register_developer_role()
+    {
+        // Get the 'Developer' role object
+        $developerRole = get_role('developer');
+        // Get the stored role version from options
+        $roleVersion = get_option('ci_role_version', '');
+    /**
+     * @since 2.4.12
+     * @access private
+     */
+    static function _register_roles()
+    {
+        $developer      = get_role('developer');
+        $role_version   = get_option('ci_role_version', '');
+        if ($role_version == __CI_VERSION__ && isset($developer)) {
+        // Check if role version matches and 'Developer' role exists
+        if ($roleVersion === __CI_VERSION__ && isset($developerRole)) {
+            // Role is already registered with correct version, no need to re-register
             return;
+        }
+        // Remove the existing 'Developer' role if it exists
         remove_role('developer');
+        // Add the 'Developer' role with specific capabilities
         add_role(
             'developer',
             esc_html__('Developer', "code-injection"),
+            [
+            array(
                 'read' => true,
                 'edit_posts' => false,
 …
                 'publish_posts' => false,
                 'upload_files' => true,
+            ]
+            )
         );
+        // Update the stored role version to the current version
+        update_option('ci_role_version', __CI_VERSION__);
-        update_option('ci_role_version', __CI_VERSION__);
+    }
+    /**
+     * Updates capabilities for specified roles.
+     *
+     * Adds capabilities related to managing code snippets for 'developer' and 'administrator' roles.
+     *
+     * @access private
+     *
+     * @since 2.2.6
+     */
+    static function _update_capabilities()
+    {
+        // List of roles to update capabilities for
+        $rolesToUpdate = array('developer', 'administrator');
+    /**
+     * @since 2.2.6
+     * @access private
+     */
+    static function _update_caps()
+    {
+        // Iterate through each role to update capabilities
+        foreach ($rolesToUpdate as $role) {
+            // Get the role object for the current role
+            $roleObject = get_role($role);
+        $roles = array('developer', 'administrator');
+        foreach ($roles as $role) {
+            $ur = get_role($role);
+            if (!isset($ur)) {
+            // Check if the role object exists
+            if (!isset($roleObject)) {
+                // If role object doesn't exist, move to the next role
                 continue;
+            }
+            foreach (array(
+                'publish',  'delete',  'delete_others', 'delete_private',
+                'delete_published',  'edit', 'edit_others',  'edit_private',
+            // List of capabilities to be added
+            $capabilities = array(
+                'publish', 'delete', 'delete_others', 'delete_private',
+                'delete_published', 'edit', 'edit_others', 'edit_private',
                 'edit_published', 'read_private'
+            ) as $cap) {
+                $ur->add_cap("{$cap}_code");
+                $ur->add_cap("{$cap}_codes");
+            );
+            // Iterate through each capability to add to the role
+            foreach ($capabilities as $capability) {
+                // Add the capability for singular code management
+                $roleObject->add_cap("{$capability}_code");
+                // Add the capability for plural code management
+                $roleObject->add_cap("{$capability}_codes");
+            }
+        }
+    }
+}

code-injection/trunk/includes/class-shortcodes.php

r2943916	r2967476
154	154
155	155	if (!empty($id)) {
156		$code = ~~get_page_by_title($id, OBJECT, 'code'~~);
	156	$code = Database::get_code_by_title($id);
157	157	} else {
158	158	$code = Database::get_code_by_slug($slug);

code-injection/trunk/includes/class-widget.php

-                      r2943916
+                      r2967476
 use WP_Widget;
+/**
+ * Custom WordPress widget for Code Injection.
+ *
+ * This class extends the WP_Widget class to create a custom widget named 'Code Injection'.
+ * It allows users to insert code snippets in HTML, CSS, and JavaScript into their website's sidebar
+ * or other widgetized areas. The widget provides a user-friendly interface to select from available code snippets.
+ *
+ * @subpackage Widget
+ *
+ * @since 0.9.0
+ */
 class Widget extends WP_Widget
+{
     /**
+     *  @since 0.9.0
+     * Constructor for the Widget class.
+     *
+     * Sets up the widget with a unique ID, name, and description.
+     *
+     * @since 0.9.0
      */
     function __construct()
 …
             'wp_code_injection_plugin_widget',
             esc_html__('Code Injection', 'code-injection'),
+            ['description' => esc_html__("This plugin allows you to effortlessly create custom ads for your website. Inject code snippets in HTML, CSS, and JavaScript, write and run custom plugins on-the-fly, and take your website's capabilities to the next level.", 'code-injection')]
+            array(
+                'description' => esc_html__("This plugin allows you to effortlessly create custom ads for your website. Inject code snippets in HTML, CSS, and JavaScript, write and run custom plugins on-the-fly, and take your website's capabilities to the next level.", 'code-injection')
+            )
         );
+    }
 …
     /**
+     * Outputs the content of the widget.
+     *
+     * Displays the selected code snippet in the widget area based on the user's choice.
+     *
+     * @param array $args Widget arguments.
+     * @param array $instance Saved values from the widget form.
+     *
      * @since 0.9.0
      */
     function widget($args, $instance)
+    {
         $title = apply_filters('widget_title', $instance['title']);
+        $title = apply_filters('widget_title', isset( $instance['title'] ) ? $instance['title'] : '0');
         if ($title == '0') {
             return;
+        if ($title !== '0') {
+            echo do_shortcode("[inject id='$title']");
+        }
-        //output
-        echo do_shortcode("[inject id='$title']");
+    }
     /**
+     * Outputs the widget form in the WordPress admin.
+     *
+     * Provides a form to select and display available code snippets as options in the widget settings.
+     *
+     * @param array $instance Previously saved values from the widget form.
+     *
      * @since 0.9.0
      */
 …
+    {
+        $label     = esc_html__('Code ID:', 'code-injection');
+        $fieldId   = $this->get_field_id('title');
+        $fieldName = $this->get_field_name('title');
+        $title = isset($instance['title']) ? $instance['title'] : 'code-#########';
+        $codes = Database::get_codes();
+        if (isset($instance['title'])) {
+            $title = $instance['title'];
+        } else {
+            $title = 'code-#########';
+        // Filter and retain only published code snippets
+        $published_codes = array_filter($codes, function ($item) {
+            return $item->post_status === 'publish';
+        });
+        // Generate dropdown options for available code snippets
+        $options = '<option value="0">' . esc_html__("— Select —", "code-injection") . '</option>';
+        foreach ($published_codes as $code) {
+            $codeTitle = get_post_meta($code->ID, "code_slug", true) ?: $code->post_title;
+            $selected = selected($code->post_title, $title, false);
+            $options .= sprintf('<option %1$s value="%2$s">%3$s</option>', $selected, esc_attr($code->post_title), $codeTitle);
+        }
+        $codes = Database::get_codes();
+        $fieldId = $this->get_field_id('title');
+        $fieldName = $this->get_field_name('title');
+        $label = esc_html__('Code ID:', 'code-injection');
+        $codes = array_filter($codes, function ($item) {
+            return $item->post_status == 'publish';
+        });
+        ob_start();
+        printf('<option value="0">— %1$s —</option>', esc_html__("Select", "code-injection"));
+        foreach ($codes as $code) {
+            $codeTitle = get_post_meta($code->ID, "code_slug", true);
+            $codeTitle = $codeTitle ?: $code->post_title;
+            printf('<option %1$s value="%2$s">%3$s</option>', selected($code->post_title, $title, false), esc_attr($code->post_title), $codeTitle);
+        }
+        $options = ob_get_clean();
+        printf('<p><label for="%1$s">%2$s</label><select style="width:100%;" id="%1$s" name="%2$s">%3$s</select></p>', $fieldId, $label , $fieldId, $fieldName, $options);
+        wp_reset_query();
+        printf('<p><label for="%1$s">%2$s</label><select style="width:100%;" id="%1$s" name="%2$s">%3$s</select></p>', $fieldId, $label, $fieldId, $fieldName, $options);
+    }
     /**
+     * Updates the widget settings when saved.
+     *
+     * Sanitizes and stores the selected code snippet ID.
+     *
+     * @param array $new_instance New settings for the widget.
+     * @param array $old_instance Old settings for the widget.
+     *
+     * @return array Updated settings for the widget.
+     *
      * @since 0.9.0
      */
 …
+    {
         $instance = array();
         $instance['title'] = (!empty($new_instance['title'])) ? strip_tags($new_instance['title']) : '';
+        $instance['title'] = !empty($new_instance['title']) ? strip_tags($new_instance['title']) : '';
         return $instance;
+    }

code-injection/trunk/readme.txt

-                      r2943916
+                      r2967476
 Tags: code, snippets, injection
 Requires at least: 4.5.0
 Tested up to: 6.2.2
 Stable tag: 2.4.13
+Tested up to: 6.3.1
+Stable tag: 2.4.14
 License: MIT License
 License URI: https://github.com/Rmanaf/wp-code-injection/blob/master/LICENSE

Plugin Directory

Context Navigation

Legend:

code-injection/trunk/code-injection.php

code-injection/trunk/includes/class-asset-manager.php

code-injection/trunk/includes/class-barchart.php

code-injection/trunk/includes/class-code-type.php

code-injection/trunk/includes/class-core.php

code-injection/trunk/includes/class-database.php

code-injection/trunk/includes/class-heatmap.php

code-injection/trunk/includes/class-helpers.php

code-injection/trunk/includes/class-metabox.php

code-injection/trunk/includes/class-options.php

code-injection/trunk/includes/class-roles.php

code-injection/trunk/includes/class-shortcodes.php

code-injection/trunk/includes/class-widget.php

code-injection/trunk/readme.txt

Download in other formats: