79214324a4af07648382e4f51be060eb1d78ecd3

Committed 23 May 2024 02:55PM UTC coverage: 48.329% (-4.3%) from 52.636%

Build # 79214324a4af07648382e4f51be060eb1d78ecd3

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #21402 from Yoast/fix/allow-multiple-faq-blocks

Allow multiple FAQ blocks

Run Details

7399 of 13438 branches covered (55.06%)

Branch coverage included in aggregate %.

0 of 4 new or added lines in 2 files covered. (0.0%)

3706 existing lines in 106 files now uncovered.

24971 of 53540 relevant lines covered (46.64%)

41953.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/inc/sitemaps/class-sitemaps.php

<?php
/**
 * WPSEO plugin file.
 *
 * @package WPSEO\XML_Sitemaps
 */

/**
 * Class WPSEO_Sitemaps.
 *
 * @todo This class could use a general description with some explanation on sitemaps. OR.
 */
class WPSEO_Sitemaps {

        /**
         * Sitemap index identifier.
         *
         * @var string
         */
        public const SITEMAP_INDEX_TYPE = '1';

        /**
         * Content of the sitemap to output.
         *
         * @var string
         */
        protected $sitemap = '';

        /**
         * Flag to indicate if this is an invalid or empty sitemap.
         *
         * @var bool
         */
        public $bad_sitemap = false;

        /**
         * Whether or not the XML sitemap was served from a transient or not.
         *
         * @var bool
         */
        private $transient = false;

        /**
         * HTTP protocol to use in headers.
         *
         * @since 3.2
         *
         * @var string
         */
        protected $http_protocol = 'HTTP/1.1';

        /**
         * Holds the n variable.
         *
         * @var int
         */
        private $current_page = 1;

        /**
         * The sitemaps router.
         *
         * @since 3.2
         *
         * @var WPSEO_Sitemaps_Router
         */
        public $router;

        /**
         * The sitemap renderer.
         *
         * @since 3.2
         *
         * @var WPSEO_Sitemaps_Renderer
         */
        public $renderer;

        /**
         * The sitemap cache.
         *
         * @since 3.2
         *
         * @var WPSEO_Sitemaps_Cache
         */
        public $cache;

        /**
         * The sitemap providers.
         *
         * @since 3.2
         *
         * @var WPSEO_Sitemap_Provider[]
         */
        public $providers;

        /**
         * Class constructor.
         */
        public function __construct() {

                add_action( 'after_setup_theme', [ $this, 'init_sitemaps_providers' ] );
                add_action( 'after_setup_theme', [ $this, 'reduce_query_load' ], 99 );
                add_action( 'pre_get_posts', [ $this, 'redirect' ], 1 );
                add_action( 'wpseo_hit_sitemap_index', [ $this, 'hit_sitemap_index' ] );

                $this->router   = new WPSEO_Sitemaps_Router();
                $this->renderer = new WPSEO_Sitemaps_Renderer();
                $this->cache    = new WPSEO_Sitemaps_Cache();

                if ( ! empty( $_SERVER['SERVER_PROTOCOL'] ) ) {
                        $this->http_protocol = sanitize_text_field( wp_unslash( $_SERVER['SERVER_PROTOCOL'] ) );
                }
        }

        /**
         * Initialize sitemap providers classes.
         *
         * @since 5.3
         *
         * @return void
         */
        public function init_sitemaps_providers() {

                $this->providers = [
                        new WPSEO_Post_Type_Sitemap_Provider(),
                        new WPSEO_Taxonomy_Sitemap_Provider(),
                        new WPSEO_Author_Sitemap_Provider(),
                ];

                $external_providers = apply_filters( 'wpseo_sitemaps_providers', [] );

                foreach ( $external_providers as $provider ) {
                        if ( is_object( $provider ) && $provider instanceof WPSEO_Sitemap_Provider ) {
                                $this->providers[] = $provider;
                        }
                }
        }

        /**
         * Check the current request URI, if we can determine it's probably an XML sitemap, kill loading the widgets.
         *
         * @return void
         */
        public function reduce_query_load() {
                if ( ! isset( $_SERVER['REQUEST_URI'] ) ) {
                        return;
                }
                $request_uri = sanitize_text_field( wp_unslash( $_SERVER['REQUEST_URI'] ) );
                $extension   = substr( $request_uri, -4 );
                if ( stripos( $request_uri, 'sitemap' ) !== false && in_array( $extension, [ '.xml', '.xsl' ], true ) ) {
                        remove_all_actions( 'widgets_init' );
                }
        }

        /**
         * Register your own sitemap. Call this during 'init'.
         *
         * @param string   $name              The name of the sitemap.
         * @param callback $building_function Function to build your sitemap.
         * @param string   $rewrite           Optional. Regular expression to match your sitemap with.
         *
         * @return void
         */
        public function register_sitemap( $name, $building_function, $rewrite = '' ) {
                add_action( 'wpseo_do_sitemap_' . $name, $building_function );
                if ( $rewrite ) {
                        Yoast_Dynamic_Rewrites::instance()->add_rule( $rewrite, 'index.php?sitemap=' . $name, 'top' );
                }
        }

