WordPress.org

Make WordPress Core

Ticket #40525: 405251.patch

File 405251.patch, 46.1 KB (added by sebastian.pisula, 4 years ago)

Reformat in WordPress code style

  • wp-includes/class-wp-rewrite.php

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    377377         * @return bool True, if permalinks are enabled.
    378378         */
    379379        public function using_permalinks() {
    380                 return ! empty($this->permalink_structure);
     380                return ! empty( $this->permalink_structure );
    381381        }
    382382
    383383        /**
     
    427427         * @access public
    428428         *
    429429         * @param int $number Index number.
     430         *
    430431         * @return string
    431432         */
    432         public function preg_index($number) {
     433        public function preg_index( $number ) {
    433434                $match_prefix = '$';
    434435                $match_suffix = '';
    435436
    436                 if ( ! empty($this->matches) ) {
     437                if ( ! empty( $this->matches ) ) {
    437438                        $match_prefix = '$' . $this->matches . '[';
    438439                        $match_suffix = ']';
    439440                }
     
    458459                global $wpdb;
    459460
    460461                // Get pages in order of hierarchy, i.e. children after parents.
    461                 $pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page' AND post_status != 'auto-draft'");
     462                $pages = $wpdb->get_results( "SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page' AND post_status != 'auto-draft'" );
    462463                $posts = get_page_hierarchy( $pages );
    463464
    464465                // If we have no pages get out quick.
    465                 if ( !$posts )
     466                if ( ! $posts ) {
    466467                        return array( array(), array() );
     468                }
    467469
    468470                // Now reverse it, because we need parents after children for rewrite rules to work properly.
    469                 $posts = array_reverse($posts, true);
     471                $posts = array_reverse( $posts, true );
    470472
    471                 $page_uris = array();
     473                $page_uris            = array();
    472474                $page_attachment_uris = array();
    473475
    474476                foreach ( $posts as $id => $post ) {
    475477                        // URL => page name
    476                         $uri = get_page_uri($id);
    477                         $attachments = $wpdb->get_results( $wpdb->prepare( "SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = %d", $id ));
    478                         if ( !empty($attachments) ) {
     478                        $uri         = get_page_uri( $id );
     479                        $attachments = $wpdb->get_results( $wpdb->prepare( "SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = %d", $id ) );
     480                        if ( ! empty( $attachments ) ) {
    479481                                foreach ( $attachments as $attachment ) {
    480                                         $attach_uri = get_page_uri($attachment->ID);
    481                                         $page_attachment_uris[$attach_uri] = $attachment->ID;
     482                                        $attach_uri                          = get_page_uri( $attachment->ID );
     483                                        $page_attachment_uris[ $attach_uri ] = $attachment->ID;
    482484                                }
    483485                        }
    484486
    485                         $page_uris[$uri] = $id;
     487                        $page_uris[ $uri ] = $id;
    486488                }
    487489
    488490                return array( $page_uris, $page_attachment_uris );
     
    524526         * @return string|false False on no permalink structure. Date permalink structure.
    525527         */
    526528        public function get_date_permastruct() {
    527                 if ( isset($this->date_structure) )
     529                if ( isset( $this->date_structure ) ) {
    528530                        return $this->date_structure;
     531                }
    529532
    530                 if ( empty($this->permalink_structure) ) {
     533                if ( empty( $this->permalink_structure ) ) {
    531534                        $this->date_structure = '';
     535
    532536                        return false;
    533537                }
    534538
    535539                // The date permalink must have year, month, and day separated by slashes.
    536                 $endians = array('%year%/%monthnum%/%day%', '%day%/%monthnum%/%year%', '%monthnum%/%day%/%year%');
     540                $endians = array( '%year%/%monthnum%/%day%', '%day%/%monthnum%/%year%', '%monthnum%/%day%/%year%' );
    537541
    538542                $this->date_structure = '';
    539                 $date_endian = '';
     543                $date_endian          = '';
    540544
    541545                foreach ( $endians as $endian ) {
    542                         if ( false !== strpos($this->permalink_structure, $endian) ) {
    543                                 $date_endian= $endian;
     546                        if ( false !== strpos( $this->permalink_structure, $endian ) ) {
     547                                $date_endian = $endian;
    544548                                break;
    545549                        }
    546550                }
    547551
    548                 if ( empty($date_endian) )
     552                if ( empty( $date_endian ) ) {
    549553                        $date_endian = '%year%/%monthnum%/%day%';
     554                }
    550555
    551556                /*
    552557                 * Do not allow the date tags and %post_id% to overlap in the permalink
    553558                 * structure. If they do, move the date tags to $front/date/.
    554559                 */
    555560                $front = $this->front;
    556                 preg_match_all('/%.+?%/', $this->permalink_structure, $tokens);
     561                preg_match_all( '/%.+?%/', $this->permalink_structure, $tokens );
    557562                $tok_index = 1;
    558                 foreach ( (array) $tokens[0] as $token) {
    559                         if ( '%post_id%' == $token && ($tok_index <= 3) ) {
     563                foreach ( (array) $tokens[0] as $token ) {
     564                        if ( '%post_id%' == $token && ( $tok_index <= 3 ) ) {
    560565                                $front = $front . 'date/';
    561566                                break;
    562567                        }
    563                         $tok_index++;
     568                        $tok_index ++;
    564569                }
    565570
    566571                $this->date_structure = $front . $date_endian;
     
    582587        public function get_year_permastruct() {
    583588                $structure = $this->get_date_permastruct();
    584589
    585                 if ( empty($structure) )
     590                if ( empty( $structure ) ) {
    586591                        return false;
     592                }
    587593
    588                 $structure = str_replace('%monthnum%', '', $structure);
    589                 $structure = str_replace('%day%', '', $structure);
    590                 $structure = preg_replace('#/+#', '/', $structure);
     594                $structure = str_replace( '%monthnum%', '', $structure );
     595                $structure = str_replace( '%day%', '', $structure );
     596                $structure = preg_replace( '#/+#', '/', $structure );
    591597
    592598                return $structure;
    593599        }
     
    606612        public function get_month_permastruct() {
    607613                $structure = $this->get_date_permastruct();
    608614
    609                 if ( empty($structure) )
     615                if ( empty( $structure ) ) {
    610616                        return false;
     617                }
    611618
    612                 $structure = str_replace('%day%', '', $structure);
    613                 $structure = preg_replace('#/+#', '/', $structure);
     619                $structure = str_replace( '%day%', '', $structure );
     620                $structure = preg_replace( '#/+#', '/', $structure );
    614621
    615622                return $structure;
    616623        }
     
    643650         * @return string|false False on failure. Category permalink structure.
    644651         */
    645652        public function get_category_permastruct() {
    646                 return $this->get_extra_permastruct('category');
     653                return $this->get_extra_permastruct( 'category' );
    647654        }
    648655
    649656        /**
     
    660667         * @return string|false False on failure. Tag permalink structure.
    661668         */
    662669        public function get_tag_permastruct() {
    663                 return $this->get_extra_permastruct('post_tag');
     670                return $this->get_extra_permastruct( 'post_tag' );
    664671        }
    665672
    666673        /**
     
    670677         * @access public
    671678         *
    672679         * @param string $name Permalink structure name.
     680         *
    673681         * @return string|false False if not found. Permalink structure string.
    674682         */
    675         public function get_extra_permastruct($name) {
    676                 if ( empty($this->permalink_structure) )
     683        public function get_extra_permastruct( $name ) {
     684                if ( empty( $this->permalink_structure ) ) {
    677685                        return false;
     686                }
    678687
    679                 if ( isset($this->extra_permastructs[$name]) )
    680                         return $this->extra_permastructs[$name]['struct'];
     688                if ( isset( $this->extra_permastructs[ $name ] ) ) {
     689                        return $this->extra_permastructs[ $name ]['struct'];
     690                }
    681691
    682692                return false;
    683693        }
     
    695705         * @return string|false False if not found. Permalink structure string.
    696706         */
    697707        public function get_author_permastruct() {
    698                 if ( isset($this->author_structure) )
     708                if ( isset( $this->author_structure ) ) {
    699709                        return $this->author_structure;
     710                }
    700711
    701                 if ( empty($this->permalink_structure) ) {
     712                if ( empty( $this->permalink_structure ) ) {
    702713                        $this->author_structure = '';
     714
    703715                        return false;
    704716                }
    705717
     
    721733         * @return string|false False if not found. Permalink structure string.
    722734         */
    723735        public function get_search_permastruct() {
    724                 if ( isset($this->search_structure) )
     736                if ( isset( $this->search_structure ) ) {
    725737                        return $this->search_structure;
     738                }
    726739
    727                 if ( empty($this->permalink_structure) ) {
     740                if ( empty( $this->permalink_structure ) ) {
    728741                        $this->search_structure = '';
     742
    729743                        return false;
    730744                }
    731745
     
    747761         * @return string|false False if not found. Permalink structure string.
    748762         */
    749763        public function get_page_permastruct() {
    750                 if ( isset($this->page_structure) )
     764                if ( isset( $this->page_structure ) ) {
    751765                        return $this->page_structure;
     766                }
    752767
    753                 if (empty($this->permalink_structure)) {
     768                if ( empty( $this->permalink_structure ) ) {
    754769                        $this->page_structure = '';
     770
    755771                        return false;
    756772                }
    757773
     
    773789         * @return string|false False if not found. Permalink structure string.
    774790         */
    775791        public function get_feed_permastruct() {
    776                 if ( isset($this->feed_structure) )
     792                if ( isset( $this->feed_structure ) ) {
    777793                        return $this->feed_structure;
     794                }
    778795
    779                 if ( empty($this->permalink_structure) ) {
     796                if ( empty( $this->permalink_structure ) ) {
    780797                        $this->feed_structure = '';
     798
    781799                        return false;
    782800                }
    783801
     
    799817         * @return string|false False if not found. Permalink structure string.
    800818         */
    801819        public function get_comment_feed_permastruct() {
    802                 if ( isset($this->comment_feed_structure) )
     820                if ( isset( $this->comment_feed_structure ) ) {
    803821                        return $this->comment_feed_structure;
     822                }
    804823
    805                 if (empty($this->permalink_structure)) {
     824                if ( empty( $this->permalink_structure ) ) {
    806825                        $this->comment_feed_structure = '';
     826
    807827                        return false;
    808828                }
    809829
     
    825845         * @see WP_Rewrite::$rewritereplace
    826846         * @see WP_Rewrite::$queryreplace
    827847         *
    828          * @param string $tag   Name of the rewrite tag to add or update.
     848         * @param string $tag Name of the rewrite tag to add or update.
    829849         * @param string $regex Regular expression to substitute the tag for in rewrite rules.
    830850         * @param string $query String to append to the rewritten query. Must end in '='.
    831851         */
     
    833853                $position = array_search( $tag, $this->rewritecode );
    834854                if ( false !== $position && null !== $position ) {
    835855                        $this->rewritereplace[ $position ] = $regex;
    836                         $this->queryreplace[ $position ] = $query;
     856                        $this->queryreplace[ $position ]   = $query;
    837857                } else {
    838                         $this->rewritecode[] = $tag;
     858                        $this->rewritecode[]    = $tag;
    839859                        $this->rewritereplace[] = $regex;
    840                         $this->queryreplace[] = $query;
     860                        $this->queryreplace[]   = $query;
    841861                }
    842862        }
    843863
     
    874894         * @access public
    875895         *
    876896         * @param string $permalink_structure The permalink structure.
    877          * @param int    $ep_mask            Optional. Endpoint mask defining what endpoints are added to the structure.
     897         * @param int $ep_mask Optional. Endpoint mask defining what endpoints are added to the structure.
    878898         *                                    Accepts `EP_NONE`, `EP_PERMALINK`, `EP_ATTACHMENT`, `EP_DATE`, `EP_YEAR`,
    879899         *                                    `EP_MONTH`, `EP_DAY`, `EP_ROOT`, `EP_COMMENTS`, `EP_SEARCH`, `EP_CATEGORIES`,
    880900         *                                    `EP_TAGS`, `EP_AUTHORS`, `EP_PAGES`, `EP_ALL_ARCHIVES`, and `EP_ALL`.
    881901         *                                    Default `EP_NONE`.
    882          * @param bool   $paged              Optional. Whether archive pagination rules should be added for the structure.
     902         * @param bool $paged Optional. Whether archive pagination rules should be added for the structure.
    883903         *                                    Default true.
    884          * @param bool   $feed                Optional Whether feed rewrite rules should be added for the structure.
     904         * @param bool $feed Optional Whether feed rewrite rules should be added for the structure.
    885905         *                                    Default true.
    886          * @param bool   $forcomments        Optional. Whether the feed rules should be a query for a comments feed.
     906         * @param bool $forcomments Optional. Whether the feed rules should be a query for a comments feed.
    887907         *                                    Default false.
    888          * @param bool   $walk_dirs          Optional. Whether the 'directories' making up the structure should be walked
     908         * @param bool $walk_dirs Optional. Whether the 'directories' making up the structure should be walked
    889909         *                                    over and rewrite rules built for each in-turn. Default true.
    890          * @param bool   $endpoints          Optional. Whether endpoints should be applied to the generated rewrite rules.
     910         * @param bool $endpoints Optional. Whether endpoints should be applied to the generated rewrite rules.
    891911         *                                    Default true.
     912         *
    892913         * @return array Rewrite rule list.
    893914         */
    894         public function generate_rewrite_rules($permalink_structure, $ep_mask = EP_NONE, $paged = true, $feed = true, $forcomments = false, $walk_dirs = true, $endpoints = true) {
     915        public function generate_rewrite_rules( $permalink_structure, $ep_mask = EP_NONE, $paged = true, $feed = true, $forcomments = false, $walk_dirs = true, $endpoints = true ) {
    895916                // Build a regex to match the feed section of URLs, something like (feed|atom|rss|rss2)/?
    896917                $feedregex2 = '';
    897                 foreach ( (array) $this->feeds as $feed_name)
     918                foreach ( (array) $this->feeds as $feed_name ) {
    898919                        $feedregex2 .= $feed_name . '|';
    899                 $feedregex2 = '(' . trim($feedregex2, '|') . ')/?$';
     920                }
     921                $feedregex2 = '(' . trim( $feedregex2, '|' ) . ')/?$';
    900922
    901923                /*
    902924                 * $feedregex is identical but with /feed/ added on as well, so URLs like <permalink>/feed/atom
     
    906928
    907929                // Build a regex to match the trackback and page/xx parts of URLs.
    908930                $trackbackregex = 'trackback/?$';
    909                 $pageregex = $this->pagination_base . '/?([0-9]{1,})/?$';
    910                 $commentregex = $this->comments_pagination_base . '-([0-9]{1,})/?$';
    911                 $embedregex = 'embed/?$';
     931                $pageregex      = $this->pagination_base . '/?([0-9]{1,})/?$';
     932                $commentregex   = $this->comments_pagination_base . '-([0-9]{1,})/?$';
     933                $embedregex     = 'embed/?$';
    912934
    913935                // Build up an array of endpoint regexes to append => queries to append.
    914936                if ( $endpoints ) {
    915                         $ep_query_append = array ();
    916                         foreach ( (array) $this->endpoints as $endpoint) {
     937                        $ep_query_append = array();
     938                        foreach ( (array) $this->endpoints as $endpoint ) {
    917939                                // Match everything after the endpoint name, but allow for nothing to appear there.
    918940                                $epmatch = $endpoint[1] . '(/(.*))?/?$';
    919941
    920942                                // This will be appended on to the rest of the query for each dir.
    921                                 $epquery = '&' . $endpoint[2] . '=';
    922                                 $ep_query_append[$epmatch] = array ( $endpoint[0], $epquery );
     943                                $epquery                     = '&' . $endpoint[2] . '=';
     944                                $ep_query_append[ $epmatch ] = array( $endpoint[0], $epquery );
    923945                        }
    924946                }
    925947
    926948                // Get everything up to the first rewrite tag.
    927                 $front = substr($permalink_structure, 0, strpos($permalink_structure, '%'));
     949                $front = substr( $permalink_structure, 0, strpos( $permalink_structure, '%' ) );
    928950
    929951                // Build an array of the tags (note that said array ends up being in $tokens[0]).
    930                 preg_match_all('/%.+?%/', $permalink_structure, $tokens);
     952                preg_match_all( '/%.+?%/', $permalink_structure, $tokens );
    931953
    932                 $num_tokens = count($tokens[0]);
     954                $num_tokens = count( $tokens[0] );
    933955
    934                 $index = $this->index; //probably 'index.php'
    935                 $feedindex = $index;
     956                $index          = $this->index; //probably 'index.php'
     957                $feedindex      = $index;
    936958                $trackbackindex = $index;
    937                 $embedindex = $index;
     959                $embedindex     = $index;
    938960
    939961                /*
    940962                 * Build a list from the rewritecode and queryreplace arrays, that will look something
    941963                 * like tagname=$matches[i] where i is the current $i.
    942964                 */
    943965                $queries = array();
    944                 for ( $i = 0; $i < $num_tokens; ++$i ) {
    945                         if ( 0 < $i )
    946                                 $queries[$i] = $queries[$i - 1] . '&';
    947                         else
    948                                 $queries[$i] = '';
     966                for ( $i = 0; $i < $num_tokens; ++ $i ) {
     967                        if ( 0 < $i ) {
     968                                $queries[ $i ] = $queries[ $i - 1 ] . '&';
     969                        } else {
     970                                $queries[ $i ] = '';
     971                        }
    949972
    950                         $query_token = str_replace($this->rewritecode, $this->queryreplace, $tokens[0][$i]) . $this->preg_index($i+1);
    951                         $queries[$i] .= $query_token;
     973                        $query_token   = str_replace( $this->rewritecode, $this->queryreplace, $tokens[0][ $i ] ) . $this->preg_index( $i + 1 );
     974                        $queries[ $i ] .= $query_token;
    952975                }
    953976
    954977                // Get the structure, minus any cruft (stuff that isn't tags) at the front.
    955978                $structure = $permalink_structure;
    956                 if ( $front != '/' )
    957                         $structure = str_replace($front, '', $structure);
     979                if ( $front != '/' ) {
     980                        $structure = str_replace( $front, '', $structure );
     981                }
    958982
    959983                /*
    960984                 * Create a list of dirs to walk over, making rewrite rules for each level
    961985                 * so for example, a $structure of /%year%/%monthnum%/%postname% would create
    962986                 * rewrite rules for /%year%/, /%year%/%monthnum%/ and /%year%/%monthnum%/%postname%
    963987                 */
    964                 $structure = trim($structure, '/');
    965                 $dirs = $walk_dirs ? explode('/', $structure) : array( $structure );
    966                 $num_dirs = count($dirs);
     988                $structure = trim( $structure, '/' );
     989                $dirs      = $walk_dirs ? explode( '/', $structure ) : array( $structure );
     990                $num_dirs  = count( $dirs );
    967991
    968992                // Strip slashes from the front of $front.
    969                 $front = preg_replace('|^/+|', '', $front);
     993                $front = preg_replace( '|^/+|', '', $front );
    970994
    971995                // The main workhorse loop.
    972996                $post_rewrite = array();
    973                 $struct = $front;
    974                 for ( $j = 0; $j < $num_dirs; ++$j ) {
     997                $struct       = $front;
     998                for ( $j = 0; $j < $num_dirs; ++ $j ) {
    975999                        // Get the struct for this dir, and trim slashes off the front.
    976                         $struct .= $dirs[$j] . '/'; // Accumulate. see comment near explode('/', $structure) above.
    977                         $struct = ltrim($struct, '/');
     1000                        $struct .= $dirs[ $j ] . '/'; // Accumulate. see comment near explode('/', $structure) above.
     1001                        $struct = ltrim( $struct, '/' );
    9781002
    9791003                        // Replace tags with regexes.
    980                         $match = str_replace($this->rewritecode, $this->rewritereplace, $struct);
     1004                        $match = str_replace( $this->rewritecode, $this->rewritereplace, $struct );
    9811005
    9821006                        // Make a list of tags, and store how many there are in $num_toks.
    983                         $num_toks = preg_match_all('/%.+?%/', $struct, $toks);
     1007                        $num_toks = preg_match_all( '/%.+?%/', $struct, $toks );
    9841008
    9851009                        // Get the 'tagname=$matches[i]'.
    986                         $query = ( ! empty( $num_toks ) && isset( $queries[$num_toks - 1] ) ) ? $queries[$num_toks - 1] : '';
     1010                        $query = ( ! empty( $num_toks ) && isset( $queries[ $num_toks - 1 ] ) ) ? $queries[ $num_toks - 1 ] : '';
    9871011
    9881012                        // Set up $ep_mask_specific which is used to match more specific URL types.
    989                         switch ( $dirs[$j] ) {
     1013                        switch ( $dirs[ $j ] ) {
    9901014                                case '%year%':
    9911015                                        $ep_mask_specific = EP_YEAR;
    9921016                                        break;
     
    10021026
    10031027                        // Create query for /page/xx.
    10041028                        $pagematch = $match . $pageregex;
    1005                         $pagequery = $index . '?' . $query . '&paged=' . $this->preg_index($num_toks + 1);
     1029                        $pagequery = $index . '?' . $query . '&paged=' . $this->preg_index( $num_toks + 1 );
    10061030
    10071031                        // Create query for /comment-page-xx.
    10081032                        $commentmatch = $match . $commentregex;
    1009                         $commentquery = $index . '?' . $query . '&cpage=' . $this->preg_index($num_toks + 1);
     1033                        $commentquery = $index . '?' . $query . '&cpage=' . $this->preg_index( $num_toks + 1 );
    10101034
    1011                         if ( get_option('page_on_front') ) {
     1035                        if ( get_option( 'page_on_front' ) ) {
    10121036                                // Create query for Root /comment-page-xx.
    10131037                                $rootcommentmatch = $match . $commentregex;
    1014                                 $rootcommentquery = $index . '?' . $query . '&page_id=' . get_option('page_on_front') . '&cpage=' . $this->preg_index($num_toks + 1);
     1038                                $rootcommentquery = $index . '?' . $query . '&page_id=' . get_option( 'page_on_front' ) . '&cpage=' . $this->preg_index( $num_toks + 1 );
    10151039                        }
    10161040
    10171041                        // Create query for /feed/(feed|atom|rss|rss2|rdf).
    10181042                        $feedmatch = $match . $feedregex;
    1019                         $feedquery = $feedindex . '?' . $query . '&feed=' . $this->preg_index($num_toks + 1);
     1043                        $feedquery = $feedindex . '?' . $query . '&feed=' . $this->preg_index( $num_toks + 1 );
    10201044
    10211045                        // Create query for /(feed|atom|rss|rss2|rdf) (see comment near creation of $feedregex).
    10221046                        $feedmatch2 = $match . $feedregex2;
    1023                         $feedquery2 = $feedindex . '?' . $query . '&feed=' . $this->preg_index($num_toks + 1);
     1047                        $feedquery2 = $feedindex . '?' . $query . '&feed=' . $this->preg_index( $num_toks + 1 );
    10241048
    10251049                        // Create query and regex for embeds.
    10261050                        $embedmatch = $match . $embedregex;
     
    10281052
    10291053                        // If asked to, turn the feed queries into comment feed ones.
    10301054                        if ( $forcomments ) {
    1031                                 $feedquery .= '&withcomments=1';
     1055                                $feedquery  .= '&withcomments=1';
    10321056                                $feedquery2 .= '&withcomments=1';
    10331057                        }
    10341058
     
    10471071
    10481072                        // Only on pages with comments add ../comment-page-xx/.
    10491073                        if ( EP_PAGES & $ep_mask || EP_PERMALINK & $ep_mask ) {
    1050                                 $rewrite = array_merge($rewrite, array($commentmatch => $commentquery));
    1051                         } elseif ( EP_ROOT & $ep_mask && get_option('page_on_front') ) {
    1052                                 $rewrite = array_merge($rewrite, array($rootcommentmatch => $rootcommentquery));
     1074                                $rewrite = array_merge( $rewrite, array( $commentmatch => $commentquery ) );
     1075                        } elseif ( EP_ROOT & $ep_mask && get_option( 'page_on_front' ) ) {
     1076                                $rewrite = array_merge( $rewrite, array( $rootcommentmatch => $rootcommentquery ) );
    10531077                        }
    10541078
    10551079                        // Do endpoints.
    10561080                        if ( $endpoints ) {
    1057                                 foreach ( (array) $ep_query_append as $regex => $ep) {
     1081                                foreach ( (array) $ep_query_append as $regex => $ep ) {
    10581082                                        // Add the endpoints on if the mask fits.
    1059                                         if ( $ep[0] & $ep_mask || $ep[0] & $ep_mask_specific )
    1060                                                 $rewrite[$match . $regex] = $index . '?' . $query . $ep[1] . $this->preg_index($num_toks + 2);
     1083                                        if ( $ep[0] & $ep_mask || $ep[0] & $ep_mask_specific ) {
     1084                                                $rewrite[ $match . $regex ] = $index . '?' . $query . $ep[1] . $this->preg_index( $num_toks + 2 );
     1085                                        }
    10611086                                }
    10621087                        }
    10631088
     
    10721097                                 * 2) post ID, 3) page name, 4) timestamp (year, month, day, hour, second and
    10731098                                 * minute all present). Set these flags now as we need them for the endpoints.
    10741099                                 */
    1075                                 if ( strpos($struct, '%postname%') !== false
    1076                                                 || strpos($struct, '%post_id%') !== false
    1077                                                 || strpos($struct, '%pagename%') !== false
    1078                                                 || (strpos($struct, '%year%') !== false && strpos($struct, '%monthnum%') !== false && strpos($struct, '%day%') !== false && strpos($struct, '%hour%') !== false && strpos($struct, '%minute%') !== false && strpos($struct, '%second%') !== false)
    1079                                                 ) {
     1100                                if ( strpos( $struct, '%postname%' ) !== false
     1101                                     || strpos( $struct, '%post_id%' ) !== false
     1102                                     || strpos( $struct, '%pagename%' ) !== false
     1103                                     || ( strpos( $struct, '%year%' ) !== false && strpos( $struct, '%monthnum%' ) !== false && strpos( $struct, '%day%' ) !== false && strpos( $struct, '%hour%' ) !== false && strpos( $struct, '%minute%' ) !== false && strpos( $struct, '%second%' ) !== false )
     1104                                ) {
    10801105                                        $post = true;
    1081                                         if ( strpos($struct, '%pagename%') !== false )
     1106                                        if ( strpos( $struct, '%pagename%' ) !== false ) {
    10821107                                                $page = true;
     1108                                        }
    10831109                                }
    10841110
    10851111                                if ( ! $post ) {
    10861112                                        // For custom post types, we need to add on endpoints as well.
    1087                                         foreach ( get_post_types( array('_builtin' => false ) ) as $ptype ) {
    1088                                                 if ( strpos($struct, "%$ptype%") !== false ) {
     1113                                        foreach ( get_post_types( array( '_builtin' => false ) ) as $ptype ) {
     1114                                                if ( strpos( $struct, "%$ptype%" ) !== false ) {
    10891115                                                        $post = true;
    10901116
    10911117                                                        // This is for page style attachment URLs.
     
    11061132                                        $embedquery = $embedindex . '?' . $query . '&embed=true';
    11071133
    11081134                                        // Trim slashes from the end of the regex for this dir.
    1109                                         $match = rtrim($match, '/');
     1135                                        $match = rtrim( $match, '/' );
    11101136
    11111137                                        // Get rid of brackets.
    1112                                         $submatchbase = str_replace( array('(', ')'), '', $match);
     1138                                        $submatchbase = str_replace( array( '(', ')' ), '', $match );
    11131139
    11141140                                        // Add a rule for at attachments, which take the form of <permalink>/some-text.
    11151141                                        $sub1 = $submatchbase . '/([^/]+)/';
     
    11511177                                        $sub2embed = $sub2 . $embedregex;
    11521178
    11531179                                        // Create queries for these extra tag-ons we've just dealt with.
    1154                                         $subquery = $index . '?attachment=' . $this->preg_index(1);
    1155                                         $subtbquery = $subquery . '&tb=1';
    1156                                         $subfeedquery = $subquery . '&feed=' . $this->preg_index(2);
    1157                                         $subcommentquery = $subquery . '&cpage=' . $this->preg_index(2);
    1158                                         $subembedquery = $subquery . '&embed=true';
     1180                                        $subquery        = $index . '?attachment=' . $this->preg_index( 1 );
     1181                                        $subtbquery      = $subquery . '&tb=1';
     1182                                        $subfeedquery    = $subquery . '&feed=' . $this->preg_index( 2 );
     1183                                        $subcommentquery = $subquery . '&cpage=' . $this->preg_index( 2 );
     1184                                        $subembedquery   = $subquery . '&embed=true';
    11591185
    11601186                                        // Do endpoints for attachments.
    1161                                         if ( !empty($endpoints) ) {
     1187                                        if ( ! empty( $endpoints ) ) {
    11621188                                                foreach ( (array) $ep_query_append as $regex => $ep ) {
    11631189                                                        if ( $ep[0] & EP_ATTACHMENT ) {
    1164                                                                 $rewrite[$sub1 . $regex] = $subquery . $ep[1] . $this->preg_index(3);
    1165                                                                 $rewrite[$sub2 . $regex] = $subquery . $ep[1] . $this->preg_index(3);
     1190                                                                $rewrite[ $sub1 . $regex ] = $subquery . $ep[1] . $this->preg_index( 3 );
     1191                                                                $rewrite[ $sub2 . $regex ] = $subquery . $ep[1] . $this->preg_index( 3 );
    11661192                                                        }
    11671193                                                }
    11681194                                        }
     
    11811207                                         * When cast to int, returned 0.
    11821208                                         */
    11831209                                        $match = $match . '(?:/([0-9]+))?/?$';
    1184                                         $query = $index . '?' . $query . '&page=' . $this->preg_index($num_toks + 1);
     1210                                        $query = $index . '?' . $query . '&page=' . $this->preg_index( $num_toks + 1 );
    11851211
    1186                                 // Not matching a permalink so this is a lot simpler.
     1212                                        // Not matching a permalink so this is a lot simpler.
    11871213                                } else {
    11881214                                        // Close the match and finalise the query.
    11891215                                        $match .= '?$';
     
    11951221                                 * only contains rules/queries for trackback, pages etc) to the main regex/query for
    11961222                                 * this dir
    11971223                                 */
    1198                                 $rewrite = array_merge($rewrite, array($match => $query));
     1224                                $rewrite = array_merge( $rewrite, array( $match => $query ) );
    11991225
    12001226                                // If we're matching a permalink, add those extras (attachments etc) on.
    12011227                                if ( $post ) {
    12021228                                        // Add trackback.
    1203                                         $rewrite = array_merge(array($trackbackmatch => $trackbackquery), $rewrite);
     1229                                        $rewrite = array_merge( array( $trackbackmatch => $trackbackquery ), $rewrite );
    12041230
    12051231                                        // Add embed.
    12061232                                        $rewrite = array_merge( array( $embedmatch => $embedquery ), $rewrite );
     
    12181244                                                ) );
    12191245                                        }
    12201246
    1221                                         $rewrite = array_merge( array( $sub2 => $subquery, $sub2tb => $subtbquery, $sub2feed => $subfeedquery, $sub2feed2 => $subfeedquery, $sub2comment => $subcommentquery, $sub2embed => $subembedquery ), $rewrite );
     1247                                        $rewrite = array_merge( array(
     1248                                                $sub2        => $subquery,
     1249                                                $sub2tb      => $subtbquery,
     1250                                                $sub2feed    => $subfeedquery,
     1251                                                $sub2feed2   => $subfeedquery,
     1252                                                $sub2comment => $subcommentquery,
     1253                                                $sub2embed   => $subembedquery
     1254                                        ), $rewrite );
    12221255                                }
    12231256                        }
    12241257                        // Add the rules for this dir to the accumulating $post_rewrite.
    1225                         $post_rewrite = array_merge($rewrite, $post_rewrite);
     1258                        $post_rewrite = array_merge( $rewrite, $post_rewrite );
    12261259                }
    12271260
    12281261                // The finished rules. phew!
     
    12421275         * @see WP_Rewrite::generate_rewrite_rules() See for long description and rest of parameters.
    12431276         *
    12441277         * @param string $permalink_structure The permalink structure to generate rules.
    1245          * @param bool   $walk_dirs           Optional, default is false. Whether to create list of directories to walk over.
     1278         * @param bool $walk_dirs Optional, default is false. Whether to create list of directories to walk over.
     1279         *
    12461280         * @return array
    12471281         */
    1248         public function generate_rewrite_rule($permalink_structure, $walk_dirs = false) {
    1249                 return $this->generate_rewrite_rules($permalink_structure, EP_NONE, false, false, false, $walk_dirs);
     1282        public function generate_rewrite_rule( $permalink_structure, $walk_dirs = false ) {
     1283                return $this->generate_rewrite_rules( $permalink_structure, EP_NONE, false, false, false, $walk_dirs );
    12501284        }
    12511285
    12521286        /**
     
    12701304        public function rewrite_rules() {
    12711305                $rewrite = array();
    12721306
    1273                 if ( empty($this->permalink_structure) )
     1307                if ( empty( $this->permalink_structure ) ) {
    12741308                        return $rewrite;
     1309                }
    12751310
    12761311                // robots.txt -only if installed at the root
    1277                 $home_path = parse_url( home_url() );
     1312                $home_path      = parse_url( home_url() );
    12781313                $robots_rewrite = ( empty( $home_path['path'] ) || '/' == $home_path['path'] ) ? array( 'robots\.txt$' => $this->index . '?robots=1' ) : array();
    12791314
    12801315                // Old feed and service files.
    12811316                $deprecated_files = array(
    12821317                        '.*wp-(atom|rdf|rss|rss2|feed|commentsrss2)\.php$' => $this->index . '?feed=old',
    1283                         '.*wp-app\.php(/.*)?$' => $this->index . '?error=403',
     1318                        '.*wp-app\.php(/.*)?$'                             => $this->index . '?error=403',
    12841319                );
    12851320
    12861321                // Registration rules.
    12871322                $registration_pages = array();
    12881323                if ( is_multisite() && is_main_site() ) {
    1289                         $registration_pages['.*wp-signup.php$'] = $this->index . '?signup=true';
     1324                        $registration_pages['.*wp-signup.php$']   = $this->index . '?signup=true';
    12901325                        $registration_pages['.*wp-activate.php$'] = $this->index . '?activate=true';
    12911326                }
    12921327
     
    13061341                $post_rewrite = apply_filters( 'post_rewrite_rules', $post_rewrite );
    13071342
    13081343                // Date rewrite rules.
    1309                 $date_rewrite = $this->generate_rewrite_rules($this->get_date_permastruct(), EP_DATE);
     1344                $date_rewrite = $this->generate_rewrite_rules( $this->get_date_permastruct(), EP_DATE );
    13101345
    13111346                /**
    13121347                 * Filters rewrite rules used for date archives.
     
    13201355                $date_rewrite = apply_filters( 'date_rewrite_rules', $date_rewrite );
    13211356
    13221357                // Root-level rewrite rules.
    1323                 $root_rewrite = $this->generate_rewrite_rules($this->root . '/', EP_ROOT);
     1358                $root_rewrite = $this->generate_rewrite_rules( $this->root . '/', EP_ROOT );
    13241359
    13251360                /**
    13261361                 * Filters rewrite rules used for root-level archives.
     
    13351370                $root_rewrite = apply_filters( 'root_rewrite_rules', $root_rewrite );
    13361371
    13371372                // Comments rewrite rules.
    1338                 $comments_rewrite = $this->generate_rewrite_rules($this->root . $this->comments_base, EP_COMMENTS, false, true, true, false);
     1373                $comments_rewrite = $this->generate_rewrite_rules( $this->root . $this->comments_base, EP_COMMENTS, false, true, true, false );
    13391374
    13401375                /**
    13411376                 * Filters rewrite rules used for comment feed archives.
     
    13501385
    13511386                // Search rewrite rules.
    13521387                $search_structure = $this->get_search_permastruct();
    1353                 $search_rewrite = $this->generate_rewrite_rules($search_structure, EP_SEARCH);
     1388                $search_rewrite   = $this->generate_rewrite_rules( $search_structure, EP_SEARCH );
    13541389
    13551390                /**
    13561391                 * Filters rewrite rules used for search archives.
     
    13651400                $search_rewrite = apply_filters( 'search_rewrite_rules', $search_rewrite );
    13661401
    13671402                // Author rewrite rules.
    1368                 $author_rewrite = $this->generate_rewrite_rules($this->get_author_permastruct(), EP_AUTHORS);
     1403                $author_rewrite = $this->generate_rewrite_rules( $this->get_author_permastruct(), EP_AUTHORS );
    13691404
    13701405                /**
    13711406                 * Filters rewrite rules used for author archives.
     
    13941429                // Extra permastructs.
    13951430                foreach ( $this->extra_permastructs as $permastructname => $struct ) {
    13961431                        if ( is_array( $struct ) ) {
    1397                                 if ( count( $struct ) == 2 )
     1432                                if ( count( $struct ) == 2 ) {
    13981433                                        $rules = $this->generate_rewrite_rules( $struct[0], $struct[1] );
    1399                                 else
     1434                                } else {
    14001435                                        $rules = $this->generate_rewrite_rules( $struct['struct'], $struct['ep_mask'], $struct['paged'], $struct['feed'], $struct['forcomments'], $struct['walk_dirs'], $struct['endpoints'] );
     1436                                }
    14011437                        } else {
    14021438                                $rules = $this->generate_rewrite_rules( $struct );
    14031439                        }
     
    14151451                         */
    14161452                        $rules = apply_filters( "{$permastructname}_rewrite_rules", $rules );
    14171453                        if ( 'post_tag' == $permastructname ) {
    1418 
    1419                                 /**
    1420                                  * Filters rewrite rules used specifically for Tags.
    1421                                  *
    1422                                  * @since 2.3.0
    1423                                  * @deprecated 3.1.0 Use 'post_tag_rewrite_rules' instead
    1424                                  *
    1425                                  * @param array $rules The rewrite rules generated for tags.
    1426                                  */
    1427                                 $rules = apply_filters( 'tag_rewrite_rules', $rules );
     1454                                /** This filter is documented in wp-includes/class-wp-rewrite.php */
     1455                                $rules = apply_filters_deprecated( 'tag_rewrite_rules', array( $rules ), '3.1.0', 'post_tag_rewrite_rules' );
    14281456                        }
    14291457
    1430                         $this->extra_rules_top = array_merge($this->extra_rules_top, $rules);
     1458                        $this->extra_rules_top = array_merge( $this->extra_rules_top, $rules );
    14311459                }
    14321460
    14331461                // Put them together.
    1434                 if ( $this->use_verbose_page_rules )
    1435                         $this->rules = array_merge($this->extra_rules_top, $robots_rewrite, $deprecated_files, $registration_pages, $root_rewrite, $comments_rewrite, $search_rewrite,  $author_rewrite, $date_rewrite, $page_rewrite, $post_rewrite, $this->extra_rules);
    1436                 else
    1437                         $this->rules = array_merge($this->extra_rules_top, $robots_rewrite, $deprecated_files, $registration_pages, $root_rewrite, $comments_rewrite, $search_rewrite,  $author_rewrite, $date_rewrite, $post_rewrite, $page_rewrite, $this->extra_rules);
     1462                if ( $this->use_verbose_page_rules ) {
     1463                        $this->rules = array_merge( $this->extra_rules_top, $robots_rewrite, $deprecated_files, $registration_pages, $root_rewrite, $comments_rewrite, $search_rewrite, $author_rewrite, $date_rewrite, $page_rewrite, $post_rewrite, $this->extra_rules );
     1464                } else {
     1465                        $this->rules = array_merge( $this->extra_rules_top, $robots_rewrite, $deprecated_files, $registration_pages, $root_rewrite, $comments_rewrite, $search_rewrite, $author_rewrite, $date_rewrite, $post_rewrite, $page_rewrite, $this->extra_rules );
     1466                }
    14381467
    14391468                /**
    14401469                 * Fires after the rewrite rules are generated.
     
    14501479                 *
    14511480                 * @since 1.5.0
    14521481                 *
    1453                  * @param array $this->rules The compiled array of rewrite rules.
     1482                 * @param array $this ->rules The compiled array of rewrite rules.
    14541483                 */
    14551484                $this->rules = apply_filters( 'rewrite_rules_array', $this->rules );
    14561485
     
    14711500         * @return array Rewrite rules.
    14721501         */
    14731502        public function wp_rewrite_rules() {
    1474                 $this->rules = get_option('rewrite_rules');
    1475                 if ( empty($this->rules) ) {
     1503                $this->rules = get_option( 'rewrite_rules' );
     1504                if ( empty( $this->rules ) ) {
    14761505                        $this->matches = 'matches';
    14771506                        $this->rewrite_rules();
    14781507                        if ( ! did_action( 'wp_loaded' ) ) {
    14791508                                add_action( 'wp_loaded', array( $this, 'flush_rules' ) );
     1509
    14801510                                return $this->rules;
    14811511                        }
    1482                         update_option('rewrite_rules', $this->rules);
     1512                        update_option( 'rewrite_rules', $this->rules );
    14831513                }
    14841514
    14851515                return $this->rules;
     
    15001530         * @return string
    15011531         */
    15021532        public function mod_rewrite_rules() {
    1503                 if ( ! $this->using_permalinks() )
     1533                if ( ! $this->using_permalinks() ) {
    15041534                        return '';
     1535                }
    15051536
    15061537                $site_root = parse_url( site_url() );
    1507                 if ( isset( $site_root['path'] ) )
    1508                         $site_root = trailingslashit($site_root['path']);
     1538                if ( isset( $site_root['path'] ) ) {
     1539                        $site_root = trailingslashit( $site_root['path'] );
     1540                }
    15091541
    1510                 $home_root = parse_url(home_url());
    1511                 if ( isset( $home_root['path'] ) )
    1512                         $home_root = trailingslashit($home_root['path']);
    1513                 else
     1542                $home_root = parse_url( home_url() );
     1543                if ( isset( $home_root['path'] ) ) {
     1544                        $home_root = trailingslashit( $home_root['path'] );
     1545                } else {
    15141546                        $home_root = '/';
     1547                }
    15151548
    15161549                $rules = "<IfModule mod_rewrite.c>\n";
    15171550                $rules .= "RewriteEngine On\n";
     
    15211554                $rules .= "RewriteRule ^index\.php$ - [L]\n";
    15221555
    15231556                // Add in the rules that don't redirect to WP's index.php (and thus shouldn't be handled by WP at all).
    1524                 foreach ( (array) $this->non_wp_rules as $match => $query) {
     1557                foreach ( (array) $this->non_wp_rules as $match => $query ) {
    15251558                        // Apache 1.3 does not support the reluctant (non-greedy) modifier.
    1526                         $match = str_replace('.+?', '.+', $match);
     1559                        $match = str_replace( '.+?', '.+', $match );
    15271560
    15281561                        $rules .= 'RewriteRule ^' . $match . ' ' . $home_root . $query . " [QSA,L]\n";
    15291562                }
    15301563
    15311564                if ( $this->use_verbose_rules ) {
    15321565                        $this->matches = '';
    1533                         $rewrite = $this->rewrite_rules();
    1534                         $num_rules = count($rewrite);
    1535                         $rules .= "RewriteCond %{REQUEST_FILENAME} -f [OR]\n" .
    1536                                 "RewriteCond %{REQUEST_FILENAME} -d\n" .
    1537                                 "RewriteRule ^.*$ - [S=$num_rules]\n";
     1566                        $rewrite       = $this->rewrite_rules();
     1567                        $num_rules     = count( $rewrite );
     1568                        $rules         .= "RewriteCond %{REQUEST_FILENAME} -f [OR]\n" .
     1569                                          "RewriteCond %{REQUEST_FILENAME} -d\n" .
     1570                                          "RewriteRule ^.*$ - [S=$num_rules]\n";
    15381571
    1539                         foreach ( (array) $rewrite as $match => $query) {
     1572                        foreach ( (array) $rewrite as $match => $query ) {
    15401573                                // Apache 1.3 does not support the reluctant (non-greedy) modifier.
    1541                                 $match = str_replace('.+?', '.+', $match);
     1574                                $match = str_replace( '.+?', '.+', $match );
    15421575
    1543                                 if ( strpos($query, $this->index) !== false )
     1576                                if ( strpos( $query, $this->index ) !== false ) {
    15441577                                        $rules .= 'RewriteRule ^' . $match . ' ' . $home_root . $query . " [QSA,L]\n";
    1545                                 else
     1578                                } else {
    15461579                                        $rules .= 'RewriteRule ^' . $match . ' ' . $site_root . $query . " [QSA,L]\n";
     1580                                }
    15471581                        }
    15481582                } else {
    15491583                        $rules .= "RewriteCond %{REQUEST_FILENAME} !-f\n" .
    1550                                 "RewriteCond %{REQUEST_FILENAME} !-d\n" .
    1551                                 "RewriteRule . {$home_root}{$this->index} [L]\n";
     1584                                  "RewriteCond %{REQUEST_FILENAME} !-d\n" .
     1585                                  "RewriteRule . {$home_root}{$this->index} [L]\n";
    15521586                }
    15531587
    15541588                $rules .= "</IfModule>\n";
     
    15621596                 */
    15631597                $rules = apply_filters( 'mod_rewrite_rules', $rules );
    15641598
    1565                 /**
    1566                  * Filters the list of rewrite rules formatted for output to an .htaccess file.
    1567                  *
    1568                  * @since 1.5.0
    1569                  * @deprecated 1.5.0 Use the mod_rewrite_rules filter instead.
    1570                  *
    1571                  * @param string $rules mod_rewrite Rewrite rules formatted for .htaccess.
    1572                  */
    1573                 return apply_filters( 'rewrite_rules', $rules );
     1599                /** This filter is documented in wp-includes/class-wp-rewrite.php */
     1600                return apply_filters_deprecated( 'rewrite_rules', array( $rules ), '1.5.0', 'mod_rewrite_rules' );
    15741601        }
    15751602
    15761603        /**
     
    15841611         *
    15851612         * @param bool $add_parent_tags Optional. Whether to add parent tags to the rewrite rule sets.
    15861613         *                              Default false.
     1614         *
    15871615         * @return string IIS7 URL rewrite rule sets.
    15881616         */
    15891617        public function iis7_url_rewrite_rules( $add_parent_tags = false ) {
    1590                 if ( ! $this->using_permalinks() )
     1618                if ( ! $this->using_permalinks() ) {
    15911619                        return '';
     1620                }
    15921621                $rules = '';
    15931622                if ( $add_parent_tags ) {
    15941623                        $rules .= '<configuration>
     
    16351664         * @since 4.4.0 Array support was added to the `$query` parameter.
    16361665         * @access public
    16371666         *
    1638          * @param string       $regex Regular expression to match request against.
     1667         * @param string $regex Regular expression to match request against.
    16391668         * @param string|array $query The corresponding query vars for this rewrite rule.
    1640          * @param string       $after Optional. Priority of the new rule. Accepts 'top'
     1669         * @param string $after Optional. Priority of the new rule. Accepts 'top'
    16411670         *                            or 'bottom'. Default 'bottom'.
    16421671         */
    16431672        public function add_rule( $regex, $query, $after = 'bottom' ) {
    16441673                if ( is_array( $query ) ) {
    16451674                        $external = false;
    1646                         $query = add_query_arg( $query, 'index.php' );
     1675                        $query    = add_query_arg( $query, 'index.php' );
    16471676                } else {
    16481677                        $index = false === strpos( $query, '?' ) ? strlen( $query ) : strpos( $query, '?' );
    16491678                        $front = substr( $query, 0, $index );
     
    16871716         * @see add_rewrite_endpoint() for full documentation.
    16881717         * @global WP $wp
    16891718         *
    1690          * @param string      $name      Name of the endpoint.
    1691          * @param int         $places    Endpoint mask describing the places the endpoint should be added.
     1719         * @param string $name Name of the endpoint.
     1720         * @param int $places Endpoint mask describing the places the endpoint should be added.
    16921721         * @param string|bool $query_var Optional. Name of the corresponding query variable. Pass `false` to
    16931722         *                               skip registering a query_var for this endpoint. Defaults to the
    16941723         *                               value of `$name`.
     
    17241753         * @since 2.5.0
    17251754         * @access public
    17261755         *
    1727          * @param string $name   Name for permalink structure.
     1756         * @param string $name Name for permalink structure.
    17281757         * @param string $struct Permalink structure (e.g. category/%category%)
    1729          * @param array  $args  {
     1758         * @param array $args {
    17301759         *     Optional. Arguments for building rewrite rules based on the permalink structure.
    17311760         *     Default empty array.
    17321761         *
    1733          *     @type bool $with_front Whether the structure should be prepended with `WP_Rewrite::$front`.
     1762         * @type bool $with_front Whether the structure should be prepended with `WP_Rewrite::$front`.
    17341763         *                             Default true.
    1735          *     @type int  $ep_mask    The endpoint mask defining which endpoints are added to the structure.
     1764         * @type int $ep_mask The endpoint mask defining which endpoints are added to the structure.
    17361765         *                             Accepts `EP_NONE`, `EP_PERMALINK`, `EP_ATTACHMENT`, `EP_DATE`, `EP_YEAR`,
    17371766         *                             `EP_MONTH`, `EP_DAY`, `EP_ROOT`, `EP_COMMENTS`, `EP_SEARCH`, `EP_CATEGORIES`,
    17381767         *                             `EP_TAGS`, `EP_AUTHORS`, `EP_PAGES`, `EP_ALL_ARCHIVES`, and `EP_ALL`.
    17391768         *                             Default `EP_NONE`.
    1740          *     @type bool $paged      Whether archive pagination rules should be added for the structure.
     1769         * @type bool $paged Whether archive pagination rules should be added for the structure.
    17411770         *                             Default true.
    1742          *     @type bool $feed        Whether feed rewrite rules should be added for the structure. Default true.
    1743          *     @type bool $forcomments Whether the feed rules should be a query for a comments feed. Default false.
    1744          *     @type bool $walk_dirs  Whether the 'directories' making up the structure should be walked over
     1771         * @type bool $feed Whether feed rewrite rules should be added for the structure. Default true.
     1772         * @type bool $forcomments Whether the feed rules should be a query for a comments feed. Default false.
     1773         * @type bool $walk_dirs Whether the 'directories' making up the structure should be walked over
    17451774         *                             and rewrite rules built for each in-turn. Default true.
    1746          *     @type bool $endpoints  Whether endpoints should be applied to the generated rules. Default true.
     1775         * @type bool $endpoints Whether endpoints should be applied to the generated rules. Default true.
    17471776         * }
    17481777         */
    17491778        public function add_permastruct( $name, $struct, $args = array() ) {
    17501779                // Back-compat for the old parameters: $with_front and $ep_mask.
    1751                 if ( ! is_array( $args ) )
     1780                if ( ! is_array( $args ) ) {
    17521781                        $args = array( 'with_front' => $args );
    1753                 if ( func_num_args() == 4 )
     1782                }
     1783                if ( func_num_args() == 4 ) {
    17541784                        $args['ep_mask'] = func_get_arg( 3 );
     1785                }
    17551786
    17561787                $defaults = array(
    1757                         'with_front' => true,
    1758                         'ep_mask' => EP_NONE,
    1759                         'paged' => true,
    1760                         'feed' => true,
     1788                        'with_front'  => true,
     1789                        'ep_mask'     => EP_NONE,
     1790                        'paged'       => true,
     1791                        'feed'        => true,
    17611792                        'forcomments' => false,
    1762                         'walk_dirs' => true,
    1763                         'endpoints' => true,
     1793                        'walk_dirs'   => true,
     1794                        'endpoints'   => true,
    17641795                );
    1765                 $args = array_intersect_key( $args, $defaults );
    1766                 $args = wp_parse_args( $args, $defaults );
     1796                $args     = array_intersect_key( $args, $defaults );
     1797                $args     = wp_parse_args( $args, $defaults );
    17671798
    1768                 if ( $args['with_front'] )
     1799                if ( $args['with_front'] ) {
    17691800                        $struct = $this->front . $struct;
    1770                 else
     1801                } else {
    17711802                        $struct = $this->root . $struct;
     1803                }
    17721804                $args['struct'] = $struct;
    17731805
    17741806                $this->extra_permastructs[ $name ] = $args;
     
    18061838                if ( ! did_action( 'wp_loaded' ) ) {
    18071839                        add_action( 'wp_loaded', array( $this, 'flush_rules' ) );
    18081840                        $do_hard_later = ( isset( $do_hard_later ) ) ? $do_hard_later || $hard : $hard;
     1841
    18091842                        return;
    18101843                }
    18111844
     
    18291862                if ( ! $hard || ! apply_filters( 'flush_rewrite_rules_hard', true ) ) {
    18301863                        return;
    18311864                }
    1832                 if ( function_exists( 'save_mod_rewrite_rules' ) )
     1865                if ( function_exists( 'save_mod_rewrite_rules' ) ) {
    18331866                        save_mod_rewrite_rules();
    1834                 if ( function_exists( 'iis7_save_url_rewrite_rules' ) )
     1867                }
     1868                if ( function_exists( 'iis7_save_url_rewrite_rules' ) ) {
    18351869                        iis7_save_url_rewrite_rules();
     1870                }
    18361871        }
    18371872
    18381873        /**
     
    18461881         * @access public
    18471882         */
    18481883        public function init() {
    1849                 $this->extra_rules = $this->non_wp_rules = $this->endpoints = array();
    1850                 $this->permalink_structure = get_option('permalink_structure');
    1851                 $this->front = substr($this->permalink_structure, 0, strpos($this->permalink_structure, '%'));
    1852                 $this->root = '';
     1884                $this->extra_rules         = $this->non_wp_rules = $this->endpoints = array();
     1885                $this->permalink_structure = get_option( 'permalink_structure' );
     1886                $this->front               = substr( $this->permalink_structure, 0, strpos( $this->permalink_structure, '%' ) );
     1887                $this->root                = '';
    18531888
    1854                 if ( $this->using_index_permalinks() )
     1889                if ( $this->using_index_permalinks() ) {
    18551890                        $this->root = $this->index . '/';
     1891                }
    18561892
    1857                 unset($this->author_structure);
    1858                 unset($this->date_structure);
    1859                 unset($this->page_structure);
    1860                 unset($this->search_structure);
    1861                 unset($this->feed_structure);
    1862                 unset($this->comment_feed_structure);
    1863                 $this->use_trailing_slashes = ( '/' == substr($this->permalink_structure, -1, 1) );
     1893                unset( $this->author_structure );
     1894                unset( $this->date_structure );
     1895                unset( $this->page_structure );
     1896                unset( $this->search_structure );
     1897                unset( $this->feed_structure );
     1898                unset( $this->comment_feed_structure );
     1899                $this->use_trailing_slashes = ( '/' == substr( $this->permalink_structure, - 1, 1 ) );
    18641900
    18651901                // Enable generic rules for pages if permalink structure doesn't begin with a wildcard.
    1866                 if ( preg_match("/^[^%]*%(?:postname|category|tag|author)%/", $this->permalink_structure) )
    1867                          $this->use_verbose_page_rules = true;
    1868                 else
     1902                if ( preg_match( "/^[^%]*%(?:postname|category|tag|author)%/", $this->permalink_structure ) ) {
     1903                        $this->use_verbose_page_rules = true;
     1904                } else {
    18691905                        $this->use_verbose_page_rules = false;
     1906                }
    18701907        }
    18711908
    18721909        /**
     
    18841921         *
    18851922         * @param string $permalink_structure Permalink structure.
    18861923         */
    1887         public function set_permalink_structure($permalink_structure) {
     1924        public function set_permalink_structure( $permalink_structure ) {
    18881925                if ( $permalink_structure != $this->permalink_structure ) {
    18891926                        $old_permalink_structure = $this->permalink_structure;
    1890                         update_option('permalink_structure', $permalink_structure);
     1927                        update_option( 'permalink_structure', $permalink_structure );
    18911928
    18921929                        $this->init();
    18931930
     
    18971934                         * @since 2.8.0
    18981935                         *
    18991936                         * @param string $old_permalink_structure The previous permalink structure.
    1900                          * @param string $permalink_structure     The new permalink structure.
     1937                         * @param string $permalink_structure The new permalink structure.
    19011938                         */
    19021939                        do_action( 'permalink_structure_changed', $old_permalink_structure, $permalink_structure );
    19031940                }
     
    19151952         *
    19161953         * @param string $category_base Category permalink structure base.
    19171954         */
    1918         public function set_category_base($category_base) {
    1919                 if ( $category_base != get_option('category_base') ) {
    1920                         update_option('category_base', $category_base);
     1955        public function set_category_base( $category_base ) {
     1956                if ( $category_base != get_option( 'category_base' ) ) {
     1957                        update_option( 'category_base', $category_base );
    19211958                        $this->init();
    19221959                }
    19231960        }
     
    19351972         * @param string $tag_base Tag permalink structure base.
    19361973         */
    19371974        public function set_tag_base( $tag_base ) {
    1938                 if ( $tag_base != get_option( 'tag_base') ) {
     1975                if ( $tag_base != get_option( 'tag_base' ) ) {
    19391976                        update_option( 'tag_base', $tag_base );
    19401977                        $this->init();
    19411978                }