2006-03-12 22:57:00 +00:00
< ? php
2008-09-01 05:47:08 +00:00
/**
* WordPress Rewrite API
*
* @ package WordPress
* @ subpackage Rewrite
*/
2006-03-12 22:57:00 +00:00
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Add a straight rewrite rule .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* @ see WP_Rewrite :: add_rule () for long description .
2008-09-01 05:47:08 +00:00
* @ since 2.1 . 0
*
2008-09-16 00:35:56 +00:00
* @ param string $regex Regular Expression to match request against .
* @ param string $redirect Page to redirect to .
* @ param string $after Optional , default is 'bottom' . Where to add rule , can also be 'top' .
2008-09-01 05:47:08 +00:00
*/
2007-06-27 21:39:50 +00:00
function add_rewrite_rule ( $regex , $redirect , $after = 'bottom' ) {
2006-03-12 22:57:00 +00:00
global $wp_rewrite ;
2007-08-28 19:55:11 +00:00
$wp_rewrite -> add_rule ( $regex , $redirect , $after );
2006-03-12 22:57:00 +00:00
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Add a new tag ( like % postname % ) .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Warning : you must call this on init or earlier , otherwise the query var
* addition stuff won ' t work .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*
2008-09-16 00:35:56 +00:00
* @ param string $tagname
* @ param string $regex
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function add_rewrite_tag ( $tagname , $regex ) {
//validation
if ( strlen ( $tagname ) < 3 || $tagname { 0 } != '%' || $tagname { strlen ( $tagname ) - 1 } != '%' ) {
return ;
}
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
$qv = trim ( $tagname , '%' );
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
global $wp_rewrite , $wp ;
$wp -> add_query_var ( $qv );
$wp_rewrite -> add_rewrite_tag ( $tagname , $regex , $qv . '=' );
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Add a new feed type like / atom1 /.
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*
2008-09-16 00:35:56 +00:00
* @ param string $feedname
* @ param callback $function Callback to run on feed display .
* @ return string Feed action name .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function add_feed ( $feedname , $function ) {
global $wp_rewrite ;
if ( ! in_array ( $feedname , $wp_rewrite -> feeds )) { //override the file if it is
$wp_rewrite -> feeds [] = $feedname ;
}
$hook = 'do_feed_' . $feedname ;
2008-06-24 00:29:04 +00:00
// Remove default function hook
remove_action ( $hook , $hook , 10 , 1 );
2006-03-12 22:57:00 +00:00
add_action ( $hook , $function , 10 , 1 );
return $hook ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for Permalink .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_PERMALINK' , 1 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for Attachment .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_ATTACHMENT' , 2 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for date .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_DATE' , 4 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for year
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_YEAR' , 8 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for month .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_MONTH' , 16 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for day .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_DAY' , 32 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for root .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_ROOT' , 64 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for comments .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_COMMENTS' , 128 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for searches .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_SEARCH' , 256 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for categories .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_CATEGORIES' , 512 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for tags .
2008-09-01 05:47:08 +00:00
*
* @ since 2.3 . 0
*/
define ( 'EP_TAGS' , 1024 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for authors .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_AUTHORS' , 2048 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for pages .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_PAGES' , 4096 );
2006-03-12 22:57:00 +00:00
//pseudo-places
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for default , which is nothing .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_NONE' , 0 );
/**
2008-09-16 00:35:56 +00:00
* Endpoint Mask for everything .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
*/
define ( 'EP_ALL' , 8191 );
2006-03-12 22:57:00 +00:00
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Add an endpoint , like / trackback /.
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The endpoints are added to the end of the request . So a request matching
* " /2008/10/14/my_post/myep/ " , the endpoint will be " /myep/ " .
2008-09-01 05:47:08 +00:00
*
2009-04-27 21:11:01 +00:00
* Be sure to flush the rewrite rules ( wp_rewrite -> flush ()) when your plugin gets
* activated ( register_activation_hook ()) and deactivated ( register_deactivation_hook ())
*
2008-09-01 05:47:08 +00:00
* @ since 2.1 . 0
2008-09-16 00:35:56 +00:00
* @ see WP_Rewrite :: add_endpoint () Parameters and more description .
* @ uses $wp_rewrite
2008-09-01 05:47:08 +00:00
*
* @ param unknown_type $name
* @ param unknown_type $places
*/
2006-03-12 22:57:00 +00:00
function add_rewrite_endpoint ( $name , $places ) {
global $wp_rewrite ;
$wp_rewrite -> add_endpoint ( $name , $places );
}
2008-06-29 08:20:25 +00:00
/**
2008-09-18 06:14:01 +00:00
* Filter the URL base for taxonomies .
*
* To remove any manually prepended / index . php /.
*
* @ access private
* @ since 2.6 . 0
* @ author Mark Jaquith
*
* @ param string $base The taxonomy base that we ' re going to filter
* @ return string
*/
2008-06-29 08:20:25 +00:00
function _wp_filter_taxonomy_base ( $base ) {
2008-07-17 19:41:48 +00:00
if ( ! empty ( $base ) ) {
$base = preg_replace ( '|^/index\.php/|' , '' , $base );
$base = trim ( $base , '/' );
}
2008-06-29 08:20:25 +00:00
return $base ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Examine a url and try to determine the post ID it represents .
2008-09-01 05:47:08 +00:00
*
* Checks are supposedly from the hosted site blog .
*
* @ since 1.0 . 0
*
2008-09-16 00:35:56 +00:00
* @ param string $url Permalink to check .
* @ return int Post ID , or 0 on failure .
2008-09-01 05:47:08 +00:00
*/
2006-04-18 04:47:26 +00:00
function url_to_postid ( $url ) {
global $wp_rewrite ;
2007-06-14 02:25:30 +00:00
2007-04-18 22:51:54 +00:00
$url = apply_filters ( 'url_to_postid' , $url );
2006-04-18 04:47:26 +00:00
// First, check to see if there is a 'p=N' or 'page_id=N' to match against
2008-03-27 22:05:51 +00:00
if ( preg_match ( '#[?&](p|page_id|attachment_id)=(\d+)#' , $url , $values ) ) {
2008-01-10 20:51:07 +00:00
$id = absint ( $values [ 2 ]);
if ( $id )
return $id ;
}
2006-04-18 04:47:26 +00:00
// Check to see if we are using rewrite rules
$rewrite = $wp_rewrite -> wp_rewrite_rules ();
// Not using rewrite rules, and 'p=N' and 'page_id=N' methods failed, so we're out of options
if ( empty ( $rewrite ) )
return 0 ;
// $url cleanup by Mark Jaquith
// This fixes things like #anchors, ?query=strings, missing 'www.',
// added 'www.', or added 'index.php/' that will mess up our WP_Query
// and return a false negative
// Get rid of the #anchor
$url_split = explode ( '#' , $url );
$url = $url_split [ 0 ];
2006-08-30 16:40:17 +00:00
// Get rid of URL ?query=string
2006-04-18 04:47:26 +00:00
$url_split = explode ( '?' , $url );
$url = $url_split [ 0 ];
// Add 'www.' if it is absent and should be there
2010-01-04 17:23:29 +00:00
if ( false !== strpos ( home_url (), '://www.' ) && false === strpos ( $url , '://www.' ) )
2006-04-18 04:47:26 +00:00
$url = str_replace ( '://' , '://www.' , $url );
// Strip 'www.' if it is present and shouldn't be
2010-01-04 17:23:29 +00:00
if ( false === strpos ( home_url (), '://www.' ) )
2006-04-18 04:47:26 +00:00
$url = str_replace ( '://www.' , '://' , $url );
// Strip 'index.php/' if we're not using path info permalinks
2006-09-21 00:09:37 +00:00
if ( ! $wp_rewrite -> using_index_permalinks () )
2006-04-18 04:47:26 +00:00
$url = str_replace ( 'index.php/' , '' , $url );
2010-01-04 17:23:29 +00:00
if ( false !== strpos ( $url , home_url ()) ) {
2006-04-18 04:47:26 +00:00
// Chop off http://domain.com
2010-01-04 17:23:29 +00:00
$url = str_replace ( home_url (), '' , $url );
2006-04-18 04:47:26 +00:00
} else {
// Chop off /path/to/blog
2010-01-04 17:23:29 +00:00
$home_path = parse_url ( home_url ());
2006-04-18 04:47:26 +00:00
$home_path = $home_path [ 'path' ];
$url = str_replace ( $home_path , '' , $url );
}
// Trim leading and lagging slashes
$url = trim ( $url , '/' );
$request = $url ;
// Done with cleanup
// Look for matches.
$request_match = $request ;
foreach ( $rewrite as $match => $query ) {
// If the requesting file is the anchor of the match, prepend it
// to the path info.
2008-01-14 21:44:08 +00:00
if ( ( ! empty ( $url )) && ( strpos ( $match , $url ) === 0 ) && ( $url != $request )) {
2006-04-18 04:47:26 +00:00
$request_match = $url . '/' . $request ;
}
if ( preg_match ( " !^ $match ! " , $request_match , $matches ) ) {
// Got a match.
// Trim the query of everything up to the '?'.
$query = preg_replace ( " !^.+ \ ?! " , '' , $query );
// Substitute the substring matches into the query.
2009-08-20 20:09:36 +00:00
$query = addslashes ( WP_MatchesMapRegex :: apply ( $query , $matches ));
2007-08-23 16:09:37 +00:00
// Filter out non-public query vars
global $wp ;
parse_str ( $query , $query_vars );
$query = array ();
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $query_vars as $key => $value ) {
2007-08-23 16:09:37 +00:00
if ( in_array ( $key , $wp -> public_query_vars ) )
$query [ $key ] = $value ;
}
// Do the query
2006-04-18 04:47:26 +00:00
$query = new WP_Query ( $query );
if ( $query -> is_single || $query -> is_page )
return $query -> post -> ID ;
else
return 0 ;
}
}
return 0 ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* WordPress Rewrite Component .
*
* The WordPress Rewrite class writes the rewrite module rules to the . htaccess
* file . It also handles parsing the request to get the correct setup for the
* WordPress Query class .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The Rewrite along with WP class function as a front controller for WordPress .
* You can add rules to trigger your page view and processing using this
* component . The full functionality of a front controller does not exist ,
* meaning you can ' t define how the template files load based on the rewrite
* rules .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
*/
2006-03-12 22:57:00 +00:00
class WP_Rewrite {
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Default permalink structure for WordPress .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $permalink_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Whether to add trailing slashes .
2008-09-01 05:47:08 +00:00
*
* @ since 2.2 . 0
* @ access private
* @ var bool
*/
2007-02-15 07:07:12 +00:00
var $use_trailing_slashes ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Customized or default category permalink base ( example . com / xx / tagname ) .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $category_base ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Customized or default tag permalink base ( example . com / xx / tagname ) .
2008-09-01 05:47:08 +00:00
*
* @ since 2.3 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2007-03-31 09:19:32 +00:00
var $tag_base ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink request structure for categories .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $category_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink request structure for tags .
2008-09-01 05:47:08 +00:00
*
* @ since 2.3 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2007-03-31 09:19:32 +00:00
var $tag_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink author request base ( example . com / author / authorname ) .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $author_base = 'author' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink request structure for author pages .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $author_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink request structure for dates .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $date_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink request structure for pages .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $page_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Search permalink base ( example . com / search / query ) .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $search_base = 'search' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink request structure for searches .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $search_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Comments permalink base .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $comments_base = 'comments' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Feed permalink base .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $feed_base = 'feed' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Comments feed request structure permalink .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $comments_feed_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Feed request structure permalink .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $feed_structure ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Front URL path .
*
* The difference between the root property is that WordPress might be
* located at example / WordPress / index . php , if permalinks are turned off . The
2008-09-18 06:14:01 +00:00
* WordPress / index . php will be the front portion . If permalinks are turned
* on , this will most likely be empty or not set .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $front ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Root URL path to WordPress ( without domain ) .
*
* The difference between front property is that WordPress might be located
* at example . com / WordPress /. The root is the 'WordPress/' portion .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
2008-09-16 00:35:56 +00:00
* @ access private
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $root = '' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Permalink to the home page .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
* @ var string
*/
2006-03-12 22:57:00 +00:00
var $index = 'index.php' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Request match string .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
var $matches = '' ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Rewrite rules to match against the request to find the redirect or query .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var array
*/
2006-03-12 22:57:00 +00:00
var $rules ;
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Additional rules added external to the rewrite class .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Those not generated by the class , see add_rewrite_rule () .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
* @ access private
* @ var array
*/
var $extra_rules = array (); //
/**
2008-09-16 00:35:56 +00:00
* Additional rules that belong at the beginning to match first .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Those not generated by the class , see add_rewrite_rule () .
2008-09-01 05:47:08 +00:00
*
* @ since 2.3 . 0
* @ access private
* @ var array
*/
var $extra_rules_top = array (); //
/**
2008-09-18 06:14:01 +00:00
* Rules that don 't redirect to WP' s index . php .
*
* These rules are written to the mod_rewrite portion of the . htaccess .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
* @ access private
* @ var array
*/
var $non_wp_rules = array (); //
/**
2008-09-18 06:14:01 +00:00
* Extra permalink structures .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
* @ access private
2008-09-16 00:35:56 +00:00
* @ var array
2008-09-01 05:47:08 +00:00
*/
2008-03-23 22:10:00 +00:00
var $extra_permastructs = array ();
2008-09-16 00:35:56 +00:00
/**
2008-12-09 18:03:31 +00:00
* Endpoints permalinks
2008-09-16 00:35:56 +00:00
*
* @ since unknown
* @ access private
* @ var array
*/
2006-03-12 22:57:00 +00:00
var $endpoints ;
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Whether to write every mod_rewrite rule for WordPress .
*
* This is off by default , turning it on might print a lot of rewrite rules
* to the . htaccess file .
2008-09-01 05:47:08 +00:00
*
* @ since 2.0 . 0
* @ access public
* @ var bool
*/
2006-03-12 22:57:00 +00:00
var $use_verbose_rules = false ;
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Whether to write every mod_rewrite rule for WordPress pages .
2008-09-01 05:47:08 +00:00
*
* @ since 2.5 . 0
* @ access public
* @ var bool
*/
2007-12-04 00:19:10 +00:00
var $use_verbose_page_rules = true ;
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Permalink structure search for preg_replace .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var array
*/
2006-11-19 07:56:05 +00:00
var $rewritecode =
2006-03-12 22:57:00 +00:00
array (
'%year%' ,
'%monthnum%' ,
'%day%' ,
'%hour%' ,
'%minute%' ,
'%second%' ,
'%postname%' ,
'%post_id%' ,
'%category%' ,
2007-03-31 09:19:32 +00:00
'%tag%' ,
2006-03-12 22:57:00 +00:00
'%author%' ,
'%pagename%' ,
'%search%'
);
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Preg_replace values for the search , see { @ link WP_Rewrite :: $rewritecode } .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var array
*/
2006-11-19 07:56:05 +00:00
var $rewritereplace =
2006-03-12 22:57:00 +00:00
array (
'([0-9]{4})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([^/]+)' ,
'([0-9]+)' ,
'(.+?)' ,
2007-03-31 09:19:32 +00:00
'(.+?)' ,
2006-03-12 22:57:00 +00:00
'([^/]+)' ,
2008-02-21 23:49:05 +00:00
'([^/]+?)' ,
2006-03-12 22:57:00 +00:00
'(.+)'
);
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Search for the query to look for replacing .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var array
*/
2006-11-19 07:56:05 +00:00
var $queryreplace =
2006-03-12 22:57:00 +00:00
array (
'year=' ,
'monthnum=' ,
'day=' ,
'hour=' ,
'minute=' ,
'second=' ,
'name=' ,
'p=' ,
'category_name=' ,
2007-03-31 09:19:32 +00:00
'tag=' ,
2006-03-12 22:57:00 +00:00
'author_name=' ,
'pagename=' ,
's='
);
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Supported default feeds .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access private
* @ var array
*/
2006-03-12 22:57:00 +00:00
var $feeds = array ( 'feed' , 'rdf' , 'rss' , 'rss2' , 'atom' );
2006-11-19 07:56:05 +00:00
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Whether permalinks are being used .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* This can be either rewrite module or permalink in the HTTP query string .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool True , if permalinks are enabled .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function using_permalinks () {
if ( empty ( $this -> permalink_structure ))
return false ;
else
return true ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Whether permalinks are being used and rewrite module is not enabled .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Means that permalink links are enabled and index . php is in the URL .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function using_index_permalinks () {
if ( empty ( $this -> permalink_structure )) {
return false ;
}
// If the index is not in the permalink, we're using mod_rewrite.
if ( preg_match ( '#^/*' . $this -> index . '#' , $this -> permalink_structure )) {
return true ;
}
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
return false ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Whether permalinks are being used and rewrite module is enabled .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Using permalinks and index . php is not in the URL .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function using_mod_rewrite_permalinks () {
if ( $this -> using_permalinks () && ! $this -> using_index_permalinks ())
return true ;
else
return false ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Index for matches for usage in preg_ * () functions .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* The format of the string is , with empty matches property value , '$NUM' .
* The 'NUM' will be replaced with the value in the $number parameter . With
* the matches property not empty , the value of the returned string will
* contain that value of the matches property . The format then will be
* '$MATCHES[NUM]' , with MATCHES as the value in the property and NUM the
* value of the $number parameter .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ param int $number Index number .
* @ return string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function preg_index ( $number ) {
$match_prefix = '$' ;
$match_suffix = '' ;
2008-09-18 06:14:01 +00:00
if ( ! empty ( $this -> matches ) ) {
2006-11-19 07:56:05 +00:00
$match_prefix = '$' . $this -> matches . '[' ;
2006-03-12 22:57:00 +00:00
$match_suffix = ']' ;
2006-11-19 07:56:05 +00:00
}
2006-03-12 22:57:00 +00:00
2006-11-19 07:56:05 +00:00
return " $match_prefix $number $match_suffix " ;
2006-03-12 22:57:00 +00:00
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Retrieve all page and attachments for pages URIs .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* The attachments are for those that have pages as parents and will be
* retrieved .
2008-09-01 05:47:08 +00:00
*
* @ since 2.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ return array Array of page URIs as first element and attachment URIs as second element .
2008-09-01 05:47:08 +00:00
*/
2007-12-04 00:19:10 +00:00
function page_uri_index () {
global $wpdb ;
//get pages in order of hierarchy, i.e. children after parents
$posts = get_page_hierarchy ( $wpdb -> get_results ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page' " ));
2009-12-23 16:23:40 +00:00
// If we have no pages get out quick
if ( ! $posts )
return array ( array (), array () );
2007-12-04 00:19:10 +00:00
//now reverse it, because we need parents after children for rewrite rules to work properly
$posts = array_reverse ( $posts , true );
$page_uris = array ();
$page_attachment_uris = array ();
foreach ( $posts as $id => $post ) {
// URL => page name
$uri = get_page_uri ( $id );
$attachments = $wpdb -> get_results ( $wpdb -> prepare ( " SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = %d " , $id ));
if ( $attachments ) {
foreach ( $attachments as $attachment ) {
$attach_uri = get_page_uri ( $attachment -> ID );
$page_attachment_uris [ $attach_uri ] = $attachment -> ID ;
}
}
$page_uris [ $uri ] = $id ;
}
return array ( $page_uris , $page_attachment_uris );
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Retrieve all of the rewrite rules for pages .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* If the 'use_verbose_page_rules' property is false , then there will only
* be a single rewrite rule for pages for those matching '%pagename%' . With
* the property set to true , the attachments and the pages will be added for
* each individual attachment URI and page URI , respectively .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ return array
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function page_rewrite_rules () {
$rewrite_rules = array ();
$page_structure = $this -> get_page_permastruct ();
2007-12-04 00:19:10 +00:00
if ( ! $this -> use_verbose_page_rules ) {
2008-02-21 23:49:05 +00:00
$this -> add_rewrite_tag ( '%pagename%' , " (.+?) " , 'pagename=' );
2007-12-04 00:19:10 +00:00
$rewrite_rules = array_merge ( $rewrite_rules , $this -> generate_rewrite_rules ( $page_structure , EP_PAGES ));
return $rewrite_rules ;
}
$page_uris = $this -> page_uri_index ();
$uris = $page_uris [ 0 ];
$attachment_uris = $page_uris [ 1 ];
2006-03-12 22:57:00 +00:00
if ( is_array ( $attachment_uris ) ) {
foreach ( $attachment_uris as $uri => $pagename ) {
$this -> add_rewrite_tag ( '%pagename%' , " ( $uri ) " , 'attachment=' );
$rewrite_rules = array_merge ( $rewrite_rules , $this -> generate_rewrite_rules ( $page_structure , EP_PAGES ));
}
}
if ( is_array ( $uris ) ) {
foreach ( $uris as $uri => $pagename ) {
$this -> add_rewrite_tag ( '%pagename%' , " ( $uri ) " , 'pagename=' );
$rewrite_rules = array_merge ( $rewrite_rules , $this -> generate_rewrite_rules ( $page_structure , EP_PAGES ));
}
}
return $rewrite_rules ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve date permalink structure , with year , month , and day .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The permalink structure for the date , if not set already depends on the
* permalink structure . It can be one of three formats . The first is year ,
* month , day ; the second is day , month , year ; and the last format is month ,
* day , year . These are matched against the permalink structure for which
* one is used . If none matches , then the default will be used , which is
* year , month , day .
*
* Prevents post ID and date permalinks from overlapping . In the case of
* post_id , the date permalink will be prepended with front permalink with
* 'date/' before the actual permalink to form the complete date permalink
* structure .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool | string False on no permalink structure . Date permalink structure .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_date_permastruct () {
if ( isset ( $this -> date_structure )) {
return $this -> date_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> date_structure = '' ;
return false ;
}
// The date permalink must have year, month, and day separated by slashes.
$endians = array ( '%year%/%monthnum%/%day%' , '%day%/%monthnum%/%year%' , '%monthnum%/%day%/%year%' );
$this -> date_structure = '' ;
$date_endian = '' ;
foreach ( $endians as $endian ) {
if ( false !== strpos ( $this -> permalink_structure , $endian )) {
$date_endian = $endian ;
break ;
}
2006-11-19 07:56:05 +00:00
}
2006-03-12 22:57:00 +00:00
if ( empty ( $date_endian ) )
$date_endian = '%year%/%monthnum%/%day%' ;
// Do not allow the date tags and %post_id% to overlap in the permalink
2006-11-19 07:56:05 +00:00
// structure. If they do, move the date tags to $front/date/.
2006-03-12 22:57:00 +00:00
$front = $this -> front ;
preg_match_all ( '/%.+?%/' , $this -> permalink_structure , $tokens );
$tok_index = 1 ;
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $tokens [ 0 ] as $token ) {
2006-03-12 22:57:00 +00:00
if ( ( $token == '%post_id%' ) && ( $tok_index <= 3 ) ) {
$front = $front . 'date/' ;
break ;
}
2006-10-03 15:56:23 +00:00
$tok_index ++ ;
2006-03-12 22:57:00 +00:00
}
$this -> date_structure = $front . $date_endian ;
return $this -> date_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the year permalink structure without month and day .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Gets the date permalink structure and strips out the month and day
* permalink structures .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool | string False on failure . Year structure on success .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_year_permastruct () {
$structure = $this -> get_date_permastruct ( $this -> permalink_structure );
if ( empty ( $structure )) {
return false ;
}
$structure = str_replace ( '%monthnum%' , '' , $structure );
$structure = str_replace ( '%day%' , '' , $structure );
$structure = preg_replace ( '#/+#' , '/' , $structure );
return $structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the month permalink structure without day and with year .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Gets the date permalink structure and strips out the day permalink
* structures . Keeps the year permalink structure .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool | string False on failure . Year / Month structure on success .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_month_permastruct () {
$structure = $this -> get_date_permastruct ( $this -> permalink_structure );
if ( empty ( $structure )) {
return false ;
}
$structure = str_replace ( '%day%' , '' , $structure );
$structure = preg_replace ( '#/+#' , '/' , $structure );
return $structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the day permalink structure with month and year .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Keeps date permalink structure with all year , month , and day .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool | string False on failure . Year / Month / Day structure on success .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_day_permastruct () {
return $this -> get_date_permastruct ( $this -> permalink_structure );
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the permalink structure for categories .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* If the category_base property has no value , then the category structure
* will have the front property value , followed by 'category' , and finally
* '%category%' . If it does , then the root property will be used , along with
* the category_base property value .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool | string False on failure . Category permalink structure .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_category_permastruct () {
if ( isset ( $this -> category_structure )) {
return $this -> category_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> category_structure = '' ;
return false ;
}
if ( empty ( $this -> category_base ))
2008-08-11 20:17:07 +00:00
$this -> category_structure = trailingslashit ( $this -> front . 'category' );
else
$this -> category_structure = trailingslashit ( '/' . $this -> root . $this -> category_base );
2006-03-12 22:57:00 +00:00
$this -> category_structure .= '%category%' ;
return $this -> category_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the permalink structure for tags .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* If the tag_base property has no value , then the tag structure will have
* the front property value , followed by 'tag' , and finally '%tag%' . If it
* does , then the root property will be used , along with the tag_base
* property value .
2008-09-01 05:47:08 +00:00
*
* @ since 2.3 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return bool | string False on failure . Tag permalink structure .
2008-09-01 05:47:08 +00:00
*/
2007-03-31 09:19:32 +00:00
function get_tag_permastruct () {
if ( isset ( $this -> tag_structure )) {
return $this -> tag_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> tag_structure = '' ;
return false ;
}
if ( empty ( $this -> tag_base ))
2008-08-11 20:17:07 +00:00
$this -> tag_structure = trailingslashit ( $this -> front . 'tag' );
else
$this -> tag_structure = trailingslashit ( '/' . $this -> root . $this -> tag_base );
2007-03-31 09:19:32 +00:00
$this -> tag_structure .= '%tag%' ;
return $this -> tag_structure ;
}
2008-09-16 00:35:56 +00:00
/**
* Retrieve extra permalink structure by name .
*
* @ since unknown
* @ access public
*
* @ param string $name Permalink structure name .
* @ return string | bool False if not found . Permalink structure string .
*/
2008-03-26 06:37:19 +00:00
function get_extra_permastruct ( $name ) {
2009-11-19 22:47:11 +00:00
if ( empty ( $this -> permalink_structure ) )
return false ;
2008-03-26 06:37:19 +00:00
if ( isset ( $this -> extra_permastructs [ $name ]) )
return $this -> extra_permastructs [ $name ];
return false ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the author permalink structure .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The permalink structure is front property , author base , and finally
* '/%author%' . Will set the author_structure property and then return it
* without attempting to set the value again .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return string | bool False if not found . Permalink structure string .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_author_permastruct () {
if ( isset ( $this -> author_structure )) {
return $this -> author_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> author_structure = '' ;
return false ;
}
$this -> author_structure = $this -> front . $this -> author_base . '/%author%' ;
return $this -> author_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the search permalink structure .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The permalink structure is root property , search base , and finally
* '/%search%' . Will set the search_structure property and then return it
* without attempting to set the value again .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return string | bool False if not found . Permalink structure string .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_search_permastruct () {
if ( isset ( $this -> search_structure )) {
return $this -> search_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> search_structure = '' ;
return false ;
}
$this -> search_structure = $this -> root . $this -> search_base . '/%search%' ;
return $this -> search_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the page permalink structure .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The permalink structure is root property , and '%pagename%' . Will set the
* page_structure property and then return it without attempting to set the
* value again .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return string | bool False if not found . Permalink structure string .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_page_permastruct () {
if ( isset ( $this -> page_structure )) {
return $this -> page_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> page_structure = '' ;
return false ;
}
$this -> page_structure = $this -> root . '%pagename%' ;
return $this -> page_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the feed permalink structure .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The permalink structure is root property , feed base , and finally
* '/%feed%' . Will set the feed_structure property and then return it
* without attempting to set the value again .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return string | bool False if not found . Permalink structure string .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_feed_permastruct () {
if ( isset ( $this -> feed_structure )) {
return $this -> feed_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> feed_structure = '' ;
return false ;
}
$this -> feed_structure = $this -> root . $this -> feed_base . '/%feed%' ;
return $this -> feed_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Retrieve the comment feed permalink structure .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* The permalink structure is root property , comment base property , feed
* base and finally '/%feed%' . Will set the comment_feed_structure property
* and then return it without attempting to set the value again .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ return string | bool False if not found . Permalink structure string .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function get_comment_feed_permastruct () {
if ( isset ( $this -> comment_feed_structure )) {
return $this -> comment_feed_structure ;
}
if ( empty ( $this -> permalink_structure )) {
$this -> comment_feed_structure = '' ;
return false ;
}
$this -> comment_feed_structure = $this -> root . $this -> comments_base . '/' . $this -> feed_base . '/%feed%' ;
return $this -> comment_feed_structure ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Append or update tag , pattern , and query for replacement .
*
* If the tag already exists , replace the existing pattern and query for
* that tag , otherwise add the new tag , pattern , and query to the end of the
* arrays .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* @ internal What is the purpose of this function again ? Need to finish long
* description .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $tag Append tag to rewritecode property array .
* @ param string $pattern Append pattern to rewritereplace property array .
* @ param string $query Append query to queryreplace property array .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function add_rewrite_tag ( $tag , $pattern , $query ) {
$position = array_search ( $tag , $this -> rewritecode );
2008-09-18 06:14:01 +00:00
if ( false !== $position && null !== $position ) {
2006-03-12 22:57:00 +00:00
$this -> rewritereplace [ $position ] = $pattern ;
$this -> queryreplace [ $position ] = $query ;
} else {
$this -> rewritecode [] = $tag ;
$this -> rewritereplace [] = $pattern ;
$this -> queryreplace [] = $query ;
}
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Generate the rules from permalink structure .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* The main WP_Rewrite function for building the rewrite rule list . The
* contents of the function is a mix of black magic and regular expressions ,
* so best just ignore the contents and move to the parameters .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $permalink_structure The permalink structure .
* @ param int $ep_mask Optional , default is EP_NONE . Endpoint constant , see EP_ * constants .
* @ param bool $paged Optional , default is true . Whether permalink request is paged .
* @ param bool $feed Optional , default is true . Whether for feed .
* @ param bool $forcomments Optional , default is false . Whether for comments .
* @ param bool $walk_dirs Optional , default is true . Whether to create list of directories to walk over .
* @ param bool $endpoints Optional , default is true . Whether endpoints are enabled .
* @ return array Rewrite rule list .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function generate_rewrite_rules ( $permalink_structure , $ep_mask = EP_NONE , $paged = true , $feed = true , $forcomments = false , $walk_dirs = true , $endpoints = true ) {
//build a regex to match the feed section of URLs, something like (feed|atom|rss|rss2)/?
$feedregex2 = '' ;
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $this -> feeds as $feed_name ) {
2006-03-12 22:57:00 +00:00
$feedregex2 .= $feed_name . '|' ;
}
$feedregex2 = '(' . trim ( $feedregex2 , '|' ) . ')/?$' ;
//$feedregex is identical but with /feed/ added on as well, so URLs like <permalink>/feed/atom
//and <permalink>/atom are both possible
$feedregex = $this -> feed_base . '/' . $feedregex2 ;
//build a regex to match the trackback and page/xx parts of URLs
$trackbackregex = 'trackback/?$' ;
$pageregex = 'page/?([0-9]{1,})/?$' ;
2008-10-23 18:55:22 +00:00
$commentregex = 'comment-page-([0-9]{1,})/?$' ;
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//build up an array of endpoint regexes to append => queries to append
if ( $endpoints ) {
$ep_query_append = array ();
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $this -> endpoints as $endpoint ) {
2006-03-12 22:57:00 +00:00
//match everything after the endpoint name, but allow for nothing to appear there
$epmatch = $endpoint [ 1 ] . '(/(.*))?/?$' ;
//this will be appended on to the rest of the query for each dir
$epquery = '&' . $endpoint [ 1 ] . '=' ;
$ep_query_append [ $epmatch ] = array ( $endpoint [ 0 ], $epquery );
}
}
//get everything up to the first rewrite tag
$front = substr ( $permalink_structure , 0 , strpos ( $permalink_structure , '%' ));
//build an array of the tags (note that said array ends up being in $tokens[0])
preg_match_all ( '/%.+?%/' , $permalink_structure , $tokens );
$num_tokens = count ( $tokens [ 0 ]);
$index = $this -> index ; //probably 'index.php'
$feedindex = $index ;
$trackbackindex = $index ;
//build a list from the rewritecode and queryreplace arrays, that will look something like
//tagname=$matches[i] where i is the current $i
for ( $i = 0 ; $i < $num_tokens ; ++ $i ) {
if ( 0 < $i ) {
$queries [ $i ] = $queries [ $i - 1 ] . '&' ;
2008-01-10 20:51:07 +00:00
} else {
$queries [ $i ] = '' ;
2006-03-12 22:57:00 +00:00
}
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
$query_token = str_replace ( $this -> rewritecode , $this -> queryreplace , $tokens [ 0 ][ $i ]) . $this -> preg_index ( $i + 1 );
$queries [ $i ] .= $query_token ;
}
//get the structure, minus any cruft (stuff that isn't tags) at the front
$structure = $permalink_structure ;
if ( $front != '/' ) {
$structure = str_replace ( $front , '' , $structure );
}
//create a list of dirs to walk over, making rewrite rules for each level
//so for example, a $structure of /%year%/%month%/%postname% would create
//rewrite rules for /%year%/, /%year%/%month%/ and /%year%/%month%/%postname%
$structure = trim ( $structure , '/' );
if ( $walk_dirs ) {
$dirs = explode ( '/' , $structure );
} else {
$dirs [] = $structure ;
}
$num_dirs = count ( $dirs );
//strip slashes from the front of $front
$front = preg_replace ( '|^/+|' , '' , $front );
//the main workhorse loop
$post_rewrite = array ();
$struct = $front ;
for ( $j = 0 ; $j < $num_dirs ; ++ $j ) {
//get the struct for this dir, and trim slashes off the front
$struct .= $dirs [ $j ] . '/' ; //accumulate. see comment near explode('/', $structure) above
$struct = ltrim ( $struct , '/' );
//replace tags with regexes
$match = str_replace ( $this -> rewritecode , $this -> rewritereplace , $struct );
//make a list of tags, and store how many there are in $num_toks
$num_toks = preg_match_all ( '/%.+?%/' , $struct , $toks );
//get the 'tagname=$matches[i]'
2008-01-10 20:51:07 +00:00
$query = ( isset ( $queries ) && is_array ( $queries ) ) ? $queries [ $num_toks - 1 ] : '' ;
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//set up $ep_mask_specific which is used to match more specific URL types
switch ( $dirs [ $j ]) {
case '%year%' : $ep_mask_specific = EP_YEAR ; break ;
case '%monthnum%' : $ep_mask_specific = EP_MONTH ; break ;
case '%day%' : $ep_mask_specific = EP_DAY ; break ;
}
//create query for /page/xx
$pagematch = $match . $pageregex ;
$pagequery = $index . '?' . $query . '&paged=' . $this -> preg_index ( $num_toks + 1 );
2008-10-23 18:55:22 +00:00
//create query for /comment-page-xx
$commentmatch = $match . $commentregex ;
$commentquery = $index . '?' . $query . '&cpage=' . $this -> preg_index ( $num_toks + 1 );
2009-05-20 22:24:37 +00:00
if ( get_option ( 'page_on_front' ) ) {
//create query for Root /comment-page-xx
$rootcommentmatch = $match . $commentregex ;
$rootcommentquery = $index . '?' . $query . '&page_id=' . get_option ( 'page_on_front' ) . '&cpage=' . $this -> preg_index ( $num_toks + 1 );
}
2006-03-12 22:57:00 +00:00
//create query for /feed/(feed|atom|rss|rss2|rdf)
$feedmatch = $match . $feedregex ;
$feedquery = $feedindex . '?' . $query . '&feed=' . $this -> preg_index ( $num_toks + 1 );
//create query for /(feed|atom|rss|rss2|rdf) (see comment near creation of $feedregex)
$feedmatch2 = $match . $feedregex2 ;
$feedquery2 = $feedindex . '?' . $query . '&feed=' . $this -> preg_index ( $num_toks + 1 );
//if asked to, turn the feed queries into comment feed ones
if ( $forcomments ) {
$feedquery .= '&withcomments=1' ;
$feedquery2 .= '&withcomments=1' ;
}
//start creating the array of rewrites for this dir
$rewrite = array ();
if ( $feed ) //...adding on /feed/ regexes => queries
$rewrite = array ( $feedmatch => $feedquery , $feedmatch2 => $feedquery2 );
if ( $paged ) //...and /page/xx ones
$rewrite = array_merge ( $rewrite , array ( $pagematch => $pagequery ));
2006-11-19 07:56:05 +00:00
2008-10-23 18:55:22 +00:00
//only on pages with comments add ../comment-page-xx/
if ( EP_PAGES & $ep_mask || EP_PERMALINK & $ep_mask || EP_NONE & $ep_mask )
$rewrite = array_merge ( $rewrite , array ( $commentmatch => $commentquery ));
2009-05-20 22:24:37 +00:00
else if ( EP_ROOT & $ep_mask && get_option ( 'page_on_front' ) )
$rewrite = array_merge ( $rewrite , array ( $rootcommentmatch => $rootcommentquery ));
2008-10-23 18:55:22 +00:00
2007-03-29 00:17:40 +00:00
//do endpoints
if ( $endpoints ) {
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $ep_query_append as $regex => $ep ) {
2007-03-29 00:17:40 +00:00
//add the endpoints on if the mask fits
if ( $ep [ 0 ] & $ep_mask || $ep [ 0 ] & $ep_mask_specific ) {
$rewrite [ $match . $regex ] = $index . '?' . $query . $ep [ 1 ] . $this -> preg_index ( $num_toks + 2 );
}
}
}
2006-03-12 22:57:00 +00:00
//if we've got some tags in this dir
if ( $num_toks ) {
$post = false ;
$page = false ;
2006-11-19 07:56:05 +00:00
//check to see if this dir is permalink-level: i.e. the structure specifies an
2006-03-12 22:57:00 +00:00
//individual post. Do this by checking it contains at least one of 1) post name,
2006-11-19 07:56:05 +00:00
//2) post ID, 3) page name, 4) timestamp (year, month, day, hour, second and
2006-03-12 22:57:00 +00:00
//minute all present). Set these flags now as we need them for the endpoints.
2007-03-07 05:29:15 +00:00
if ( strpos ( $struct , '%postname%' ) !== false || strpos ( $struct , '%post_id%' ) !== false
|| strpos ( $struct , '%pagename%' ) !== false
|| ( strpos ( $struct , '%year%' ) !== false && strpos ( $struct , '%monthnum%' ) !== false && strpos ( $struct , '%day%' ) !== false && strpos ( $struct , '%hour%' ) !== false && strpos ( $struct , '%minute%' ) !== false && strpos ( $struct , '%second%' ) !== false )) {
2006-03-12 22:57:00 +00:00
$post = true ;
2007-03-07 05:29:15 +00:00
if ( strpos ( $struct , '%pagename%' ) !== false )
2006-03-12 22:57:00 +00:00
$page = true ;
}
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//if we're creating rules for a permalink, do all the endpoints like attachments etc
if ( $post ) {
$post = true ;
//create query and regex for trackback
$trackbackmatch = $match . $trackbackregex ;
$trackbackquery = $trackbackindex . '?' . $query . '&tb=1' ;
//trim slashes from the end of the regex for this dir
$match = rtrim ( $match , '/' );
//get rid of brackets
$submatchbase = str_replace ( array ( '(' , ')' ), '' , $match );
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//add a rule for at attachments, which take the form of <permalink>/some-text
$sub1 = $submatchbase . '/([^/]+)/' ;
$sub1tb = $sub1 . $trackbackregex ; //add trackback regex <permalink>/trackback/...
$sub1feed = $sub1 . $feedregex ; //and <permalink>/feed/(atom|...)
$sub1feed2 = $sub1 . $feedregex2 ; //and <permalink>/(feed|atom...)
2008-10-23 18:55:22 +00:00
$sub1comment = $sub1 . $commentregex ; //and <permalink>/comment-page-xx
2006-03-12 22:57:00 +00:00
//add an ? as we don't have to match that last slash, and finally a $ so we
//match to the end of the URL
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//add another rule to match attachments in the explicit form:
//<permalink>/attachment/some-text
$sub2 = $submatchbase . '/attachment/([^/]+)/' ;
$sub2tb = $sub2 . $trackbackregex ; //and add trackbacks <permalink>/attachment/trackback
$sub2feed = $sub2 . $feedregex ; //feeds, <permalink>/attachment/feed/(atom|...)
$sub2feed2 = $sub2 . $feedregex2 ; //and feeds again on to this <permalink>/attachment/(feed|atom...)
2008-10-23 18:55:22 +00:00
$sub2comment = $sub2 . $commentregex ; //and <permalink>/comment-page-xx
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//create queries for these extra tag-ons we've just dealt with
$subquery = $index . '?attachment=' . $this -> preg_index ( 1 );
$subtbquery = $subquery . '&tb=1' ;
$subfeedquery = $subquery . '&feed=' . $this -> preg_index ( 2 );
2008-10-23 18:55:22 +00:00
$subcommentquery = $subquery . '&cpage=' . $this -> preg_index ( 2 );
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//do endpoints for attachments
2009-11-24 16:08:13 +00:00
if ( ! empty ( $endpoints ) ) { foreach ( ( array ) $ep_query_append as $regex => $ep ) {
2006-03-12 22:57:00 +00:00
if ( $ep [ 0 ] & EP_ATTACHMENT ) {
2009-11-24 16:08:13 +00:00
$rewrite [ $sub1 . $regex ] = $subquery . $ep [ 1 ] . $this -> preg_index ( 2 );
$rewrite [ $sub2 . $regex ] = $subquery . $ep [ 1 ] . $this -> preg_index ( 2 );
2006-03-12 22:57:00 +00:00
}
} }
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//now we've finished with endpoints, finish off the $sub1 and $sub2 matches
$sub1 .= '?$' ;
$sub2 .= '?$' ;
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//allow URLs like <permalink>/2 for <permalink>/page/2
$match = $match . '(/[0-9]+)?/?$' ;
$query = $index . '?' . $query . '&page=' . $this -> preg_index ( $num_toks + 1 );
} else { //not matching a permalink so this is a lot simpler
//close the match and finalise the query
$match .= '?$' ;
$query = $index . '?' . $query ;
}
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//create the final array for this dir by joining the $rewrite array (which currently
//only contains rules/queries for trackback, pages etc) to the main regex/query for
//this dir
$rewrite = array_merge ( $rewrite , array ( $match => $query ));
//if we're matching a permalink, add those extras (attachments etc) on
if ( $post ) {
//add trackback
$rewrite = array_merge ( array ( $trackbackmatch => $trackbackquery ), $rewrite );
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//add regexes/queries for attachments, attachment trackbacks and so on
if ( ! $page ) //require <permalink>/attachment/stuff form for pages because of confusion with subpages
2008-10-23 18:55:22 +00:00
$rewrite = array_merge ( $rewrite , array ( $sub1 => $subquery , $sub1tb => $subtbquery , $sub1feed => $subfeedquery , $sub1feed2 => $subfeedquery , $sub1comment => $subcommentquery ));
$rewrite = array_merge ( array ( $sub2 => $subquery , $sub2tb => $subtbquery , $sub2feed => $subfeedquery , $sub2feed2 => $subfeedquery , $sub2comment => $subcommentquery ), $rewrite );
2006-03-12 22:57:00 +00:00
}
} //if($num_toks)
//add the rules for this dir to the accumulating $post_rewrite
$post_rewrite = array_merge ( $rewrite , $post_rewrite );
} //foreach ($dir)
return $post_rewrite ; //the finished rules. phew!
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Generate Rewrite rules with permalink structure and walking directory only .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* Shorten version of { @ link WP_Rewrite :: generate_rewrite_rules ()} that
* allows for shorter list of parameters . See the method for longer
* description of what generating rewrite rules does .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* @ uses WP_Rewrite :: generate_rewrite_rules () See for long description and rest of parameters .
2008-09-01 05:47:08 +00:00
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $permalink_structure The permalink structure to generate rules .
* @ param bool $walk_dirs Optional , default is false . Whether to create list of directories to walk over .
* @ return array
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function generate_rewrite_rule ( $permalink_structure , $walk_dirs = false ) {
return $this -> generate_rewrite_rules ( $permalink_structure , EP_NONE , false , false , false , $walk_dirs );
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Construct rewrite matches and queries from permalink structure .
*
* Runs the action 'generate_rewrite_rules' with the parameter that is an
* reference to the current WP_Rewrite instance to further manipulate the
* permalink structures and rewrite rules . Runs the 'rewrite_rules_array'
* filter on the full rewrite rule array .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* There are two ways to manipulate the rewrite rules , one by hooking into
* the 'generate_rewrite_rules' action and gaining full control of the
* object or just manipulating the rewrite rule array before it is passed
* from the function .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ return array An associate array of matches and queries .
2006-03-12 22:57:00 +00:00
*/
function rewrite_rules () {
$rewrite = array ();
if ( empty ( $this -> permalink_structure )) {
return $rewrite ;
}
2006-05-22 22:06:06 +00:00
// robots.txt
2008-11-12 23:04:43 +00:00
$robots_rewrite = array ( 'robots\.txt$' => $this -> index . '?robots=1' );
2006-05-22 22:06:06 +00:00
2006-11-30 01:54:05 +00:00
//Default Feed rules - These are require to allow for the direct access files to work with permalink structure starting with %category%
2008-04-28 06:17:01 +00:00
$default_feeds = array ( '.*wp-atom.php$' => $this -> index . '?feed=atom' ,
'.*wp-rdf.php$' => $this -> index . '?feed=rdf' ,
'.*wp-rss.php$' => $this -> index . '?feed=rss' ,
'.*wp-rss2.php$' => $this -> index . '?feed=rss2' ,
'.*wp-feed.php$' => $this -> index . '?feed=feed' ,
'.*wp-commentsrss2.php$' => $this -> index . '?feed=rss2&withcomments=1' );
2006-11-30 01:54:05 +00:00
2006-03-12 22:57:00 +00:00
// Post
$post_rewrite = $this -> generate_rewrite_rules ( $this -> permalink_structure , EP_PERMALINK );
$post_rewrite = apply_filters ( 'post_rewrite_rules' , $post_rewrite );
// Date
$date_rewrite = $this -> generate_rewrite_rules ( $this -> get_date_permastruct (), EP_DATE );
$date_rewrite = apply_filters ( 'date_rewrite_rules' , $date_rewrite );
// Root
$root_rewrite = $this -> generate_rewrite_rules ( $this -> root . '/' , EP_ROOT );
$root_rewrite = apply_filters ( 'root_rewrite_rules' , $root_rewrite );
// Comments
$comments_rewrite = $this -> generate_rewrite_rules ( $this -> root . $this -> comments_base , EP_COMMENTS , true , true , true , false );
$comments_rewrite = apply_filters ( 'comments_rewrite_rules' , $comments_rewrite );
// Search
$search_structure = $this -> get_search_permastruct ();
$search_rewrite = $this -> generate_rewrite_rules ( $search_structure , EP_SEARCH );
$search_rewrite = apply_filters ( 'search_rewrite_rules' , $search_rewrite );
// Categories
$category_rewrite = $this -> generate_rewrite_rules ( $this -> get_category_permastruct (), EP_CATEGORIES );
$category_rewrite = apply_filters ( 'category_rewrite_rules' , $category_rewrite );
2007-03-31 09:19:32 +00:00
// Tags
$tag_rewrite = $this -> generate_rewrite_rules ( $this -> get_tag_permastruct (), EP_TAGS );
$tag_rewrite = apply_filters ( 'tag_rewrite_rules' , $tag_rewrite );
2006-03-12 22:57:00 +00:00
// Authors
$author_rewrite = $this -> generate_rewrite_rules ( $this -> get_author_permastruct (), EP_AUTHORS );
$author_rewrite = apply_filters ( 'author_rewrite_rules' , $author_rewrite );
// Pages
$page_rewrite = $this -> page_rewrite_rules ();
$page_rewrite = apply_filters ( 'page_rewrite_rules' , $page_rewrite );
2008-03-23 17:02:11 +00:00
// Extra permastructs
foreach ( $this -> extra_permastructs as $permastruct )
2008-03-26 06:37:19 +00:00
$this -> extra_rules_top = array_merge ( $this -> extra_rules_top , $this -> generate_rewrite_rules ( $permastruct , EP_NONE ));
2008-03-23 17:02:11 +00:00
2006-03-12 22:57:00 +00:00
// Put them together.
2007-12-04 00:19:10 +00:00
if ( $this -> use_verbose_page_rules )
2008-03-26 06:37:19 +00:00
$this -> rules = array_merge ( $this -> extra_rules_top , $robots_rewrite , $default_feeds , $page_rewrite , $root_rewrite , $comments_rewrite , $search_rewrite , $category_rewrite , $tag_rewrite , $author_rewrite , $date_rewrite , $post_rewrite , $this -> extra_rules );
2007-12-04 00:19:10 +00:00
else
2008-03-26 06:37:19 +00:00
$this -> rules = array_merge ( $this -> extra_rules_top , $robots_rewrite , $default_feeds , $root_rewrite , $comments_rewrite , $search_rewrite , $category_rewrite , $tag_rewrite , $author_rewrite , $date_rewrite , $post_rewrite , $page_rewrite , $this -> extra_rules );
2006-03-12 22:57:00 +00:00
2006-09-12 17:45:23 +00:00
do_action_ref_array ( 'generate_rewrite_rules' , array ( & $this ));
2006-03-12 22:57:00 +00:00
$this -> rules = apply_filters ( 'rewrite_rules_array' , $this -> rules );
return $this -> rules ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Retrieve the rewrite rules .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* The difference between this method and { @ link
* WP_Rewrite :: rewrite_rules ()} is that this method stores the rewrite rules
* in the 'rewrite_rules' option and retrieves it . This prevents having to
* process all of the permalinks to get the rewrite rules in the form of
* caching .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ return array Rewrite rules .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function wp_rewrite_rules () {
2009-10-19 21:10:46 +00:00
$this -> rules = get_option ( 'rewrite_rules' );
2006-03-12 22:57:00 +00:00
if ( empty ( $this -> rules ) ) {
$this -> matches = 'matches' ;
$this -> rewrite_rules ();
2009-10-19 21:10:46 +00:00
update_option ( 'rewrite_rules' , $this -> rules );
2006-03-12 22:57:00 +00:00
}
return $this -> rules ;
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Retrieve mod_rewrite formatted rewrite rules to write to . htaccess .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* Does not actually write to the . htaccess file , but creates the rules for
* the process that will .
*
* Will add the non_wp_rules property rules to the . htaccess file before
* the WordPress rewrite rules one .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ return string
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function mod_rewrite_rules () {
if ( ! $this -> using_permalinks ()) {
return '' ;
}
2006-08-30 21:46:31 +00:00
$site_root = parse_url ( get_option ( 'siteurl' ));
2008-11-04 03:22:24 +00:00
if ( isset ( $site_root [ 'path' ] ) ) {
$site_root = trailingslashit ( $site_root [ 'path' ]);
}
2006-03-12 22:57:00 +00:00
2010-01-04 17:23:29 +00:00
$home_root = parse_url ( home_url ());
2008-11-04 03:22:24 +00:00
if ( isset ( $home_root [ 'path' ] ) ) {
$home_root = trailingslashit ( $home_root [ 'path' ]);
2008-11-04 21:58:30 +00:00
} else {
$home_root = '/' ;
2008-11-04 03:22:24 +00:00
}
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
$rules = " <IfModule mod_rewrite.c> \n " ;
$rules .= " RewriteEngine On \n " ;
$rules .= " RewriteBase $home_root\n " ;
2006-11-19 07:56:05 +00:00
2006-03-12 22:57:00 +00:00
//add in the rules that don't redirect to WP's index.php (and thus shouldn't be handled by WP at all)
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $this -> non_wp_rules as $match => $query ) {
2006-03-12 22:57:00 +00:00
// Apache 1.3 does not support the reluctant (non-greedy) modifier.
$match = str_replace ( '.+?' , '.+' , $match );
// If the match is unanchored and greedy, prepend rewrite conditions
// to avoid infinite redirects and eclipsing of real files.
if ( $match == '(.+)/?$' || $match == '([^/]+)/?$' ) {
//nada.
}
$rules .= 'RewriteRule ^' . $match . ' ' . $home_root . $query . " [QSA,L] \n " ;
}
if ( $this -> use_verbose_rules ) {
$this -> matches = '' ;
$rewrite = $this -> rewrite_rules ();
$num_rules = count ( $rewrite );
$rules .= " RewriteCond % { REQUEST_FILENAME} -f [OR] \n " .
" RewriteCond % { REQUEST_FILENAME} -d \n " .
" RewriteRule ^.* $ - [S= $num_rules ] \n " ;
2008-08-06 20:31:54 +00:00
foreach ( ( array ) $rewrite as $match => $query ) {
2006-03-12 22:57:00 +00:00
// Apache 1.3 does not support the reluctant (non-greedy) modifier.
$match = str_replace ( '.+?' , '.+' , $match );
// If the match is unanchored and greedy, prepend rewrite conditions
// to avoid infinite redirects and eclipsing of real files.
if ( $match == '(.+)/?$' || $match == '([^/]+)/?$' ) {
//nada.
}
2007-03-07 05:29:15 +00:00
if ( strpos ( $query , $this -> index ) !== false ) {
2006-03-12 22:57:00 +00:00
$rules .= 'RewriteRule ^' . $match . ' ' . $home_root . $query . " [QSA,L] \n " ;
} else {
$rules .= 'RewriteRule ^' . $match . ' ' . $site_root . $query . " [QSA,L] \n " ;
}
}
} else {
$rules .= " RewriteCond % { REQUEST_FILENAME} !-f \n " .
" RewriteCond % { REQUEST_FILENAME} !-d \n " .
" RewriteRule . { $home_root } { $this -> index } [L] \n " ;
}
$rules .= " </IfModule> \n " ;
$rules = apply_filters ( 'mod_rewrite_rules' , $rules );
$rules = apply_filters ( 'rewrite_rules' , $rules ); // Deprecated
return $rules ;
}
2009-05-24 23:47:49 +00:00
2009-05-16 02:04:36 +00:00
/**
* Retrieve IIS7 URL Rewrite formatted rewrite rules to write to web . config file .
*
* Does not actually write to the web . config file , but creates the rules for
* the process that will .
*
2009-05-24 23:47:49 +00:00
* @ since 2.8 . 0
2009-05-16 02:04:36 +00:00
* @ access public
*
* @ return string
*/
2009-11-23 18:17:46 +00:00
function iis7_url_rewrite_rules ( $add_parent_tags = false , $indent = " " , $end_of_line = " \n " ) {
2009-05-24 23:47:49 +00:00
2009-05-16 02:04:36 +00:00
if ( ! $this -> using_permalinks ()) {
return '' ;
}
2010-01-11 21:49:40 +00:00
2010-01-11 22:30:21 +00:00
if ( ! is_multisite () ) {
$rules = '' ;
$extra_indent = '' ;
if ( $add_parent_tags ) {
$rules .= " <configuration> " . $end_of_line ;
$rules .= $indent . " <system.webServer> " . $end_of_line ;
$rules .= $indent . $indent . " <rewrite> " . $end_of_line ;
$rules .= $indent . $indent . $indent . " <rules> " . $end_of_line ;
$extra_indent = $indent . $indent . $indent . $indent ;
}
$rules .= $extra_indent . " <rule name= \" wordpress \" patternSyntax= \" Wildcard \" > " . $end_of_line ;
$rules .= $extra_indent . $indent . " <match url= \" * \" /> " . $end_of_line ;
$rules .= $extra_indent . $indent . $indent . " <conditions> " . $end_of_line ;
$rules .= $extra_indent . $indent . $indent . $indent . " <add input= \" { REQUEST_FILENAME} \" matchType= \" IsFile \" negate= \" true \" /> " . $end_of_line ;
$rules .= $extra_indent . $indent . $indent . $indent . " <add input= \" { REQUEST_FILENAME} \" matchType= \" IsDirectory \" negate= \" true \" /> " . $end_of_line ;
$rules .= $extra_indent . $indent . $indent . " </conditions> " . $end_of_line ;
$rules .= $extra_indent . $indent . " <action type= \" Rewrite \" url= \" index.php \" /> " . $end_of_line ;
$rules .= $extra_indent . " </rule> " ;
if ( $add_parent_tags ) {
$rules .= $end_of_line . $indent . $indent . $indent . " </rules> " . $end_of_line ;
$rules .= $indent . $indent . " </rewrite> " . $end_of_line ;
$rules .= $indent . " </system.webServer> " . $end_of_line ;
$rules .= " </configuration> " ;
}
} else {
$rules = ' < rule name = " wordpress - strip index.php " stopProcessing = " false " >
< match url = " ^index.php/(.*) $ " />
< action type = " Rewrite " url = " { R:1} " />
</ rule >
< rule name = " wordpress - 1 " stopProcessing = " true " >
< match url = " ^(.*/)?files/ $ " />
< action type = " Rewrite " url = " index.php " />
</ rule >
< rule name = " wordpress - 2 " stopProcessing = " true " >
< match url = " ^(.*/)?files/(.*) " />
< conditions >
< add input = " { REQUEST_URI} " negate = " true " pattern = " .*wp-content/plugins.* " />
</ conditions >
< action type = " Rewrite " url = " wp-content/blogs.php?file= { R:2} " appendQueryString = " false " />
</ rule >
< rule name = " wordpress - 3 " stopProcessing = " true " >
< match url = " ^(.+) $ " />
< conditions >
< add input = " { REQUEST_URI} " pattern = " ^.*/wp-admin $ " />
</ conditions >
< action type = " Redirect " url = " { R:1}/ " redirectType = " Permanent " />
</ rule >
< rule name = " wordpress - 4 " stopProcessing = " true " >
< match url = " . " />
< conditions logicalGrouping = " MatchAny " >
< add input = " { REQUEST_FILENAME} " matchType = " IsFile " pattern = " " />
< add input = " { REQUEST_FILENAME} " matchType = " IsDirectory " pattern = " " />
</ conditions >
< action type = " None " />
</ rule >
< rule name = " wordpress - 5 " stopProcessing = " true " >
< match url = " ^([_0-9a-zA-Z-]+/)?(wp-.*) " />
< action type = " Rewrite " url = " { R:2} " />
</ rule >
< rule name = " wordpress - 6 " stopProcessing = " true " >
< match url = " ^([_0-9a-zA-Z-]+/)?(.* \ .php) $ " />
< action type = " Rewrite " url = " { R:2} " />
</ rule >
< rule name = " wordpress - 7 " stopProcessing = " true " >
< match url = " . " />
< action type = " Rewrite " url = " index.php " />
</ rule > ' ;
}
2009-05-24 23:47:49 +00:00
2009-05-16 02:04:36 +00:00
$rules = apply_filters ( 'iis7_url_rewrite_rules' , $rules );
2009-05-24 23:47:49 +00:00
2009-05-16 02:04:36 +00:00
return $rules ;
}
2006-11-19 07:56:05 +00:00
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Add a straight rewrite rule .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* Any value in the $after parameter that isn 't ' bottom ' will be placed at
* the top of the rules .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $regex Regular expression to match against request .
* @ param string $redirect URL regex redirects to when regex matches request .
* @ param string $after Optional , default is bottom . Location to place rule .
2008-09-01 05:47:08 +00:00
*/
2007-06-27 21:39:50 +00:00
function add_rule ( $regex , $redirect , $after = 'bottom' ) {
2006-03-12 22:57:00 +00:00
//get everything up to the first ?
$index = ( strpos ( $redirect , '?' ) == false ? strlen ( $redirect ) : strpos ( $redirect , '?' ));
$front = substr ( $redirect , 0 , $index );
if ( $front != $this -> index ) { //it doesn't redirect to WP's index.php
$this -> add_external_rule ( $regex , $redirect );
} else {
2007-06-27 21:39:50 +00:00
if ( 'bottom' == $after )
$this -> extra_rules = array_merge ( $this -> extra_rules , array ( $regex => $redirect ));
else
$this -> extra_rules_top = array_merge ( $this -> extra_rules_top , array ( $regex => $redirect ));
//$this->extra_rules[$regex] = $redirect;
2006-03-12 22:57:00 +00:00
}
}
2006-11-19 07:56:05 +00:00
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Add a rule that doesn ' t redirect to index . php .
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* Can redirect to any place .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $regex Regular expression to match against request .
* @ param string $redirect URL regex redirects to when regex matches request .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function add_external_rule ( $regex , $redirect ) {
$this -> non_wp_rules [ $regex ] = $redirect ;
}
2006-11-19 07:56:05 +00:00
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Add an endpoint , like / trackback /.
2008-09-01 05:47:08 +00:00
*
2008-09-18 06:14:01 +00:00
* To be inserted after certain URL types ( specified in $places ) .
2008-09-01 05:47:08 +00:00
*
* @ since 2.1 . 0
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $name Name of endpoint .
* @ param array $places URL types that endpoint can be used .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function add_endpoint ( $name , $places ) {
global $wp ;
$this -> endpoints [] = array ( $places , $name );
$wp -> add_query_var ( $name );
}
2008-09-16 00:35:56 +00:00
/**
2008-09-18 06:14:01 +00:00
* Add permalink structure .
2008-09-16 00:35:56 +00:00
*
2008-09-18 06:14:01 +00:00
* These are added along with the extra rewrite rules that are merged to the
* top .
2008-09-16 00:35:56 +00:00
*
* @ since unknown
* @ access public
*
2008-09-18 06:14:01 +00:00
* @ param string $name Name for permalink structure .
* @ param string $struct Permalink structure .
* @ param bool $with_front Prepend front base to permalink structure .
2008-09-16 00:35:56 +00:00
*/
2008-03-26 06:37:19 +00:00
function add_permastruct ( $name , $struct , $with_front = true ) {
2008-03-23 17:02:11 +00:00
if ( $with_front )
$struct = $this -> front . $struct ;
2008-03-26 06:37:19 +00:00
$this -> extra_permastructs [ $name ] = $struct ;
2008-03-23 17:02:11 +00:00
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Remove rewrite rules and then recreate rewrite rules .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Calls { @ link WP_Rewrite :: wp_rewrite_rules ()} after removing the
* 'rewrite_rules' option . If the function named 'save_mod_rewrite_rules'
* exists , it will be called .
2008-09-01 05:47:08 +00:00
*
* @ since 2.0 . 1
* @ access public
2009-10-19 21:10:46 +00:00
* @ param $hard bool Whether to update . htaccess ( hard flush ) or just update rewrite_rules option ( soft flush ) . Default is true ( hard ) .
2008-09-01 05:47:08 +00:00
*/
2009-06-16 02:44:28 +00:00
function flush_rules ( $hard = true ) {
2009-10-19 21:10:46 +00:00
delete_option ( 'rewrite_rules' );
2006-03-12 22:57:00 +00:00
$this -> wp_rewrite_rules ();
2009-06-16 02:44:28 +00:00
if ( $hard && function_exists ( 'save_mod_rewrite_rules' ) )
2006-03-12 22:57:00 +00:00
save_mod_rewrite_rules ();
2009-06-16 02:44:28 +00:00
if ( $hard && function_exists ( 'iis7_save_url_rewrite_rules' ) )
2009-05-16 02:04:36 +00:00
iis7_save_url_rewrite_rules ();
2006-03-12 22:57:00 +00:00
}
2008-09-01 05:47:08 +00:00
/**
2008-09-18 06:14:01 +00:00
* Sets up the object ' s properties .
2008-09-01 05:47:08 +00:00
*
2009-01-29 22:11:27 +00:00
* The 'use_verbose_page_rules' object property will be set to true if the
* permalink structure begins with one of the following : '%postname%' , '%category%' ,
2008-09-18 06:14:01 +00:00
* '%tag%' , or '%author%' .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*/
2006-03-12 22:57:00 +00:00
function init () {
$this -> extra_rules = $this -> non_wp_rules = $this -> endpoints = array ();
2006-08-30 21:46:31 +00:00
$this -> permalink_structure = get_option ( 'permalink_structure' );
2006-03-12 22:57:00 +00:00
$this -> front = substr ( $this -> permalink_structure , 0 , strpos ( $this -> permalink_structure , '%' ));
$this -> root = '' ;
if ( $this -> using_index_permalinks ()) {
$this -> root = $this -> index . '/' ;
}
2008-07-17 19:41:48 +00:00
$this -> category_base = get_option ( 'category_base' );
$this -> tag_base = get_option ( 'tag_base' );
2006-03-12 22:57:00 +00:00
unset ( $this -> category_structure );
unset ( $this -> author_structure );
unset ( $this -> date_structure );
unset ( $this -> page_structure );
unset ( $this -> search_structure );
unset ( $this -> feed_structure );
unset ( $this -> comment_feed_structure );
2007-02-15 07:07:12 +00:00
$this -> use_trailing_slashes = ( substr ( $this -> permalink_structure , - 1 , 1 ) == '/' ) ? true : false ;
2007-12-17 06:29:30 +00:00
// Enable generic rules for pages if permalink structure doesn't begin with a wildcard.
2009-05-14 21:50:20 +00:00
if ( preg_match ( " /^[^%]*%(?:postname|category|tag|author)%/ " , $this -> permalink_structure ) )
2007-12-17 06:29:30 +00:00
$this -> use_verbose_page_rules = true ;
else
$this -> use_verbose_page_rules = false ;
2006-03-12 22:57:00 +00:00
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Set the main permalink structure for the blog .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Will update the 'permalink_structure' option , if there is a difference
* between the current permalink structure and the parameter value . Calls
* { @ link WP_Rewrite :: init ()} after the option is updated .
2009-05-24 23:47:49 +00:00
*
2009-05-14 06:38:34 +00:00
* Fires the 'permalink_structure_changed' action once the init call has
* processed passing the old and new values
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ param string $permalink_structure Permalink structure .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function set_permalink_structure ( $permalink_structure ) {
if ( $permalink_structure != $this -> permalink_structure ) {
update_option ( 'permalink_structure' , $permalink_structure );
$this -> init ();
2009-05-14 06:38:34 +00:00
do_action ( 'permalink_structure_changed' , $this -> permalink_structure , $permalink_structure );
2006-03-12 22:57:00 +00:00
}
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Set the category base for the category permalink .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Will update the 'category_base' option , if there is a difference between
* the current category base and the parameter value . Calls
* { @ link WP_Rewrite :: init ()} after the option is updated .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ param string $category_base Category permalink structure base .
2008-09-01 05:47:08 +00:00
*/
2006-03-12 22:57:00 +00:00
function set_category_base ( $category_base ) {
if ( $category_base != $this -> category_base ) {
update_option ( 'category_base' , $category_base );
$this -> init ();
}
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* Set the tag base for the tag permalink .
2008-09-01 05:47:08 +00:00
*
2008-09-16 00:35:56 +00:00
* Will update the 'tag_base' option , if there is a difference between the
* current tag base and the parameter value . Calls
* { @ link WP_Rewrite :: init ()} after the option is updated .
2008-09-01 05:47:08 +00:00
*
* @ since 2.3 . 0
* @ access public
*
2008-09-16 00:35:56 +00:00
* @ param string $tag_base Tag permalink structure base .
2008-09-01 05:47:08 +00:00
*/
2007-03-31 09:19:32 +00:00
function set_tag_base ( $tag_base ) {
if ( $tag_base != $this -> tag_base ) {
update_option ( 'tag_base' , $tag_base );
$this -> init ();
}
}
2008-09-01 05:47:08 +00:00
/**
2008-09-16 00:35:56 +00:00
* PHP4 Constructor - Calls init (), which runs setup .
2008-09-01 05:47:08 +00:00
*
* @ since 1.5 . 0
* @ access public
*
* @ return WP_Rewrite
*/
2006-03-12 22:57:00 +00:00
function WP_Rewrite () {
$this -> init ();
}
}
2007-08-28 19:55:11 +00:00
?>