        /**
         * Register your own XSL file. Call this during 'init'.
         *
         * @since 1.4.23
         *
         * @param string   $name              The name of the XSL file.
         * @param callback $building_function Function to build your XSL file.
         * @param string   $rewrite           Optional. Regular expression to match your sitemap with.
         *
         * @return void
         */
        public function register_xsl( $name, $building_function, $rewrite = '' ) {
                add_action( 'wpseo_xsl_' . $name, $building_function );
                if ( $rewrite ) {
                        Yoast_Dynamic_Rewrites::instance()->add_rule( $rewrite, 'index.php?yoast-sitemap-xsl=' . $name, 'top' );
                }
        }

        /**
         * Set the sitemap current page to allow creating partial sitemaps with WP-CLI
         * in a one-off process.
         *
         * @param int $current_page The part that should be generated.
         *
         * @return void
         */
        public function set_n( $current_page ) {
                if ( is_scalar( $current_page ) && intval( $current_page ) > 0 ) {
                        $this->current_page = intval( $current_page );
                }
        }

        /**
         * Set the sitemap content to display after you have generated it.
         *
         * @param string $sitemap The generated sitemap to output.
         *
         * @return void
         */
        public function set_sitemap( $sitemap ) {
                $this->sitemap = $sitemap;
        }

        /**
         * Set as true to make the request 404. Used stop the display of empty sitemaps or invalid requests.
         *
         * @param bool $is_bad Is this a bad request. True or false.
         *
         * @return void
         */
        public function set_bad_sitemap( $is_bad ) {
                $this->bad_sitemap = (bool) $is_bad;
        }

        /**
         * Prevent stupid plugins from running shutdown scripts when we're obviously not outputting HTML.
         *
         * @since 1.4.16
         *
         * @return void
         */
        public function sitemap_close() {
                remove_all_actions( 'wp_footer' );
                die();
        }

        /**
         * Hijack requests for potential sitemaps and XSL files.
         *
         * @param WP_Query $query Main query instance.
         *
         * @return void
         */
        public function redirect( $query ) {

                if ( ! $query->is_main_query() ) {
                        return;
                }

                $yoast_sitemap_xsl = get_query_var( 'yoast-sitemap-xsl' );

                if ( ! empty( $yoast_sitemap_xsl ) ) {
                        /*
                         * This is a method to provide the XSL via the home_url.
                         * Needed when the site_url and home_url are not the same.
                         * Loading the XSL needs to come from the same domain, protocol and port as the XML.
                         *
                         * Whenever home_url and site_url are the same, the file can be loaded directly.
                         */
                        $this->xsl_output( $yoast_sitemap_xsl );
                        $this->sitemap_close();

                        return;
                }

                $type = get_query_var( 'sitemap' );

                if ( empty( $type ) ) {
                        return;
                }

                if ( get_query_var( 'sitemap_n' ) === '1' || get_query_var( 'sitemap_n' ) === '0' ) {
                        wp_safe_redirect( home_url( "/$type-sitemap.xml" ), 301, 'Yoast SEO' );
                        exit;
                }

                $this->set_n( get_query_var( 'sitemap_n' ) );

                if ( ! $this->get_sitemap_from_cache( $type, $this->current_page ) ) {
                        $this->build_sitemap( $type );
                }

                if ( $this->bad_sitemap ) {
                        $query->set_404();
                        status_header( 404 );

                        return;
                }

                $this->output();
                $this->sitemap_close();
        }

        /**
         * Try to get the sitemap from cache.
         *
         * @param string $type        Sitemap type.
         * @param int    $page_number The page number to retrieve.
         *
         * @return bool If the sitemap has been retrieved from cache.
         */
        private function get_sitemap_from_cache( $type, $page_number ) {

                $this->transient = false;

                if ( $this->cache->is_enabled() !== true ) {
                        return false;
                }

                /**
                 * Fires before the attempt to retrieve XML sitemap from the transient cache.
                 *
                 * @param WPSEO_Sitemaps $sitemaps Sitemaps object.
                 */
                do_action( 'wpseo_sitemap_stylesheet_cache_' . $type, $this );

                $sitemap_cache_data = $this->cache->get_sitemap_data( $type, $page_number );

                // No cache was found, refresh it because cache is enabled.
                if ( empty( $sitemap_cache_data ) ) {
                        return $this->refresh_sitemap_cache( $type, $page_number );
                }

                // Cache object was found, parse information.
                $this->transient = true;

                $this->sitemap     = $sitemap_cache_data->get_sitemap();
                $this->bad_sitemap = ! $sitemap_cache_data->is_usable();

                return true;
        }

        /**
         * Build and save sitemap to cache.
         *
         * @param string $type        Sitemap type.
         * @param int    $page_number The page number to save to.
         *
         * @return bool
         */
        private function refresh_sitemap_cache( $type, $page_number ) {
                $this->set_n( $page_number );
                $this->build_sitemap( $type );

                return $this->cache->store_sitemap( $type, $page_number, $this->sitemap, ! $this->bad_sitemap );
        }

