PLL_Links_Directory

Links model for use when the language code is added in url as a directory for example mysite.com/en/something implements the "links_model interface".

Defined (1)

The class is defined in the following location(s).

/include/links-directory.php  
  1. class PLL_Links_Directory extends PLL_Links_Permalinks { 
  2.  
  3.     /** 
  4.      * Constructor 
  5.      * 
  6.      * @since 1.2 
  7.      * 
  8.      * @param object $model PLL_Model instance 
  9.      */ 
  10.     public function __construct( &$model ) { 
  11.         parent::__construct( $model ); 
  12.  
  13.         if ( did_action( 'pll_init' ) ) { 
  14.             $this->init(); 
  15.         } else { 
  16.             add_action( 'pll_init', array( $this, 'init' ) ); 
  17.         } 
  18.     } 
  19.  
  20.     /** 
  21.      * Called only at first object creation to avoid duplicating filters when switching blog 
  22.      * 
  23.      * @since 1.6 
  24.      */ 
  25.     public function init() { 
  26.         if ( did_action( 'setup_theme' ) ) { 
  27.             $this->add_permastruct(); 
  28.         } else { 
  29.             add_action( 'setup_theme', array( $this, 'add_permastruct' ), 2 ); 
  30.         } 
  31.  
  32.         // Make sure to prepare rewrite rules when flushing 
  33.         add_action( 'pre_option_rewrite_rules', array( $this, 'prepare_rewrite_rules' ) ); 
  34.     } 
  35.  
  36.     /** 
  37.      * Adds the language code in url 
  38.      * links_model interface 
  39.      * 
  40.      * @since 1.2 
  41.      * 
  42.      * @param string $url  url to modify 
  43.      * @param object $lang language 
  44.      * @return string modified url 
  45.      */ 
  46.     public function add_language_to_link( $url, $lang ) { 
  47.         if ( ! empty( $lang ) ) { 
  48.             $base = $this->options['rewrite'] ? '' : 'language/'; 
  49.             $slug = $this->options['default_lang'] == $lang->slug && $this->options['hide_default'] ? '' : $base . $lang->slug . '/'; 
  50.             if ( false === strpos( $url, $this->home . '/' . $this->root . $slug ) ) { 
  51.                 return str_replace( $this->home . '/' . $this->root, $this->home . '/' . $this->root . $slug, $url ); 
  52.             } 
  53.         } 
  54.         return $url; 
  55.     } 
  56.  
  57.     /** 
  58.      * Returns the url without language code 
  59.      * links_model interface 
  60.      * 
  61.      * @since 1.2 
  62.      * 
  63.      * @param string $url url to modify 
  64.      * @return string modified url 
  65.      */ 
  66.     function remove_language_from_link( $url ) { 
  67.         foreach ( $this->model->get_languages_list() as $language ) { 
  68.             if ( ! $this->options['hide_default'] || $this->options['default_lang'] != $language->slug ) { 
  69.                 $languages[] = $language->slug; 
  70.             } 
  71.         } 
  72.  
  73.         if ( ! empty( $languages ) ) { 
  74.             $pattern = str_replace( '/', '\/', $this->home . '/' . $this->root ); 
  75.             $pattern = '#' . $pattern . ( $this->options['rewrite'] ? '' : 'language\/' ) . '('.implode( '|', $languages ).')(\/|$)#'; 
  76.             $url = preg_replace( $pattern, $this->home . '/' . $this->root, $url ); 
  77.         } 
  78.         return $url; 
  79.     } 
  80.  
  81.     /** 
  82.      * Returns the language based on language code in url 
  83.      * links_model interface 
  84.      * 
  85.      * @since 1.2 
  86.      * @since 2.0 add $url argument 
  87.      * 
  88.      * @param string $url optional, defaults to current url 
  89.      * @return string language slug 
  90.      */ 
  91.     public function get_language_from_url( $url = '' ) { 
  92.         if ( empty( $url ) ) { 
  93.             $path = $_SERVER['REQUEST_URI']; 
  94.         } else { 
  95.             $path = parse_url( $url, PHP_URL_PATH ); 
  96.         } 
  97.  
  98.         $pattern = parse_url( $this->home . '/' . $this->root . ( $this->options['rewrite'] ? '' : 'language/' ), PHP_URL_PATH ); 
  99.         $pattern = str_replace( '/', '\/', $pattern ); 
  100.         $pattern = '#' . $pattern . '('. implode( '|', $this->model->get_languages_list( array( 'fields' => 'slug' ) ) ) . ')(\/|$)#'; 
  101.         return preg_match( $pattern, trailingslashit( $path ), $matches ) ? $matches[1] : ''; // $matches[1] is the slug of the requested language 
  102.     } 
  103.  
  104.     /** 
  105.      * Returns the home url 
  106.      * links_model interface 
  107.      * 
  108.      * @since 1.3.1 
  109.      * 
  110.      * @param object $lang PLL_Language object 
  111.      * @return string 
  112.      */ 
  113.     public function home_url( $lang ) { 
  114.         $base = $this->options['rewrite'] ? '' : 'language/'; 
  115.         $slug = $this->options['default_lang'] == $lang->slug && $this->options['hide_default'] ? '' : '/' . $this->root . $base . $lang->slug; 
  116.         return trailingslashit( $this->home . $slug ); 
  117.     } 
  118.  
  119.     /** 
  120.      * Optionaly removes 'language' in permalinks so that we get http://www.myblog/en/ instead of http://www.myblog/language/en/ 
  121.      * 
  122.      * @since 1.2 
  123.      */ 
  124.     function add_permastruct() { 
  125.         // Language information always in front of the uri ( 'with_front' => false ) 
  126.         // The 3rd parameter structure has been modified in WP 3.4 
  127.         // Leads to error 404 for pages when there is no language created yet 
  128.         if ( $this->model->get_languages_list() ) { 
  129.             add_permastruct( 'language', $this->options['rewrite'] ? '%language%' : 'language/%language%', array( 'with_front' => false ) ); 
  130.         } 
  131.     } 
  132.  
  133.     /** 
  134.      * Prepares rewrite rules filters 
  135.      * 
  136.      * @since 0.8.1 
  137.      * 
  138.      * @param array $pre not used 
  139.      * @return unmodified $pre 
  140.      */ 
  141.     public function prepare_rewrite_rules( $pre ) { 
  142.         // Don't modify the rules if there is no languages created yet 
  143.         // Make sure to add filter only once and if all custom post types and taxonomies have been registered 
  144.         if ( $this->model->get_languages_list() && did_action( 'wp_loaded' ) && ! has_filter( 'language_rewrite_rules', '__return_empty_array' ) ) { 
  145.             // Suppress the rules created by WordPress for our taxonomy 
  146.             add_filter( 'language_rewrite_rules', '__return_empty_array' ); 
  147.  
  148.             foreach ( $this->get_rewrite_rules_filters() as $type ) { 
  149.                 add_filter( $type . '_rewrite_rules', array( $this, 'rewrite_rules' ) ); 
  150.             } 
  151.  
  152.             add_filter( 'rewrite_rules_array', array( $this, 'rewrite_rules' ) ); // needed for post type archives 
  153.         } 
  154.         return $pre; 
  155.     } 
  156.  
  157.     /** 
  158.      * The rewrite rules ! 
  159.      * always make sure the default language is at the end in case the language information is hidden for default language 
  160.      * thanks to brbrbr http://wordpress.org/support/topic/plugin-polylang-rewrite-rules-not-correct 
  161.      * 
  162.      * @since 0.8.1 
  163.      * 
  164.      * @param array $rules rewrite rules 
  165.      * @return array modified rewrite rules 
  166.      */ 
  167.     public function rewrite_rules( $rules ) { 
  168.         $filter = str_replace( '_rewrite_rules', '', current_filter() ); 
  169.  
  170.         global $wp_rewrite; 
  171.         $newrules = array(); 
  172.  
  173.         $languages = $this->model->get_languages_list( array( 'fields' => 'slug' ) ); 
  174.         if ( $this->options['hide_default'] ) { 
  175.             $languages = array_diff( $languages, array( $this->options['default_lang'] ) ); 
  176.         } 
  177.  
  178.         if ( ! empty( $languages ) ) { 
  179.             $slug = $wp_rewrite->root . ( $this->options['rewrite'] ? '' : 'language/' ) . '(' . implode( '|', $languages ) . ')/'; 
  180.         } 
  181.  
  182.         // For custom post type archives 
  183.         $cpts = array_intersect( $this->model->get_translated_post_types(), get_post_types( array( '_builtin' => false ) ) ); 
  184.         $cpts = $cpts ? '#post_type=(' . implode( '|', $cpts ) . ')#' : ''; 
  185.  
  186.         foreach ( $rules as $key => $rule ) { 
  187.             // Special case for translated post types and taxonomies to allow canonical redirection 
  188.             if ( $this->options['force_lang'] && in_array( $filter, array_merge( $this->model->get_translated_post_types(), $this->model->get_translated_taxonomies() ) ) ) { 
  189.  
  190.                 /** 
  191.                  * Filters the rewrite rules to modify 
  192.                  * 
  193.                  * @since 1.9.1 
  194.                  * 
  195.                  * @param bool        $modify  whether to modify or not the rule, defaults to true 
  196.                  * @param array       $rule    original rewrite rule 
  197.                  * @param string      $filter  current set of rules being modified 
  198.                  * @param string|bool $archive custom post post type archive name or false if it is not a cpt archive 
  199.                  */ 
  200.                 if (  isset( $slug ) && apply_filters( 'pll_modify_rewrite_rule', true, array( $key => $rule ), $filter, false ) ) { 
  201.                     $newrules[ $slug . str_replace( $wp_rewrite->root, '', ltrim( $key, '^' ) ) ] = str_replace( 
  202.                         array( '[8]', '[7]', '[6]', '[5]', '[4]', '[3]', '[2]', '[1]', '?' ),  
  203.                         array( '[9]', '[8]', '[7]', '[6]', '[5]', '[4]', '[3]', '[2]', '?lang=$matches[1]&' ),  
  204.                         $rule 
  205.  ); // Should be enough! 
  206.                 } 
  207.  
  208.                 $newrules[ $key ] = $rule; 
  209.             } 
  210.  
  211.             // Rewrite rules filtered by language 
  212.             elseif ( in_array( $filter, $this->always_rewrite ) || in_array( $filter, $this->model->get_filtered_taxonomies() ) || ( $cpts && preg_match( $cpts, $rule, $matches ) && ! strpos( $rule, 'name=' ) ) || ( 'rewrite_rules_array' != $filter && $this->options['force_lang'] ) ) { 
  213.  
  214.                 /** This filter is documented in include/links-directory.php */ 
  215.                 if ( apply_filters( 'pll_modify_rewrite_rule', true, array( $key => $rule ), $filter, empty( $matches[1] ) ? false : $matches[1] ) ) { 
  216.                     if ( isset( $slug ) ) { 
  217.                         $newrules[ $slug . str_replace( $wp_rewrite->root, '', ltrim( $key, '^' ) ) ] = str_replace( 
  218.                             array( '[8]', '[7]', '[6]', '[5]', '[4]', '[3]', '[2]', '[1]', '?' ),  
  219.                             array( '[9]', '[8]', '[7]', '[6]', '[5]', '[4]', '[3]', '[2]', '?lang=$matches[1]&' ),  
  220.                             $rule 
  221.  ); // Should be enough! 
  222.                     } 
  223.  
  224.                     if ( $this->options['hide_default'] ) { 
  225.                         $newrules[ $key ] = str_replace( '?', '?lang=' . $this->options['default_lang'] . '&', $rule ); 
  226.                     } 
  227.                 }    else { 
  228.                     $newrules[ $key ] = $rule; 
  229.                 } 
  230.             } 
  231.  
  232.             // Unmodified rules 
  233.             else { 
  234.                 $newrules[ $key ] = $rule; 
  235.             } 
  236.         } 
  237.  
  238.         // The home rewrite rule 
  239.         if ( 'root' == $filter && isset( $slug ) ) { 
  240.             $newrules[ $slug . '?$' ] = $wp_rewrite->index.'?lang=$matches[1]'; 
  241.         } 
  242.  
  243.         return $newrules; 
  244.     } 
  245. }