WordPress.org
Get WordPress

Plugin Directory

Changeset 1535968


Ignore:
Timestamp:
11/17/2016 11:20:18 PM (9 years ago)
Author:
travislopes
Message:

Shortcode Locator (1.1)

  • Rewrote entire plugin.
Location:
shortcode-locator
Files:
9 added
2 deleted
2 edited

Legend:

Unmodified
Added
Removed

  • shortcode-locator/trunk/readme.txt

    r1106154 r1535968  
    33Tags: shortcode, find content, post types
    44Requires at least: 4.0.0
    5 Tested up to: 4.1.1
    6 Stable tag: 4.1.1
     5Tested up to: 4.6.1
     6Stable tag: 4.6.1
    77
    88Quickly locate what and where shortcodes are being used.
    … …  
    1515== Installation ==
    1616= Requirements =
    17 * WordPress version 4.0.0 and later (tested at 4.1.1)
     17* WordPress version 4.0.0 and later (tested at 4.6.1)
    1818
    1919= Installation =
    … …  
    2828
    2929== Changelog ==
     30= v1.1 =
     31* Rewrote entire plugin.
    3032= v1.0.1 =
    3133* Made post title and type columns sortable

  • shortcode-locator/trunk/shortcode-locator.php

    r1106152 r1535968  
    11<?php
    2    
    3     /*
    4     Plugin Name: Shortcode Locator
    5     Plugin URI: http://travislop.es/plugins/shortcode-locator/
    6     Description: Quickly locate what and where shortcodes are being used
    7     Version: 1.0.1
    8     Author: travislopes
    9     Author URI: http://travislop.es
    10     */
    11    
    12     class Shortcode_Locator {
    13        
    14         public static $admin_page_slug = 'shortcode_locator';
    15         public static $basename;
    16         public static $post_types = array();
    17         public static $settings;
    18         private static $admin_page_title = 'Shortcode Locator';
    19         private static $_instance = null;
    20    
    21         public static function get_instance() {
    22            
    23             if ( self::$_instance == null )
    24                 self::$_instance = new Shortcode_Locator();
    25    
    26             return self::$_instance;
    27            
    28         }
    29    
    30         public function __construct() {
    31            
    32             /* Set basename */
    33             self::$basename = plugin_basename( __FILE__ );
    34            
    35             /* Include settings page class */
    36             include_once 'shortcode-locator-settings.php';
    37            
    38             /* Assign settings to this class */
    39             self::$settings = Shortcode_Locator_Settings::get_settings();
    40            
    41             /* Register admin page */
    42             add_action( 'admin_menu', array( __CLASS__, 'register_admin_page' ) );
    43            
    44             /* Add and render shortcode column to selected post types */
    45             foreach( self::$settings['display_column'] as $post_type ) {
    46                
    47                 add_filter( 'manage_'. $post_type .'_posts_columns', array( __CLASS__, 'add_shortcode_post_column' ) );
    48                 add_filter( 'manage_'. $post_type .'_posts_custom_column', array( __CLASS__, 'render_shortcode_post_column' ), 10, 2 );
    49                
     2/**
     3Plugin Name: Shortcode Locator
     4Plugin URI: http://travislop.es/plugins/shortcode-locator/
     5Description: Quickly locate what and where shortcodes are being used
     6Version: 1.1
     7Author: travislopes
     8Author URI: http://travislop.es
     9 **/
     10
     11/**
     12 * Shortcode Locator.
     13 *
     14 * @since     1.0
     15 * @author    Travis Lopes
     16 * @copyright Copyright (c) 2016, Travis Lopes
     17 */
     18class Shortcode_Locator {
     19
     20    /**
     21     * Defines the plugin slug.
     22     *
     23     * @since  1.1
     24     * @access public
     25     * @var    string $_slug The slug used for this plugin.
     26     */
     27    public $slug = 'shortcode_locator';
     28
     29    /**
     30     * Defines the full path to this class file.
     31     *
     32     * @since  1.1
     33     * @access protected
     34     * @var    string $full_path The full path.
     35     */
     36    protected $full_path = __FILE__;
     37
     38    /**
     39     * Get instance of this class.
     40     *
     41     * @since  1.0
     42     * @access public
     43     * @static
     44     *
     45     * @return $_instance
     46     */
     47    private static $_instance = null;
     48
     49    /**
     50     * Get instance of this class.
     51     *
     52     * @since  1.0
     53     * @access public
     54     * @static
     55     *
     56     * @return $_instance
     57     */
     58    public static function get_instance() {
     59
     60        if ( null === self::$_instance ) {
     61            self::$_instance = new self;
     62        }
     63
     64        return self::$_instance;
     65
     66    }
     67
     68    /**
     69     * Constructor.
     70     *
     71     * @since  1.0
     72     * @access public
     73     */
     74    public function __construct() {
     75
     76        // Load required classes.
     77        require_once 'includes/class-shortcode-locator-settings.php';
     78        require_once 'includes/class-shortcode-locator-table.php';
     79
     80        // Initialize settings.
     81        $settings = shortcode_locator_settings();
     82
     83        // Register plugin action links.
     84        add_filter( 'plugin_action_links_'. plugin_basename( $this->full_path ), array( $this, 'plugin_action_links' ) );
     85
     86        // Register plugin pages.
     87        add_action( 'admin_menu', array( $this, 'register_plugin_page' ) );
     88        add_action( 'admin_menu', array( $settings, 'register_settings_page' ) );
     89
     90        // Add shortcode post column.
     91        add_filter( 'manage_posts_columns', array( $this, 'add_posts_column' ), 10, 2 );
     92        add_action( 'manage_posts_custom_column', array( $this, 'render_posts_column' ), 10, 2 );
     93
     94    }
     95
     96
     97
     98
     99
     100    // # SETTINGS ------------------------------------------------------------------------------------------------------
     101
     102    /**
     103     * Links display on the pluginspage.
     104     *
     105     * @since  1.1
     106     * @access public
     107     * @param  array $links An array of plugin action links.
     108     *
     109     * @return array
     110     */
     111    public function plugin_action_links( $links ) {
     112
     113        // Prepare plugin links.
     114        $plugin_links = array( '<a href="'. admin_url( 'options-general.php?page='. shortcode_locator_settings()->page_slug ) .'">' . esc_html__( 'Settings', 'shortcode-locator' ) . '</a>' );
     115
     116        return array_merge( $plugin_links, $links );
     117
     118    }
     119
     120
     121
     122
     123
     124    // # PLUGIN PAGE ---------------------------------------------------------------------------------------------------
     125
     126    /**
     127     * Register plugin page.
     128     *
     129     * @since  1.0
     130     * @access public
     131     */
     132    public function register_plugin_page() {
     133
     134        // Add plugin page to Tools menu.
     135        add_submenu_page(
     136            'tools.php', // Parent slug.
     137            $this->plugin_page_title(), // Page title.
     138            $this->plugin_page_title(), // Menu title.
     139            'edit_posts', // Capability.
     140            $this->slug, // Menu slug.
     141            array( $this, 'render_plugin_page' ) // Page function.
     142        );
     143
     144    }
     145
     146    /**
     147     * Render and display plugin page.
     148     *
     149     * @since  1.0
     150     * @access public
     151     */
     152    public function render_plugin_page() {
     153
     154        // Start page.
     155        echo '<div class="wrap">';
     156
     157        // Display page title.
     158        echo '<h2>'. $this->plugin_page_title() .'</h2>';
     159
     160        // Display shortcodes table.
     161        $table = new Shortcode_Locator_Table();
     162        $table->prepare_items();
     163        $table->display();
     164
     165        // End page.
     166        echo '</div>';
     167
     168    }
     169
     170    /**
     171     * Prepares plugin page title.
     172     *
     173     * @since  1.1
     174     * @access public
     175     *
     176     * @return string
     177     */
     178    public function plugin_page_title() {
     179
     180        return esc_html__( 'Shortcode Locator', 'shortcode-locator' );
     181
     182    }
     183
     184
     185
     186
     187
     188    // # POSTS PAGE ----------------------------------------------------------------------------------------------------
     189
     190    /**
     191     * Add shortcode column to posts list.
     192     *
     193     * @since  1.0
     194     * @access public
     195     *
     196     * @param array  $columns   An array of column names.
     197     * @param string $post_type The post type slug.
     198     *
     199     * @return array
     200     */
     201    public function add_posts_column( $columns, $post_type ) {
     202
     203        // Get allowed post types.
     204        $allowed_post_types = shortcode_locator_settings()->get_setting( 'display_column' );
     205
     206        // If this post type is not on the display columns list, return columns.
     207        if ( ! in_array( $post_type, $allowed_post_types ) ) {
     208            return $columns;
     209        }
     210
     211        // Add columns.
     212        $columns['shortcodes'] = esc_html__( 'Shortcodes Located', 'shortcode-locator' );
     213
     214        return $columns;
     215
     216    }
     217
     218    /**
     219     * Display shortcode column on posts list.
     220     *
     221     * @since  1.0
     222     * @access public
     223     *
     224     * @param string $column  The name of the column to display.
     225     * @param int    $post_id The current post ID.
     226     */
     227    public function render_posts_column( $column, $post_id ) {
     228
     229        // Get post content.
     230        $post_content = get_post_field( 'post_content', $post_id );
     231
     232        // Get shortcodes in post.
     233        $shortcodes = $this->get_shortcodes_for_post( $post_content );
     234
     235        // If no shortcodes were found, return.
     236        if ( empty( $shortcodes ) ) {
     237            return;
     238        }
     239
     240        // Escape shortcodes.
     241        $shortcodes = array_map( 'esc_html', $shortcodes );
     242
     243        // Display shortcodes.
     244        echo implode( '<br />', $shortcodes );
     245
     246    }
     247
     248    /**
     249     * Get available post types.
     250     *
     251     * @since  1.1
     252     * @access public
     253     *
     254     * @return array
     255     */
     256    public function get_post_types() {
     257
     258        // Initialize post types array.
     259        $post_types = array();
     260
     261        // Define excluded post types.
     262        $excluded_post_types = array( 'attachment', 'revision', 'nav_menu_item' );
     263        $excluded_post_types = apply_filters( 'shortcode_locator_excluded_post_types', $excluded_post_types );
     264
     265        // Get registered post types.
     266        $registered_post_types = get_post_types( array(), 'objects' );
     267
     268        // Loop through registered post types.
     269        foreach ( $registered_post_types as $post_type ) {
     270
     271            // If post type is excluded, skip it.
     272            if ( in_array( $post_type->name, $excluded_post_types ) ) {
     273                continue;
    50274            }
    51            
    52             /* Set available post types */
    53             add_action( 'admin_init', array( __CLASS__, 'set_post_types' ) );
    54            
    55         }
    56 
    57         /* Register admin page */
    58         function register_admin_page() {
    59            
    60             add_submenu_page( 'tools.php', self::$admin_page_title, self::$admin_page_title, 'edit_posts', self::$admin_page_slug, array( __CLASS__, 'render_admin_page' ) );
    61            
    62         }
    63        
    64         /* Render admin page */
    65         function render_admin_page() {
    66                        
    67             /* Load table class */
    68             include_once 'shortcode-locator-table.php';
    69 
    70             /* Open page */
    71             echo '<div class="wrap">';
    72            
    73             /* Page title */
    74             echo '<h2>'. self::$admin_page_title .'</h2>';
    75            
    76             /* Display table */
    77             $shortcode_locator_table = new Shortcode_Locator_Table();
    78             $shortcode_locator_table->prepare_items();
    79             $shortcode_locator_table->display();           
    80            
    81             /* Close page */
    82             echo '</div>';
    83            
    84         }
    85 
    86         /* Add shortcode column to selected post types */
    87         function add_shortcode_post_column( $columns ) {
    88            
    89             $columns['shortcodes'] = 'Shortcodes Located';
    90             return $columns;
    91            
    92         }
    93 
    94         /* Render shortcode column to selected post types */
    95         function render_shortcode_post_column( $column, $post_id ) {
    96            
    97             /* Get shortcodes in post */
    98             $shortcodes_located = self::get_shortcodes_for_post( get_post_field( 'post_content', $post_id ) );
    99            
    100             /* Display if found */
    101             if ( ! empty( $shortcodes_located ) )
    102                 echo implode( '<br />', $shortcodes_located );
    103            
    104         }
    105        
    106         /* Set available post types */
    107         function set_post_types() {
    108            
    109             /* Set list of post types to exclude */
    110             $excluded_post_types = apply_filters( 'shortcode_locator_excluded_post_types', array( 'attachment', 'revision', 'nav_menu_item' ) );
    111            
    112             /* Get registered post types */
    113             $registered_post_types = get_post_types( array(), 'objects' );
    114            
    115             /* Loop through registered post types and push to class array if not excluded */
    116             foreach( $registered_post_types as $post_type ) {
    117                                
    118                 if( ! in_array( $post_type->name, $excluded_post_types ) )
    119                     self::$post_types[$post_type->name] = $post_type->label;               
    120                
    121             }
    122            
    123         }
    124 
    125         /* Get shortcodes for post */
    126         function get_shortcodes_for_post( $post_content, $shortcode = null ) {
    127            
    128             /* Get shortcode regex */
    129             $shortcode_regex = ( is_null( $shortcode ) ) ? get_shortcode_regex() : self::get_specific_shortcode_regex( $shortcode );
    130            
    131             /* Search for shortcodes */
    132             preg_match_all( '/'. $shortcode_regex .'/', $post_content, $shortcodes_located );
    133            
    134             /* Loop through the shortcodes located array and push them to a separate array */
    135             $shortcodes = array();
    136             foreach( $shortcodes_located as $child_array ) {
    137                
    138                 foreach( $child_array as $key => $value ) {
    139                
    140                     if ( ! isset( $shortcodes[$key] ) )
    141                         $shortcodes[$key] = array();
    142                        
    143                     $shortcodes[$key][] = $value;
    144                    
    145                 }
    146                
    147             }
    148            
    149             /* Loop through the shortcodes again and put together shortcode string */
    150             $shortcode_strings = array();
    151             foreach( $shortcodes as &$shortcode ) {
    152                
    153                 $shortcode_string = '['. $shortcode[2];
    154                
    155                 /* If arguments exist, add them to the shortcode string */
    156                 if ( ! empty( $shortcode[3] ) )
    157                     $shortcode_string .= $shortcode[3];
    158                
    159                 /* Close shortcode string */
    160                 $shortcode_string .= ']';
    161                
    162                 /* Add to array */
    163                 $shortcode_strings[] = $shortcode_string;
    164                
    165             }
    166            
    167             /* Return found shortcodes */
    168             return $shortcode_strings;
    169            
    170         }
    171        
    172         /* Get regex for specific shortcode */
    173         function get_specific_shortcode_regex( $shortcode ) {
    174            
    175             return
    176                   '\\['                              // Opening bracket
    177                 . '(\\[?)'                           // 1: Optional second opening bracket for escaping shortcodes: [[tag]]
    178                 . "($shortcode)"                     // 2: Shortcode name
    179                 . '(?![\\w-])'                       // Not followed by word character or hyphen
    180                 . '('                                // 3: Unroll the loop: Inside the opening shortcode tag
    181                 .     '[^\\]\\/]*'                   // Not a closing bracket or forward slash
    182                 .     '(?:'
    183                 .         '\\/(?!\\])'               // A forward slash not followed by a closing bracket
    184                 .         '[^\\]\\/]*'               // Not a closing bracket or forward slash
    185                 .     ')*?'
    186                 . ')'
    187                 . '(?:'
    188                 .     '(\\/)'                        // 4: Self closing tag ...
    189                 .     '\\]'                          // ... and closing bracket
    190                 . '|'
    191                 .     '\\]'                          // Closing bracket
    192                 .     '(?:'
    193                 .         '('                        // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
    194                 .             '[^\\[]*+'             // Not an opening bracket
    195                 .             '(?:'
    196                 .                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag
    197                 .                 '[^\\[]*+'         // Not an opening bracket
    198                 .             ')*+'
    199                 .         ')'
    200                 .         '\\[\\/\\2\\]'             // Closing shortcode tag
    201                 .     ')?'
    202                 . ')'
    203                 . '(\\]?)';                          // 6: Optional second closing brocket for escaping shortcodes: [[tag]]
    204            
    205            
    206         }
    207        
    208     }
    209 
    210     Shortcode_Locator::get_instance();
     275
     276            // Add post type to return array.
     277            $post_types[ $post_type->name ] = $post_type->label;
     278
     279        }
     280
     281        return $post_types;
     282
     283    }
     284
     285
     286
     287
     288
     289    // # HELPERS -------------------------------------------------------------------------------------------------------
     290
     291    /**
     292     * Get shortcodes within post content.
     293     *
     294     * @since  1.0
     295     * @access public
     296     *
     297     * @param string $post_content Post content.
     298     * @param string $shortcode    Shortcode to search for. Defaults to null.
     299     *
     300     * @return array
     301     */
     302    public function get_shortcodes_for_post( $post_content, $shortcode = null ) {
     303
     304        // Initialize shortcodes return array.
     305        $shortcodes = array();
     306
     307        // Prepare shortcode regex.
     308        $shortcode_regex = $shortcode ? $this->get_shortcode_regex( $shortcode ) : get_shortcode_regex();
     309
     310        // Locate shortcodes.
     311        preg_match_all( '/'. $shortcode_regex .'/', $post_content, $located );
     312
     313        // If no shortcodes were located, return.
     314        if ( empty( $located[0] ) ) {
     315            return $shortcodes;
     316        }
     317
     318        // Loop through located shortcodes.
     319        foreach ( $located[0] as $i => $shortcode_string ) {
     320
     321            // Add to return array.
     322            $shortcodes[] = $shortcode_string;
     323
     324        }
     325
     326        return $shortcodes;
     327
     328    }
     329
     330    /**
     331     * Get regular expression for a shortcode.
     332     *
     333     * @since  1.0
     334     * @access public
     335     * @param  string $shortcode Shortcode name.
     336     *
     337     * @return string
     338     */
     339    public function get_shortcode_regex( $shortcode ) {
     340
     341        return
     342              '\\['                              // Opening bracket
     343            . '(\\[?)'                           // 1: Optional second opening bracket for escaping shortcodes: [[tag]]
     344            . "($shortcode)"                     // 2: Shortcode name
     345            . '(?![\\w-])'                       // Not followed by word character or hyphen
     346            . '('                                // 3: Unroll the loop: Inside the opening shortcode tag
     347            .     '[^\\]\\/]*'                   // Not a closing bracket or forward slash
     348            .     '(?:'
     349            .         '\\/(?!\\])'               // A forward slash not followed by a closing bracket
     350            .         '[^\\]\\/]*'               // Not a closing bracket or forward slash
     351            .     ')*?'
     352            . ')'
     353            . '(?:'
     354            .     '(\\/)'                        // 4: Self closing tag ...
     355            .     '\\]'                          // ... and closing bracket
     356            . '|'
     357            .     '\\]'                          // Closing bracket
     358            .     '(?:'
     359            .         '('                        // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
     360            .             '[^\\[]*+'             // Not an opening bracket
     361            .             '(?:'
     362            .                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag
     363            .                 '[^\\[]*+'         // Not an opening bracket
     364            .             ')*+'
     365            .         ')'
     366            .         '\\[\\/\\2\\]'             // Closing shortcode tag
     367            .     ')?'
     368            . ')'
     369            . '(\\]?)';                          // 6: Optional second closing brocket for escaping shortcodes: [[tag]]
     370
     371    }
     372
     373}
     374
     375/**
     376 * Returns an instance of the Shortcode_Locator class.
     377 *
     378 * @see    Shortcode_Locator::get_instance()
     379 *
     380 * @return object Shortcode_Locator
     381 */
     382function shortcode_locator() {
     383    return Shortcode_Locator::get_instance();
     384}
     385
     386shortcode_locator();
Note: See TracChangeset for help on using the changeset viewer.