        /**
         * Attempts to build the requested sitemap.
         *
         * Sets $bad_sitemap if this isn't for the root sitemap, a post type or taxonomy.
         *
         * @param string $type The requested sitemap's identifier.
         *
         * @return void
         */
        public function build_sitemap( $type ) {

                /**
                 * Filter the type of sitemap to build.
                 *
                 * @param string $type Sitemap type, determined by the request.
                 */
                $type = apply_filters( 'wpseo_build_sitemap_post_type', $type );

                if ( $type === '1' ) {
                        $this->build_root_map();

                        return;
                }

                $entries_per_page = $this->get_entries_per_page();

                foreach ( $this->providers as $provider ) {
                        if ( ! $provider->handles_type( $type ) ) {
                                continue;
                        }

                        try {
                                $links = $provider->get_sitemap_links( $type, $entries_per_page, $this->current_page );
                        } catch ( OutOfBoundsException $exception ) {
                                $this->bad_sitemap = true;

                                return;
                        }

                        $this->sitemap = $this->renderer->get_sitemap( $links, $type, $this->current_page );

                        return;
                }

                if ( has_action( 'wpseo_do_sitemap_' . $type ) ) {
                        /**
                         * Fires custom handler, if hooked to generate sitemap for the type.
                         */
                        do_action( 'wpseo_do_sitemap_' . $type );

                        return;
                }

                $this->bad_sitemap = true;
        }

        /**
         * Build the root sitemap (example.com/sitemap_index.xml) which lists sub-sitemaps for other content types.
         *
         * @return void
         */
        public function build_root_map() {

                $links            = [];
                $entries_per_page = $this->get_entries_per_page();

                foreach ( $this->providers as $provider ) {
                        $links = array_merge( $links, $provider->get_index_links( $entries_per_page ) );
                }

                /**
                 * Filter the sitemap links array before the index sitemap is built.
                 *
                 * @param array  $links Array of sitemap links
                 */
                $links = apply_filters( 'wpseo_sitemap_index_links', $links );

                if ( empty( $links ) ) {
                        $this->bad_sitemap = true;
                        $this->sitemap     = '';

                        return;
                }

                $this->sitemap = $this->renderer->get_index( $links );
        }

        /**
         * Spits out the XSL for the XML sitemap.
         *
         * @since 1.4.13
         *
         * @param string $type Type to output.
         *
         * @return void
         */
        public function xsl_output( $type ) {

                if ( $type !== 'main' ) {

                        /**
                         * Fires for the output of XSL for XML sitemaps, other than type "main".
                         */
                        do_action( 'wpseo_xsl_' . $type );

                        return;
                }

                header( $this->http_protocol . ' 200 OK', true, 200 );
                // Prevent the search engines from indexing the XML Sitemap.
                header( 'X-Robots-Tag: noindex, follow', true );
                header( 'Content-Type: text/xml' );

                // Make the browser cache this file properly.
                $expires = YEAR_IN_SECONDS;
                header( 'Pragma: public' );
                header( 'Cache-Control: max-age=' . $expires );
                header( 'Expires: ' . YoastSEO()->helpers->date->format_timestamp( ( time() + $expires ), 'D, d M Y H:i:s' ) . ' GMT' );

                // Don't use WP_Filesystem() here because that's not initialized yet. See https://yoast.atlassian.net/browse/QAK-2043.
                readfile( WPSEO_PATH . 'css/main-sitemap.xsl' );
        }

        /**
         * Spit out the generated sitemap.
         *
         * @return void
         */
        public function output() {
                $this->send_headers();
                // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- Escaping sitemap as either xml or html results in empty document.
                echo $this->renderer->get_output( $this->sitemap );
        }

        /**
         * Makes a request to the sitemap index to cache it before the arrival of the search engines.
         *
         * @return void
         */
        public function hit_sitemap_index() {
                if ( ! $this->cache->is_enabled() ) {
                        return;
                }

                wp_remote_get( WPSEO_Sitemaps_Router::get_base_url( 'sitemap_index.xml' ) );
        }

        /**
         * Get the GMT modification date for the last modified post in the post type.
         *
         * @since 3.2
         *
         * @param string|array $post_types Post type or array of types.
         * @param bool         $return_all Flag to return array of values.
         *
         * @return string|array|false
         */
        public static function get_last_modified_gmt( $post_types, $return_all = false ) {

                global $wpdb;

                static $post_type_dates = null;

                if ( ! is_array( $post_types ) ) {
                        $post_types = [ $post_types ];
                }

                foreach ( $post_types as $post_type ) {
                        if ( ! isset( $post_type_dates[ $post_type ] ) ) { // If we hadn't seen post type before. R.
                                $post_type_dates = null;
                                break;
                        }
                }

                if ( is_null( $post_type_dates ) ) {

                        $post_type_dates = [];
                        $post_type_names = WPSEO_Post_Type::get_accessible_post_types();

                        if ( ! empty( $post_type_names ) ) {
                                $post_statuses = array_map( 'esc_sql', self::get_post_statuses() );
                                $replacements  = array_merge(
                                        [
                                                'post_type',
                                                'post_modified_gmt',
                                                'date',
                                                $wpdb->posts,
                                                'post_status',
                                        ],
                                        $post_statuses,
                                        [ 'post_type' ],
                                        array_keys( $post_type_names ),
                                        [
                                                'post_type',
                                                'date',
                                        ]
                                );

                                //phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- We need to use a direct query here.
                                //phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
                                $dates = $wpdb->get_results(
                                        //phpcs:disable WordPress.DB.PreparedSQLPlaceholders -- %i placeholder is still not recognized.
                                        $wpdb->prepare(
                                                '
                                        SELECT %i, MAX(%i) AS %i
                                        FROM %i
                                        WHERE %i IN (' . implode( ', ', array_fill( 0, count( $post_statuses ), '%s' ) ) . ')
                                                AND %i IN (' . implode( ', ', array_fill( 0, count( $post_type_names ), '%s' ) ) . ')
                                        GROUP BY %i
                                        ORDER BY %i DESC
                                ',
                                                $replacements
                                        )
                                );

                                foreach ( $dates as $obj ) {
                                        $post_type_dates[ $obj->post_type ] = $obj->date;
                                }
                        }
                }

                $dates = array_intersect_key( $post_type_dates, array_flip( $post_types ) );

                if ( count( $dates ) > 0 ) {
                        if ( $return_all ) {
                                return $dates;
                        }

                        return max( $dates );
                }

                return false;
        }

        /**
         * Get the modification date for the last modified post in the post type.
         *
         * @param array $post_types Post types to get the last modification date for.
         *
         * @return string
         */
        public function get_last_modified( $post_types ) {
                return YoastSEO()->helpers->date->format( self::get_last_modified_gmt( $post_types ) );
        }

        /**
         * Get the maximum number of entries per XML sitemap.
         *
         * @return int The maximum number of entries.
         */
        protected function get_entries_per_page() {
                /**
                 * Filter the maximum number of entries per XML sitemap.
                 *
                 * After changing the output of the filter, make sure that you disable and enable the
                 * sitemaps to make sure the value is picked up for the sitemap cache.
                 *
                 * @param int $entries The maximum number of entries per XML sitemap.
                 */
                $entries = (int) apply_filters( 'wpseo_sitemap_entries_per_page', 1000 );

                return $entries;
        }

        /**
         * Get post statuses for post_type or the root sitemap.
         *
         * @since 10.2
         *
         * @param string $type Provide a type for a post_type sitemap, SITEMAP_INDEX_TYPE for the root sitemap.
         *
         * @return array List of post statuses.
         */
        public static function get_post_statuses( $type = self::SITEMAP_INDEX_TYPE ) {
                /**
                 * Filter post status list for sitemap query for the post type.
                 *
                 * @param array  $post_statuses Post status list, defaults to array( 'publish' ).
                 * @param string $type          Post type or SITEMAP_INDEX_TYPE.
                 */
                $post_statuses = apply_filters( 'wpseo_sitemap_post_statuses', [ 'publish' ], $type );

                if ( ! is_array( $post_statuses ) || empty( $post_statuses ) ) {
                        $post_statuses = [ 'publish' ];
                }

                if ( ( $type === self::SITEMAP_INDEX_TYPE || $type === 'attachment' )
                        && ! in_array( 'inherit', $post_statuses, true )
                ) {
                        $post_statuses[] = 'inherit';
                }

                return $post_statuses;
        }

        /**
         * Sends all the required HTTP Headers.
         *
         * @return void
         */
        private function send_headers() {
                if ( headers_sent() ) {
                        return;
                }

                $headers = [
                        $this->http_protocol . ' 200 OK' => 200,
                        // Prevent the search engines from indexing the XML Sitemap.
                        'X-Robots-Tag: noindex, follow'  => '',
                        'Content-Type: text/xml; charset=' . esc_attr( $this->renderer->get_output_charset() ) => '',
                ];

                /**
                 * Filter the HTTP headers we send before an XML sitemap.
                 *
                 * @param array  $headers The HTTP headers we're going to send out.
                 */
                $headers = apply_filters( 'wpseo_sitemap_http_headers', $headers );

                foreach ( $headers as $header => $status ) {
                        if ( is_numeric( $status ) ) {
                                header( $header, true, $status );
                                continue;
                        }
                        header( $header, true );
                }
        }
}

1	<?php
2	/**
3	* WPSEO plugin file.
4	*
5	* @package WPSEO\XML_Sitemaps
6	*/
7
8	/**
9	* Class WPSEO_Sitemaps.
10	*
11	* @todo This class could use a general description with some explanation on sitemaps. OR.
12	*/
13	class WPSEO_Sitemaps {
14
15	/**
16	* Sitemap index identifier.
17	*
18	* @var string
19	*/
20	public const SITEMAP_INDEX_TYPE = '1';
21
22	/**
23	* Content of the sitemap to output.
24	*
25	* @var string
26	*/
27	protected $sitemap = '';
28
29	/**
30	* Flag to indicate if this is an invalid or empty sitemap.
31	*
32	* @var bool
33	*/
34	public $bad_sitemap = false;
35
36	/**
37	* Whether or not the XML sitemap was served from a transient or not.
38	*
39	* @var bool
40	*/
41	private $transient = false;
42
43	/**
44	* HTTP protocol to use in headers.
45	*
46	* @since 3.2
47	*
48	* @var string
49	*/
50	protected $http_protocol = 'HTTP/1.1';
51
52	/**
53	* Holds the n variable.
54	*
55	* @var int
56	*/
57	private $current_page = 1;
58
59	/**
60	* The sitemaps router.
61	*
62	* @since 3.2
63	*
64	* @var WPSEO_Sitemaps_Router
65	*/
66	public $router;
67
68	/**
69	* The sitemap renderer.
70	*
71	* @since 3.2
72	*
73	* @var WPSEO_Sitemaps_Renderer
74	*/
75	public $renderer;
76
77	/**
78	* The sitemap cache.
79	*
80	* @since 3.2
81	*
82	* @var WPSEO_Sitemaps_Cache
83	*/
84	public $cache;
85
86	/**
87	* The sitemap providers.
88	*
89	* @since 3.2
90	*
91	* @var WPSEO_Sitemap_Provider[]
92	*/
93	public $providers;
94
95	/**
96	* Class constructor.
97	*/
UNCOV 98	public function __construct() {	×
99
UNCOV 100	add_action( 'after_setup_theme', [ $this, 'init_sitemaps_providers' ] );	×
UNCOV 101	add_action( 'after_setup_theme', [ $this, 'reduce_query_load' ], 99 );	×
UNCOV 102	add_action( 'pre_get_posts', [ $this, 'redirect' ], 1 );	×
UNCOV 103	add_action( 'wpseo_hit_sitemap_index', [ $this, 'hit_sitemap_index' ] );	×
104
UNCOV 105	$this->router = new WPSEO_Sitemaps_Router();	×
UNCOV 106	$this->renderer = new WPSEO_Sitemaps_Renderer();	×
UNCOV 107	$this->cache = new WPSEO_Sitemaps_Cache();	×
108
UNCOV 109	if ( ! empty( $_SERVER['SERVER_PROTOCOL'] ) ) {	×
UNCOV 110	$this->http_protocol = sanitize_text_field( wp_unslash( $_SERVER['SERVER_PROTOCOL'] ) );	×
111	}
112	}
113
114	/**
115	* Initialize sitemap providers classes.
116	*
117	* @since 5.3
118	*
119	* @return void
120	*/
UNCOV 121	public function init_sitemaps_providers() {	×
122
UNCOV 123	$this->providers = [	×
UNCOV 124	new WPSEO_Post_Type_Sitemap_Provider(),	×
UNCOV 125	new WPSEO_Taxonomy_Sitemap_Provider(),	×
UNCOV 126	new WPSEO_Author_Sitemap_Provider(),	×
UNCOV 127	];	×
128
UNCOV 129	$external_providers = apply_filters( 'wpseo_sitemaps_providers', [] );	×
130
UNCOV 131	foreach ( $external_providers as $provider ) {	×
132	if ( is_object( $provider ) && $provider instanceof WPSEO_Sitemap_Provider ) {	×
133	$this->providers[] = $provider;	×
134	}
135	}
136	}
137
138	/**
139	* Check the current request URI, if we can determine it's probably an XML sitemap, kill loading the widgets.
140	*
141	* @return void
142	*/
143	public function reduce_query_load() {	×
144	if ( ! isset( $_SERVER['REQUEST_URI'] ) ) {	×
145	return;	×
146	}
147	$request_uri = sanitize_text_field( wp_unslash( $_SERVER['REQUEST_URI'] ) );	×
148	$extension = substr( $request_uri, -4 );	×
149	if ( stripos( $request_uri, 'sitemap' ) !== false && in_array( $extension, [ '.xml', '.xsl' ], true ) ) {	×
150	remove_all_actions( 'widgets_init' );	×
151	}
152	}
153
154	/**
155	* Register your own sitemap. Call this during 'init'.
156	*
157	* @param string $name The name of the sitemap.
158	* @param callback $building_function Function to build your sitemap.
159	* @param string $rewrite Optional. Regular expression to match your sitemap with.
160	*
161	* @return void
162	*/
163	public function register_sitemap( $name, $building_function, $rewrite = '' ) {	×
164	add_action( 'wpseo_do_sitemap_' . $name, $building_function );	×
165	if ( $rewrite ) {	×
166	Yoast_Dynamic_Rewrites::instance()->add_rule( $rewrite, 'index.php?sitemap=' . $name, 'top' );	×
167	}
168	}
169
170	/**
171	* Register your own XSL file. Call this during 'init'.
172	*
173	* @since 1.4.23
174	*
175	* @param string $name The name of the XSL file.
176	* @param callback $building_function Function to build your XSL file.
177	* @param string $rewrite Optional. Regular expression to match your sitemap with.
178	*
179	* @return void
180	*/
181	public function register_xsl( $name, $building_function, $rewrite = '' ) {	×
182	add_action( 'wpseo_xsl_' . $name, $building_function );	×
183	if ( $rewrite ) {	×
184	Yoast_Dynamic_Rewrites::instance()->add_rule( $rewrite, 'index.php?yoast-sitemap-xsl=' . $name, 'top' );	×
185	}
186	}
187
188	/**
189	* Set the sitemap current page to allow creating partial sitemaps with WP-CLI
190	* in a one-off process.
191	*
192	* @param int $current_page The part that should be generated.
193	*
194	* @return void
195	*/
UNCOV 196	public function set_n( $current_page ) {	×
UNCOV 197	if ( is_scalar( $current_page ) && intval( $current_page ) > 0 ) {	×
198	$this->current_page = intval( $current_page );	×
199	}
200	}
201
202	/**
203	* Set the sitemap content to display after you have generated it.
204	*
205	* @param string $sitemap The generated sitemap to output.
206	*
207	* @return void
208	*/
209	public function set_sitemap( $sitemap ) {	×
210	$this->sitemap = $sitemap;	×
211	}
212
213	/**
214	* Set as true to make the request 404. Used stop the display of empty sitemaps or invalid requests.
215	*
216	* @param bool $is_bad Is this a bad request. True or false.
217	*
218	* @return void
219	*/
220	public function set_bad_sitemap( $is_bad ) {	×
221	$this->bad_sitemap = (bool) $is_bad;	×
222	}
223
224	/**
225	* Prevent stupid plugins from running shutdown scripts when we're obviously not outputting HTML.
226	*
227	* @since 1.4.16
228	*
229	* @return void
230	*/
231	public function sitemap_close() {	×
232	remove_all_actions( 'wp_footer' );	×
233	die();	×
234	}
235
236	/**
237	* Hijack requests for potential sitemaps and XSL files.
238	*
239	* @param WP_Query $query Main query instance.
240	*
241	* @return void
242	*/
UNCOV 243	public function redirect( $query ) {	×
244
UNCOV 245	if ( ! $query->is_main_query() ) {	×
UNCOV 246	return;	×
247	}
248
UNCOV 249	$yoast_sitemap_xsl = get_query_var( 'yoast-sitemap-xsl' );	×
250
UNCOV 251	if ( ! empty( $yoast_sitemap_xsl ) ) {	×
252	/*
253	* This is a method to provide the XSL via the home_url.
254	* Needed when the site_url and home_url are not the same.
255	* Loading the XSL needs to come from the same domain, protocol and port as the XML.
256	*
257	* Whenever home_url and site_url are the same, the file can be loaded directly.
258	*/
259	$this->xsl_output( $yoast_sitemap_xsl );	×
260	$this->sitemap_close();	×
261
262	return;	×
263	}
264
UNCOV 265	$type = get_query_var( 'sitemap' );	×
266
UNCOV 267	if ( empty( $type ) ) {	×
268	return;	×
269	}
270
UNCOV 271	if ( get_query_var( 'sitemap_n' ) === '1' \|\| get_query_var( 'sitemap_n' ) === '0' ) {	×
272	wp_safe_redirect( home_url( "/$type-sitemap.xml" ), 301, 'Yoast SEO' );	×
273	exit;	×
274	}
275
UNCOV 276	$this->set_n( get_query_var( 'sitemap_n' ) );	×
277
UNCOV 278	if ( ! $this->get_sitemap_from_cache( $type, $this->current_page ) ) {	×
UNCOV 279	$this->build_sitemap( $type );	×
280	}
281
UNCOV 282	if ( $this->bad_sitemap ) {	×
283	$query->set_404();	×
284	status_header( 404 );	×
285
286	return;	×
287	}
288
UNCOV 289	$this->output();	×
UNCOV 290	$this->sitemap_close();	×
291	}
292
293	/**
294	* Try to get the sitemap from cache.
295	*
296	* @param string $type Sitemap type.
297	* @param int $page_number The page number to retrieve.
298	*
299	* @return bool If the sitemap has been retrieved from cache.
300	*/
UNCOV 301	private function get_sitemap_from_cache( $type, $page_number ) {	×
302
UNCOV 303	$this->transient = false;	×
304
UNCOV 305	if ( $this->cache->is_enabled() !== true ) {	×
UNCOV 306	return false;	×
307	}
308
309	/**
310	* Fires before the attempt to retrieve XML sitemap from the transient cache.
311	*
312	* @param WPSEO_Sitemaps $sitemaps Sitemaps object.
313	*/
314	do_action( 'wpseo_sitemap_stylesheet_cache_' . $type, $this );	×
315
316	$sitemap_cache_data = $this->cache->get_sitemap_data( $type, $page_number );	×
317
318	// No cache was found, refresh it because cache is enabled.
319	if ( empty( $sitemap_cache_data ) ) {	×
320	return $this->refresh_sitemap_cache( $type, $page_number );	×
321	}
322
323	// Cache object was found, parse information.
324	$this->transient = true;	×
325
326	$this->sitemap = $sitemap_cache_data->get_sitemap();	×
327	$this->bad_sitemap = ! $sitemap_cache_data->is_usable();	×
328
329	return true;	×
330	}
331
332	/**
333	* Build and save sitemap to cache.
334	*
335	* @param string $type Sitemap type.
336	* @param int $page_number The page number to save to.
337	*
338	* @return bool
339	*/
340	private function refresh_sitemap_cache( $type, $page_number ) {	×
341	$this->set_n( $page_number );	×
342	$this->build_sitemap( $type );	×
343
344	return $this->cache->store_sitemap( $type, $page_number, $this->sitemap, ! $this->bad_sitemap );	×
345	}
346
347	/**
348	* Attempts to build the requested sitemap.
349	*
350	* Sets $bad_sitemap if this isn't for the root sitemap, a post type or taxonomy.
351	*
352	* @param string $type The requested sitemap's identifier.
353	*
354	* @return void
355	*/
UNCOV 356	public function build_sitemap( $type ) {	×
357
358	/**
359	* Filter the type of sitemap to build.
360	*
361	* @param string $type Sitemap type, determined by the request.
362	*/
UNCOV 363	$type = apply_filters( 'wpseo_build_sitemap_post_type', $type );	×
364
UNCOV 365	if ( $type === '1' ) {	×
UNCOV 366	$this->build_root_map();	×
367
UNCOV 368	return;	×
369	}
370
UNCOV 371	$entries_per_page = $this->get_entries_per_page();	×
372
UNCOV 373	foreach ( $this->providers as $provider ) {	×
UNCOV 374	if ( ! $provider->handles_type( $type ) ) {	×
UNCOV 375	continue;	×
376	}
377
378	try {
UNCOV 379	$links = $provider->get_sitemap_links( $type, $entries_per_page, $this->current_page );	×
380	} catch ( OutOfBoundsException $exception ) {	×
381	$this->bad_sitemap = true;	×
382
383	return;	×
384	}
385
UNCOV 386	$this->sitemap = $this->renderer->get_sitemap( $links, $type, $this->current_page );	×
387
UNCOV 388	return;	×
389	}
390
391	if ( has_action( 'wpseo_do_sitemap_' . $type ) ) {	×
392	/**
393	* Fires custom handler, if hooked to generate sitemap for the type.
394	*/
395	do_action( 'wpseo_do_sitemap_' . $type );	×
396
397	return;	×
398	}
399
400	$this->bad_sitemap = true;	×
401	}
402
403	/**
404	* Build the root sitemap (example.com/sitemap_index.xml) which lists sub-sitemaps for other content types.
405	*
406	* @return void
407	*/
UNCOV 408	public function build_root_map() {	×
409
UNCOV 410	$links = [];	×
UNCOV 411	$entries_per_page = $this->get_entries_per_page();	×
412
UNCOV 413	foreach ( $this->providers as $provider ) {	×
UNCOV 414	$links = array_merge( $links, $provider->get_index_links( $entries_per_page ) );	×
415	}
416
417	/**
418	* Filter the sitemap links array before the index sitemap is built.
419	*
420	* @param array $links Array of sitemap links
421	*/
UNCOV 422	$links = apply_filters( 'wpseo_sitemap_index_links', $links );	×
423
UNCOV 424	if ( empty( $links ) ) {	×
425	$this->bad_sitemap = true;	×
426	$this->sitemap = '';	×
427
428	return;	×
429	}
430
UNCOV 431	$this->sitemap = $this->renderer->get_index( $links );	×
432	}
433
434	/**
435	* Spits out the XSL for the XML sitemap.
436	*
437	* @since 1.4.13
438	*
439	* @param string $type Type to output.
440	*
441	* @return void
442	*/
443	public function xsl_output( $type ) {	×
444
445	if ( $type !== 'main' ) {	×
446
447	/**
448	* Fires for the output of XSL for XML sitemaps, other than type "main".
449	*/
450	do_action( 'wpseo_xsl_' . $type );	×
451
452	return;	×
453	}
454
455	header( $this->http_protocol . ' 200 OK', true, 200 );	×
456	// Prevent the search engines from indexing the XML Sitemap.
457	header( 'X-Robots-Tag: noindex, follow', true );	×
458	header( 'Content-Type: text/xml' );	×
459
460	// Make the browser cache this file properly.
461	$expires = YEAR_IN_SECONDS;	×
462	header( 'Pragma: public' );	×
463	header( 'Cache-Control: max-age=' . $expires );	×
464	header( 'Expires: ' . YoastSEO()->helpers->date->format_timestamp( ( time() + $expires ), 'D, d M Y H:i:s' ) . ' GMT' );	×
465
466	// Don't use WP_Filesystem() here because that's not initialized yet. See https://yoast.atlassian.net/browse/QAK-2043.
467	readfile( WPSEO_PATH . 'css/main-sitemap.xsl' );	×
468	}
469
470	/**
471	* Spit out the generated sitemap.
472	*
473	* @return void
474	*/
UNCOV 475	public function output() {	×
UNCOV 476	$this->send_headers();	×
477	// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- Escaping sitemap as either xml or html results in empty document.
UNCOV 478	echo $this->renderer->get_output( $this->sitemap );	×
479	}
480
481	/**
482	* Makes a request to the sitemap index to cache it before the arrival of the search engines.
483	*
484	* @return void
485	*/
486	public function hit_sitemap_index() {	×
487	if ( ! $this->cache->is_enabled() ) {	×
488	return;	×
489	}
490
491	wp_remote_get( WPSEO_Sitemaps_Router::get_base_url( 'sitemap_index.xml' ) );	×
492	}
493
494	/**
495	* Get the GMT modification date for the last modified post in the post type.
496	*
497	* @since 3.2
498	*
499	* @param string\|array $post_types Post type or array of types.
500	* @param bool $return_all Flag to return array of values.
501	*
502	* @return string\|array\|false
503	*/
UNCOV 504	public static function get_last_modified_gmt( $post_types, $return_all = false ) {	×
505
UNCOV 506	global $wpdb;	×
507
UNCOV 508	static $post_type_dates = null;	×
509
UNCOV 510	if ( ! is_array( $post_types ) ) {	×
511	$post_types = [ $post_types ];	×
512	}
513
UNCOV 514	foreach ( $post_types as $post_type ) {	×
UNCOV 515	if ( ! isset( $post_type_dates[ $post_type ] ) ) { // If we hadn't seen post type before. R.	×
UNCOV 516	$post_type_dates = null;	×
UNCOV 517	break;	×
518	}
519	}
520
UNCOV 521	if ( is_null( $post_type_dates ) ) {	×
522
UNCOV 523	$post_type_dates = [];	×
UNCOV 524	$post_type_names = WPSEO_Post_Type::get_accessible_post_types();	×
525
UNCOV 526	if ( ! empty( $post_type_names ) ) {	×
UNCOV 527	$post_statuses = array_map( 'esc_sql', self::get_post_statuses() );	×
UNCOV 528	$replacements = array_merge(	×
UNCOV 529	[	×
UNCOV 530	'post_type',	×
UNCOV 531	'post_modified_gmt',	×
UNCOV 532	'date',	×
UNCOV 533	$wpdb->posts,	×
UNCOV 534	'post_status',	×
UNCOV 535	],	×
UNCOV 536	$post_statuses,	×
UNCOV 537	[ 'post_type' ],	×
UNCOV 538	array_keys( $post_type_names ),	×
UNCOV 539	[	×
UNCOV 540	'post_type',	×
UNCOV 541	'date',	×
UNCOV 542	]	×
UNCOV 543	);	×
544
545	//phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- We need to use a direct query here.
546	//phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- Reason: No relevant caches.
UNCOV 547	$dates = $wpdb->get_results(	×
548	//phpcs:disable WordPress.DB.PreparedSQLPlaceholders -- %i placeholder is still not recognized.
UNCOV 549	$wpdb->prepare(	×
UNCOV 550	'	×
551	SELECT %i, MAX(%i) AS %i
552	FROM %i
UNCOV 553	WHERE %i IN (' . implode( ', ', array_fill( 0, count( $post_statuses ), '%s' ) ) . ')	×
UNCOV 554	AND %i IN (' . implode( ', ', array_fill( 0, count( $post_type_names ), '%s' ) ) . ')	×
555	GROUP BY %i
556	ORDER BY %i DESC
UNCOV 557	',	×
UNCOV 558	$replacements	×
UNCOV 559	)	×
UNCOV 560	);	×
561
UNCOV 562	foreach ( $dates as $obj ) {	×
UNCOV 563	$post_type_dates[ $obj->post_type ] = $obj->date;	×
564	}
565	}
566	}
567
UNCOV 568	$dates = array_intersect_key( $post_type_dates, array_flip( $post_types ) );	×
569
UNCOV 570	if ( count( $dates ) > 0 ) {	×
UNCOV 571	if ( $return_all ) {	×
UNCOV 572	return $dates;	×
573	}
574
UNCOV 575	return max( $dates );	×
576	}
577
UNCOV 578	return false;	×
579	}
580
581	/**
582	* Get the modification date for the last modified post in the post type.
583	*
584	* @param array $post_types Post types to get the last modification date for.
585	*
586	* @return string
587	*/
588	public function get_last_modified( $post_types ) {	×
589	return YoastSEO()->helpers->date->format( self::get_last_modified_gmt( $post_types ) );	×
590	}
591
592	/**
593	* Get the maximum number of entries per XML sitemap.
594	*
595	* @return int The maximum number of entries.
596	*/
UNCOV 597	protected function get_entries_per_page() {	×
598	/**
599	* Filter the maximum number of entries per XML sitemap.
600	*
601	* After changing the output of the filter, make sure that you disable and enable the
602	* sitemaps to make sure the value is picked up for the sitemap cache.
603	*
604	* @param int $entries The maximum number of entries per XML sitemap.
605	*/
UNCOV 606	$entries = (int) apply_filters( 'wpseo_sitemap_entries_per_page', 1000 );	×
607
UNCOV 608	return $entries;	×
609	}
610
611	/**
612	* Get post statuses for post_type or the root sitemap.
613	*
614	* @since 10.2
615	*
616	* @param string $type Provide a type for a post_type sitemap, SITEMAP_INDEX_TYPE for the root sitemap.
617	*
618	* @return array List of post statuses.
619	*/
UNCOV 620	public static function get_post_statuses( $type = self::SITEMAP_INDEX_TYPE ) {	×
621	/**
622	* Filter post status list for sitemap query for the post type.
623	*
624	* @param array $post_statuses Post status list, defaults to array( 'publish' ).
625	* @param string $type Post type or SITEMAP_INDEX_TYPE.
626	*/
UNCOV 627	$post_statuses = apply_filters( 'wpseo_sitemap_post_statuses', [ 'publish' ], $type );	×
628
UNCOV 629	if ( ! is_array( $post_statuses ) \|\| empty( $post_statuses ) ) {	×
630	$post_statuses = [ 'publish' ];	×
631	}
632
UNCOV 633	if ( ( $type === self::SITEMAP_INDEX_TYPE \|\| $type === 'attachment' )	×
UNCOV 634	&& ! in_array( 'inherit', $post_statuses, true )	×
635	) {
UNCOV 636	$post_statuses[] = 'inherit';	×
637	}
638
UNCOV 639	return $post_statuses;	×
640	}
641
642	/**
643	* Sends all the required HTTP Headers.
644	*
645	* @return void
646	*/
UNCOV 647	private function send_headers() {	×
UNCOV 648	if ( headers_sent() ) {	×
UNCOV 649	return;	×
650	}
651
UNCOV 652	$headers = [	×
653	$this->http_protocol . ' 200 OK' => 200,	×
654	// Prevent the search engines from indexing the XML Sitemap.
655	'X-Robots-Tag: noindex, follow' => '',	×
656	'Content-Type: text/xml; charset=' . esc_attr( $this->renderer->get_output_charset() ) => '',	×
UNCOV 657	];	×
658
659	/**
660	* Filter the HTTP headers we send before an XML sitemap.
661	*
662	* @param array $headers The HTTP headers we're going to send out.
663	*/
664	$headers = apply_filters( 'wpseo_sitemap_http_headers', $headers );	×
665
666	foreach ( $headers as $header => $status ) {	×
667	if ( is_numeric( $status ) ) {	×
668	header( $header, true, $status );	×
669	continue;	×
670	}
671	header( $header, true );	×
672	}
673	}
674	}

Yoast / wordpress-seo / 79214324a4af07648382e4f51be060eb1d78ecd3

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous