<?php /** * @package The_SEO_Framework\Classes\Facade\Detect * @subpackage The_SEO_Framework\Compatibility */ namespace The_SEO_Framework; \defined( 'THE_SEO_FRAMEWORK_PRESENT' ) or die; /** * The SEO Framework plugin * Copyright (C) 2015 - 2023 Sybre Waaijer, CyberWire B.V. (https://cyberwire.nl/) * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License version 3 as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ /** * Class The_SEO_Framework\Detect * * Detects other plugins and themes * * @since 2.8.0 */ class Detect extends Render { /** * Returns list of active plugins. * Memoizes the return value. * * @since 2.6.1 * @credits Jetpack for some code. * * @return array List of active plugins. */ public function active_plugins() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; $active_plugins = (array) \get_option( 'active_plugins', [] ); if ( \is_multisite() ) { // Due to legacy code, active_sitewide_plugins stores them in the keys, // whereas active_plugins stores them in the values. array_keys() resolves the disparity. $network_plugins = array_keys( \get_site_option( 'active_sitewide_plugins', [] ) ); if ( $network_plugins ) $active_plugins = array_merge( $active_plugins, $network_plugins ); } sort( $active_plugins ); return memo( $active_plugins ); } /** * Filterable list of conflicting plugins. * * @since 2.6.0 * @credits Jetpack for most code. * * @return array List of conflicting plugins. */ public function conflicting_plugins() { $conflicting_plugins = [ 'seo_tools' => [ 'Yoast SEO' => 'wordpress-seo/wp-seo.php', 'Yoast SEO Premium' => 'wordpress-seo-premium/wp-seo-premium.php', 'All in One SEO Pack' => 'all-in-one-seo-pack/all_in_one_seo_pack.php', 'SEO Ultimate' => 'seo-ultimate/seo-ultimate.php', 'SEOPress' => 'wp-seopress/seopress.php', 'Rank Math' => 'seo-by-rank-math/rank-math.php', 'Smart Crawl' => 'smartcrawl-seo/wpmu-dev-seo.php', ], 'sitemaps' => [ 'Google XML Sitemaps' => 'google-sitemap-generator/sitemap.php', 'XML Sitemap & Google News feeds' => 'xml-sitemap-feed/xml-sitemap.php', 'Google Sitemap by BestWebSoft' => 'google-sitemap-plugin/google-sitemap-plugin.php', 'Simple Wp Sitemap' => 'simple-wp-sitemap/simple-wp-sitemap.php', // Remove? ], 'open_graph' => [ 'Facebook Open Graph Meta Tags for WordPress' => 'wonderm00ns-simple-facebook-open-graph-tags/wonderm00n-open-graph.php', 'Open Graph' => 'opengraph/opengraph.php', // Redundant. 'Open Graph Protocol Framework' => 'open-graph-protocol-framework/open-graph-protocol-framework.php', // Redundant. 'Shareaholic2' => 'shareaholic/sexy-bookmarks.php', 'WordPress Social Sharing Optimization' => 'wpsso/wpsso.php', ], 'twitter_card' => [], ]; /** * @since 2.6.0 * @param array $conflicting_plugins The conflicting plugin list. */ return (array) \apply_filters_ref_array( 'the_seo_framework_conflicting_plugins', [ $conflicting_plugins ] ); } /** * Fetches type of conflicting plugins. * * @since 2.6.0 * @since 4.2.0 Now always runs the filter, even when $type is not registered. * * @param string $type The Key from $this->conflicting_plugins() * @return array */ public function get_conflicting_plugins( $type = 'seo_tools' ) { /** * @since 2.6.1 * @param array $conflicting_plugins Conflicting plugins * @param string $type The type of plugins to get. */ return (array) \apply_filters_ref_array( 'the_seo_framework_conflicting_plugins_type', [ $this->conflicting_plugins()[ $type ] ?? [], $type, ] ); } /** * Detect active plugin by constant, class or function existence. * * Note: Class check is 3 times as slow as defined check. Function check is 2 times as slow. * * @since 1.3.0 * @since 2.8.0 1. Can now check for globals. * 2. Switched detection order from FAST to SLOW. * @since 4.0.6 Can no longer autoload classes. * * @param array $plugins Array of array for constants, classes and / or functions to check for plugin existence. * @return boolean True if plugin exists or false if plugin constant, class or function not detected. */ public function detect_plugin( $plugins ) { foreach ( $plugins['globals'] ?? [] as $name ) if ( isset( $GLOBALS[ $name ] ) ) return true; // Check for constants foreach ( $plugins['constants'] ?? [] as $name ) if ( \defined( $name ) ) return true; // Check for functions foreach ( $plugins['functions'] ?? [] as $name ) if ( \function_exists( $name ) ) return true; // Check for classes foreach ( $plugins['classes'] ?? [] as $name ) if ( class_exists( $name, false ) ) // phpcs:ignore, TSF.Performance.Functions.PHP -- we don't autoload. return true; // No globals, constant, function, or class found to exist return false; } /** * Detect if you can use the given constants, functions and classes. * All inputs must be available for this method to return true. * Memoizes the return value for the input argument--sorts the array deeply to ensure a match. * * @since 2.5.2 * @since 4.1.4 Fixed sorting algorithm from fribbling-me to resolving-me. Nothing changed but legibility. * @since 4.2.0 Rewrote sorting algorithm; now, it's actually good. * @uses $this->detect_plugin_multi() * * @param array[] $plugins Array of array for globals, constants, classes * and/or functions to check for plugin existence. * @param bool $use_cache Bypasses cache if false */ public function can_i_use( $plugins = [], $use_cache = true ) { if ( ! $use_cache ) return $this->detect_plugin_multi( $plugins ); ksort( $plugins ); foreach ( $plugins as &$test ) sort( $test ); // phpcs:ignore, WordPress.PHP.DiscouragedPHPFunctions -- No objects are inserted, nor is this ever unserialized. $key = serialize( $test ); return memo( null, $key ) ?? memo( $this->detect_plugin_multi( $plugins ), $key ); } /** * Detect active plugin by constant, class or function existence. * All parameters must match and return true. * * @since 2.5.2 * @since 4.0.6 1. Can now check for globals. * 2. Switched detection order from FAST to SLOW. * 3. Can no longer autoload classes. * This method is only used by can_i_use(), and is only effective in the Ultimate Member compat file... * @TODO deprecate? * * @param array[] $plugins Array of array for constants, classes * and / or functions to check for plugin existence. * @return bool True if ALL functions classes and constants exists * or false if plugin constant, class or function not detected. */ public function detect_plugin_multi( $plugins ) { // Check for globals foreach ( $plugins['globals'] ?? [] as $name ) if ( ! isset( $GLOBALS[ $name ] ) ) return false; // Check for constants foreach ( $plugins['constants'] ?? [] as $name ) if ( ! \defined( $name ) ) return false; // Check for functions foreach ( $plugins['functions'] ?? [] as $name ) if ( ! \function_exists( $name ) ) return false; // Check for classes foreach ( $plugins['classes'] ?? [] as $name ) if ( ! class_exists( $name, false ) ) // phpcs:ignore, TSF.Performance.Functions.PHP -- we don't autoload. return false; // All classes, functions and constant have been found to exist return true; } /** * Checks if the (parent) theme name is loaded. * * @since 2.1.0 * @since 4.2.0 No longer "loads" the theme; instead, simply compares input to active theme options. * * @param string|array $themes The theme names to test. * @return bool is theme active. */ public function is_theme( $themes = '' ) { $active_theme = [ strtolower( \get_option( 'stylesheet' ) ), // Parent strtolower( \get_option( 'template' ) ), // Child ]; foreach ( (array) $themes as $theme ) if ( \in_array( strtolower( $theme ), $active_theme, true ) ) return true; return false; } /** * Determines if other SEO plugins are active. * Memoizes the return value. * * @since 1.3.0 * @since 2.6.0 Uses new style detection. * @since 3.1.0 The filter no longer short-circuits the function when it's false. * * @return bool SEO plugin detected. */ public function detect_seo_plugins() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; $active_plugins = $this->active_plugins(); if ( ! $active_plugins ) return memo( false ); foreach ( $this->get_conflicting_plugins( 'seo_tools' ) as $plugin_name => $plugin ) { if ( \in_array( $plugin, $active_plugins, true ) ) { /** * @since 2.6.1 * @since 3.1.0 Added second and third parameters. * @param bool $detected Whether the plugin should be detected. * @param string $plugin_name The plugin name as defined in `$this->conflicting_plugins()`. * @param string $plugin The plugin that's been detected. */ if ( \apply_filters_ref_array( 'the_seo_framework_seo_plugin_detected', [ true, $plugin_name, $plugin, ] ) ) { $detected = true; break; } } } return memo( $detected ?? false ); } /** * Determines if other Open Graph or SEO plugins are active. * Memoizes the return value. * * @since 1.3.0 * @since 2.8.0 No longer checks for old style filter. * @since 3.1.0 The filter no longer short-circuits the function when it's false. * * @return bool True if OG or SEO plugin detected. */ public function detect_og_plugin() { // Detect SEO plugins beforehand. if ( $this->detect_seo_plugins() ) return true; // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; $active_plugins = $this->active_plugins(); if ( ! $active_plugins ) return memo( false ); foreach ( $this->get_conflicting_plugins( 'open_graph' ) as $plugin_name => $plugin ) { if ( \in_array( $plugin, $active_plugins, true ) ) { /** * @since 2.6.1 * @since 3.1.0 Added second and third parameters. * @param bool $detected Whether the plugin should be detected. * @param string $plugin_name The plugin name as defined in `$this->conflicting_plugins()`. * @param string $plugin The plugin that's been detected. */ if ( \apply_filters_ref_array( 'the_seo_framework_og_plugin_detected', [ true, $plugin_name, $plugin, ] ) ) { $detected = true; break; } } } return memo( $detected ?? false ); } /** * Determines if other Twitter Card plugins are active. * Memoizes the return value. * * @since 2.6.0 * @since 3.1.0 The filter no longer short-circuits the function when it's false. * * @return bool Twitter Card plugin detected. */ public function detect_twitter_card_plugin() { // Detect SEO plugins beforehand. if ( $this->detect_seo_plugins() ) return true; // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; $active_plugins = $this->active_plugins(); if ( ! $active_plugins ) return memo( false ); foreach ( $this->get_conflicting_plugins( 'twitter_card' ) as $plugin_name => $plugin ) { if ( \in_array( $plugin, $active_plugins, true ) ) { /** * @since 2.6.1 * @param bool $detected Whether the plugin should be detected. * @param string $plugin_name The plugin name as defined in `$this->conflicting_plugins()`. * @param string $plugin The plugin that's been detected. */ if ( \apply_filters_ref_array( 'the_seo_framework_twittercard_plugin_detected', [ true, $plugin_name, $plugin, ] ) ) { $detected = true; break; } } } return memo( $detected ?? false ); } /** * Determines if other Schema.org LD+Json plugins are active. * * @since 1.3.0 * @since 2.6.1 Always return false. Let other plugin authors decide its value. * @TODO Make a list of plugins, so the users are well-informed. * * @return bool Whether another Schema.org plugin is active. */ public function has_json_ld_plugin() { /** * @since 2.6.5 * @param bool $detected Whether a conflicting schema plugin is detected. */ return (bool) \apply_filters( 'the_seo_framework_ldjson_plugin_detected', false ); } /** * Determines if other Sitemap plugins are active. * Memoizes the return value. * * @since 2.1.0 * @since 3.1.0 The filter no longer short-circuits the function when it's false. * * @return bool */ public function detect_sitemap_plugin() { // Detect SEO plugins beforehand. if ( $this->detect_seo_plugins() ) return true; // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; $active_plugins = $this->active_plugins(); if ( ! $active_plugins ) return memo( false ); foreach ( $this->get_conflicting_plugins( 'sitemaps' ) as $plugin_name => $plugin ) { if ( \in_array( $plugin, $active_plugins, true ) ) { /** * @since 2.6.1 * @param bool $detected Whether the plugin should be detected. * @param string $plugin_name The plugin name as defined in `$this->conflicting_plugins()`. * @param string $plugin The plugin that's been detected. */ if ( \apply_filters( 'the_seo_framework_sitemap_plugin_detected', [ true, $plugin_name, $plugin, ] ) ) { $detected = true; break; } } } return memo( $detected ?? false ); } /** * Tells whether WP 5.5 Core Sitemaps are used. * Memoizes the return value. * * @since 4.1.2 * * @return bool */ public function use_core_sitemaps() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; if ( $this->get_option( 'sitemaps_output' ) ) return memo( false ); $wp_sitemaps_server = \wp_sitemaps_get_server(); return memo( method_exists( $wp_sitemaps_server, 'sitemaps_enabled' ) && $wp_sitemaps_server->sitemaps_enabled() ); } /** * Detects presence of a page builder that renders content dynamically. * * Detects the following builders: * - Divi Builder by Elegant Themes * - Visual Composer by WPBakery * * @since 4.1.0 * * @return bool */ public function detect_non_html_page_builder() { return memo() ?? memo( /** * @since 4.1.0 * @param bool $detected Whether an active page builder that renders content dynamically is detected. * @NOTE not to be confused with `the_seo_framework_detect_non_html_page_builder`, which tests * the page builder status for each post individually. */ (bool) \apply_filters( 'the_seo_framework_shortcode_based_page_builder_active', $this->detect_plugin( [ 'constants' => [ 'ET_BUILDER_VERSION', 'WPB_VC_VERSION', ], ] ) ) ); } /** * Detects presence of robots.txt in root folder. * Memoizes the return value. * * @since 2.5.2 * @since 4.0.0 Now tries to load `wp-admin/includes/file.php` to prevent a fatal error. * * @return bool Whether the robots.txt file exists. */ public function has_robots_txt() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; // Ensure get_home_path() is declared. if ( ! \function_exists( '\\get_home_path' ) ) require_once ABSPATH . 'wp-admin/includes/file.php'; $path = \get_home_path() . 'robots.txt'; // phpcs:ignore, TSF.Performance.Functions.PHP -- we use path, not URL. return memo( file_exists( $path ) ); } /** * Detects presence of sitemap.xml in root folder. * Memoizes the return value. * * @since 2.5.2 * @since 4.0.0 Now tries to load `wp-admin/includes/file.php` to prevent a fatal error. * * @return bool Whether the sitemap.xml file exists. */ public function has_sitemap_xml() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; // Ensure get_home_path() is declared. if ( ! \function_exists( '\\get_home_path' ) ) require_once ABSPATH . 'wp-admin/includes/file.php'; $path = \get_home_path() . 'sitemap.xml'; // phpcs:ignore, TSF.Performance.Functions.PHP -- we use path, not URL. return memo( file_exists( $path ) ); } /** * Determines whether the main query supports custom SEO. * * @since 4.0.0 * @since 4.0.2 Now tests for an existing post/term ID when on singular/term pages. * @since 4.0.3 Can now assert empty categories again by checking for taxonomy support. * @since 4.2.4 Added detection for AJAX, Cron, JSON, and REST queries (they're not supported as SEO-able queries). * * @return bool */ public function query_supports_seo() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; switch ( true ) : case \is_feed(): case \wp_doing_ajax(): case \wp_doing_cron(): case \wp_is_json_request(): case \defined( 'REST_REQUEST' ) && REST_REQUEST: $supported = false; break; case $this->is_singular(): $supported = $this->is_post_type_supported() && $this->get_the_real_ID(); break; case \is_post_type_archive(): $supported = $this->is_post_type_archive_supported(); break; case $this->is_term_meta_capable(): // When a term has no posts attached, it'll not return a post type, and it returns a 404 late in the loop. // This is because get_post_type() tries to assert the first post in the loop here. // Thus, we test for is_taxonomy_supported() instead. $supported = $this->is_taxonomy_supported() && $this->get_the_real_ID(); break; // This includes 404. default: $supported = true; break; // TODO consider this instead of the current default? (it'd make the AJAX through REST test obsolete) // Every recognized query (aside from $this->is_singular()/is_post_type_archive for we already covered those in full) // case \is_404(): // case $this->is_search(): // case $this->is_real_front_page(): // case $this->is_archive(): // $supported = true; // break; // default: // $supported = false; // break; endswitch; /** * Override false negatives on exploit. * * This protects against (accidental) negative-SEO bombarding. * Support broken queries, so we can noindex them. */ if ( ! $supported && $this->is_query_exploited() ) $supported = true; /** * @since 4.0.0 * @param bool $supported Whether the query supports SEO. */ return memo( (bool) \apply_filters( 'the_seo_framework_query_supports_seo', $supported ) ); } /** * Determines when paged/page is exploited. * Memoizes the return value. * * Google is acting "smart" nowadays, and follows everything that remotely resembles a link. Therefore, unintentional * queries can occur in WordPress. WordPress deals with this well, alas, the query parser (WP_Query::parse_query) * doesn't rectify the mixed signals it receives. Instead, it only sanitizes it, resulting in a combobulated mess. * Ultimately, this leads to non-existing blog archives, among other failures. * * Example 1: `/?p=nonnumeric` will cause an issue. We will see a non-existing blog page. `is_home` is true, but * `page_id` leads to 0 while the database expects the blog page to be another page. So, `is_posts_page` is * incorrectly false. This is mitigated via the canonical URL, but that MUST output, thus overriding otherwise chosen * and expected behavior. * * Example 2: `/page/2/?p=nonnumeric` will cause a bigger issue. What happens is that `is_home` will again be true, * but so will `is_paged`. `paged` will be set to `2` (as per example URL). The page ID will again be set to `0`, * which is completely false. The canonical URL will be malformed. Even moreso, Google can ignore the canonical URL, * so we MUST output noindex. * * Example 3: `/page/2/?X=nonnumeric` will also cause the same issues as in example 2. Where X can be: * `page_id`, `attachment_id`, `year`, `monthnum`, `day`, `w`, `m`, and of course `p`. * * Example 4: `/?hour=nonnumeric`, the same issue as Example 1. The canonical URL is malformed, noindex is set, and * link relationships will be active. A complete mess. `minute` and `second` are also affected the same way. * * Example 5: `/page/2/?p=0`, this is the trickiest. It's indicative of a paginated blog, but also the homepage. When * the homepage is not a blog, then this query is malformed. Otherwise, however, it's a good query. * * @since 4.0.5 * @since 4.2.7 1. Added detection `not_home_as_page`, specifically for query variable `search`. * 2. Improved detection for `cat` and `author`, where the value may only be numeric above 0. * @since 4.2.8 Now blocks any publicly registered variable requested to the home-as-page. * @global \WP_Query $wp_query * * @return bool Whether the query is (accidentally) exploited. * Defaults to false when `advanced_query_protection` option is disabled. * False when there's a query-ID found. * False when no custom query is set (for the homepage). * Otherwise, it performs query tests. */ public function is_query_exploited() { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo() ) return $memo; if ( ! $this->get_option( 'advanced_query_protection' ) ) return memo( false ); // When the page ID is not 0, a real page will always be returned. if ( $this->get_the_real_ID() ) return memo( false ); global $wp_query; // When no special query data is registered, ignore this. Don't set cache. if ( ! isset( $wp_query->query ) ) return false; /** * @since 4.0.5 * @param array $exploitables The exploitable endpoints by type. * @since 4.2.7 Added index `not_home_as_page` with value `search`. */ $exploitables = \apply_filters( 'the_seo_framework_exploitable_query_endpoints', [ 'numeric' => [ 'page_id', 'attachment_id', 'year', 'monthnum', 'day', 'w', 'm', 'p', 'paged', // 'page' is mitigated by WordPress. 'hour', 'minute', 'second', 'subpost_id', ], 'numeric_array' => [ 'cat', 'author', ], 'requires_s' => [ 'sentence', ], // When the blog (home) is a page then these requests to any registered query variable will cause issues, // but only when the page ID returns 0. (We already tested for `if ( $this->get_the_real_ID() )` above). // This global's property is only populated with requested parameters that match registered `public_query_vars`. // TODO: We only need one to pass this test. We could use array_key_first()... (PHP7.3+) -> Might be mixed. 'not_home_as_page' => array_keys( $GLOBALS['wp']->query_vars ?? [] ), ] ); $query = $wp_query->query; foreach ( $exploitables as $type => $qvs ) : foreach ( $qvs as $qv ) : // Only test isset, because falsey or empty-array is what we need to test against. if ( ! isset( $query[ $qv ] ) ) continue; switch ( $type ) : case 'numeric': if ( '0' === $query[ $qv ] || ! is_numeric( $query[ $qv ] ) ) return memo( true ); break; case 'numeric_array': // We can't protect non-pretty permalinks. if ( ! $this->pretty_permalinks ) break; // If WordPress didn't canonical_redirect() the user yet, it's exploited. // WordPress mitigates this via a 404 query when a numeric value is found. if ( ! preg_match( '/^[1-9][0-9]*$/', $query[ $qv ] ) ) return memo( true ); break; case 'requires_s': if ( ! isset( $query['s'] ) ) return memo( true ); break; case 'not_home_as_page': // isset($query[$qv]) is already executed. Just test if homepage ID still works. // !$this->get_the_real_ID() is already executed. Just test if home is a page. if ( $this->is_home_as_page() ) return memo( true ); break; default: break; endswitch; endforeach; endforeach; return memo( false ); } /** * Tests if the post type archive of said post type contains public posts. * Memoizes the return value. * * @since 4.2.0 * @slow The queried result is not stored in WP Post's cache, which would allow * direct access to all values of the post (if requested). This is because * we're using `'fields' => 'ids'` instead of `'fields' => 'all'`. * * @param string $post_type The post type to test. * @return bool True if a post is found in the archive, false otherwise. */ public function has_posts_in_post_type_archive( $post_type ) { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo( null, $post_type ) ) return $memo; $query = new \WP_Query( [ 'posts_per_page' => 1, 'post_type' => [ $post_type ], 'orderby' => 'date', 'order' => 'ASC', 'post_status' => 'publish', 'has_password' => false, 'fields' => 'ids', 'cache_results' => false, 'no_found_rows' => true, ] ); return memo( ! empty( $query->posts ), $post_type ); } /** * Detects if the current or inputted post type is supported and not disabled. * * @since 3.1.0 * @since 4.0.5 The `$post_type` fallback now uses a real query ID, instead of `$GLOBALS['post']`; * mitigating issues with singular-archives pages (blog, shop, etc.). * * @param string $post_type Optional. The post type to check. * @return bool */ public function is_post_type_supported( $post_type = '' ) { $post_type = $post_type ?: $this->get_current_post_type(); /** * @since 2.6.2 * @since 3.1.0 The first parameter is always a boolean now. * @param bool $supported Whether the post type is supported. * @param string $post_type_evaluated The evaluated post type. */ return (bool) \apply_filters_ref_array( 'the_seo_framework_supported_post_type', [ $post_type && ! $this->is_post_type_disabled( $post_type ) && \in_array( $post_type, $this->get_public_post_types(), true ), $post_type, ] ); } /** * Detects if the current or inputted post type's archive is supported and not disabled. * * @since 4.2.8 * @uses `tsf()->is_post_type_supported()` * * @param string $post_type Optional. The post type's archive to check. * @return bool */ public function is_post_type_archive_supported( $post_type = '' ) { $post_type = $post_type ?: $this->get_current_post_type(); /** * @since 4.2.8 * @param bool $supported Whether the post type archive is supported. * @param string $post_type_evaluated The evaluated post type. */ return (bool) \apply_filters_ref_array( 'the_seo_framework_supported_post_type_archive', [ $post_type && $this->is_post_type_supported( $post_type ) && \in_array( $post_type, $this->get_public_post_type_archives(), true ), $post_type, ] ); } /** * Determines if the taxonomy supports The SEO Framework. * * Checks if at least one taxonomy objects post type supports The SEO Framework, * and wether the taxonomy is public and rewritable. * * @since 4.0.0 * * @param string $taxonomy Optional. The taxonomy name. * @return bool True if at least one post type in taxonomy isn't disabled. */ public function is_taxonomy_supported( $taxonomy = '' ) { $taxonomy = $taxonomy ?: $this->get_current_taxonomy(); /** * @since 3.1.0 * @since 4.0.0 Now returns only returns false when all post types in the taxonomy aren't supported. * @param bool $post_type Whether the post type is supported * @param string $post_type_evaluated The evaluated post type. */ return (bool) \apply_filters_ref_array( 'the_seo_framework_supported_taxonomy', [ $taxonomy && ! $this->is_taxonomy_disabled( $taxonomy ) && \in_array( $taxonomy, $this->get_public_taxonomies(), true ), $taxonomy, ] ); } /** * Checks (current) Post Type for having taxonomical archives. * Memoizes the return value for the input argument. * * @since 2.9.3 * @since 4.0.5 The `$post_type` fallback now uses a real query ID, instead of `$GLOBALS['post']`; * mitigating issues with singular-archives pages (blog, shop, etc.). * @global \WP_Screen $current_screen * * @param string $post_type Optional. The post type to check. * @return bool True when the post type has taxonomies. */ public function post_type_supports_taxonomies( $post_type = '' ) { // phpcs:ignore, WordPress.CodeAnalysis.AssignmentInCondition -- I know. if ( null !== $memo = memo( null, $post_type ) ) return $memo; $post_type = $post_type ?: $this->get_current_post_type(); // Return false if no post type if found -- do not memo that, for query call might be too early. return $post_type && memo( (bool) \get_object_taxonomies( $post_type, 'names' ), $post_type ); } /** * Returns a list of all supported post types with archives. * Memoizes the return value. * * @since 4.2.0 * @since 4.2.8 Now filters via `tsf()->is_post_type_archive_supported()`. * * @return string[] Supported post types with post type archive support. */ public function get_supported_post_type_archives() { return memo() ?? memo( array_values( array_filter( $this->get_public_post_type_archives(), [ $this, 'is_post_type_archive_supported' ] ) ) ); } /** * Gets all post types that have PTA and could possibly support SEO. * Memoizes the return value. * * @since 4.2.0 * @since 4.2.8 Added filter `the_seo_framework_public_post_type_archives`. * * @return string[] Public post types with post type archive support. */ public function get_public_post_type_archives() { return umemo( __METHOD__ ) ?? umemo( __METHOD__, /** * Do not consider using this filter. Properly register your post type, noob. * * @since 4.2.8 * @param string[] $post_types The public post types. */ \apply_filters( 'the_seo_framework_public_post_type_archives', array_values( array_filter( $this->get_public_post_types(), static function( $post_type ) { return \get_post_type_object( $post_type )->has_archive ?? false; } ) ) ) ); } /** * Returns a list of all supported post types. * * @since 3.1.0 * * @return string[] All supported post types. */ public function get_supported_post_types() { return memo() ?? memo( array_values( array_filter( $this->get_public_post_types(), [ $this, 'is_post_type_supported' ] ) ) ); } /** * Gets all post types that could possibly support SEO. * Memoizes the return value. * * @since 4.1.0 * @since 4.1.4 Now resets the index keys of the return value. * * @return string[] All public post types. */ protected function get_public_post_types() { return umemo( __METHOD__ ) ?? umemo( __METHOD__, /** * Do not consider using this filter. Properly register your post type, noob. * * @since 4.2.0 * @param string[] $post_types The public post types. */ \apply_filters( 'the_seo_framework_public_post_types', array_values( array_filter( array_unique( array_merge( $this->get_forced_supported_post_types(), // array_keys() because get_post_types() gives a sequential array. array_keys( (array) \get_post_types( [ 'public' => true ] ) ) ) ), 'is_post_type_viewable' ) ) ) ); } /** * Returns a list of builtin public post types. * * @since 3.1.0 * @since 4.2.0 Removed memoization. * * @return string[] Forced supported post types. */ protected function get_forced_supported_post_types() { /** * @since 3.1.0 * @param string[] $forced Forced supported post types */ return (array) \apply_filters_ref_array( 'the_seo_framework_forced_supported_post_types', [ array_values( \get_post_types( [ 'public' => true, '_builtin' => true, ] ) ), ] ); } /** * Returns a list of all supported taxonomies. * * @since 4.2.0 * * @return string[] All supported taxonomies. */ public function get_supported_taxonomies() { return memo() ?? memo( array_values( array_filter( $this->get_public_taxonomies(), [ $this, 'is_taxonomy_supported' ] ) ) ); } /** * Gets all taxonomies that could possibly support SEO. * Memoizes the return value. * * @since 4.1.0 * * @return string[] The taxonomies that are public. */ protected function get_public_taxonomies() { return umemo( __METHOD__ ) ?? umemo( __METHOD__, /** * Do not consider using this filter. Properly register your taxonomy, noob. * * @since 4.2.0 * @param string[] $post_types The public post types. */ \apply_filters( 'the_seo_framework_public_taxonomies', array_filter( array_unique( array_merge( $this->get_forced_supported_taxonomies(), // array_values() because get_taxonomies() gives a sequential array. array_values( \get_taxonomies( [ 'public' => true, '_builtin' => false, ] ) ) ) ), 'is_taxonomy_viewable' ) ) ); } /** * Returns a list of builtin public taxonomies. * * @since 4.1.0 * @since 4.2.0 Removed memoization. * * @return string[] Forced supported taxonomies */ protected function get_forced_supported_taxonomies() { /** * @since 4.1.0 * @param string[] $forced Forced supported post types */ return (array) \apply_filters_ref_array( 'the_seo_framework_forced_supported_taxonomies', [ array_values( \get_taxonomies( [ 'public' => true, '_builtin' => true, ] ) ), ] ); } /** * Determines if the post type is disabled from SEO all optimization. * * @since 3.1.0 * @since 3.1.2 Now is fiterable. * @since 4.0.5 The `$post_type` fallback now uses a real query ID, instead of `$GLOBALS['post']`; * mitigating issues with singular-archives pages (blog, shop, etc.). * * @param string $post_type Optional. The post type to check. * @return bool True if disabled, false otherwise. */ public function is_post_type_disabled( $post_type = '' ) { $post_type = $post_type ?: $this->get_current_post_type(); /** * @since 3.1.2 * @param bool $disabled * @param string $post_type */ return \apply_filters_ref_array( 'the_seo_framework_post_type_disabled', [ isset( $this->get_option( 'disabled_post_types' )[ $post_type ] ), $post_type, ] ); } /** * Checks if the taxonomy isn't disabled, and that at least one taxonomy * objects post type supports The SEO Framework. * * @since 3.1.0 * @since 4.0.0 1. Now returns true if at least one post type for the taxonomy is supported. * 2. Now uses `is_post_type_supported()` instead of `is_post_type_disabled()`. * @since 4.1.0 1. Now also checks for the option `disabled_taxonomies`. * 2. Now applies filters `the_seo_framework_taxonomy_disabled`. * * @param string $taxonomy The taxonomy name. * @return bool True if at least one post type in taxonomy is supported. */ public function is_taxonomy_disabled( $taxonomy = '' ) { $disabled = false; // First, test pertaining option directly. if ( $taxonomy && isset( $this->get_option( 'disabled_taxonomies' )[ $taxonomy ] ) ) { $disabled = true; } else { // Then, test some() post types. // Populate $disabled within loop, for the taxonomy might not have post types at all. foreach ( $this->get_post_types_from_taxonomy( $taxonomy ) as $type ) { if ( $this->is_post_type_supported( $type ) ) { $disabled = false; break; } $disabled = true; } } /** * @since 4.1.0 * @param bool $disabled * @param string $taxonomy */ return \apply_filters_ref_array( 'the_seo_framework_taxonomy_disabled', [ $disabled, $taxonomy, ] ); } /** * Determines whether a page or blog is on front. * * @since 2.6.0 * @since 3.1.0 Removed caching. * * @return bool */ public function has_page_on_front() { return 'page' === \get_option( 'show_on_front' ); } /** * Detects if we're on a Gutenberg page. * * @since 3.1.0 * @since 3.2.0 1. Now detects the WP 5.0 block editor. * 2. Method is now public. * * @return bool */ public function is_gutenberg_page() { if ( \function_exists( '\\use_block_editor_for_post' ) ) return ! empty( $GLOBALS['post'] ) && \use_block_editor_for_post( $GLOBALS['post'] ); if ( \function_exists( '\\is_gutenberg_page' ) ) return \is_gutenberg_page(); return false; } /** * Determines whether we can output sitemap or not based on options and blog status. * * @since 2.6.0 * @since 2.9.2 No longer checks for plain and ugly permalinks. * @since 4.0.0 Removed caching. * * @return bool */ public function can_run_sitemap() { return $this->get_option( 'sitemaps_output' ) && ! $this->current_blog_is_spam_or_deleted(); } /** * Returns the robots.txt location URL. * Only allows root domains. * * @since 2.9.2 * @since 4.0.2 Now uses the preferred URL scheme. * @global \WP_Rewrite $wp_rewrite * * @return string URL location of robots.txt. Unescaped. */ public function get_robots_txt_url() { if ( $GLOBALS['wp_rewrite']->using_permalinks() && ! $this->is_subdirectory_installation() ) { $home = \trailingslashit( $this->set_preferred_url_scheme( $this->get_home_host() ) ); $path = "{$home}robots.txt"; } elseif ( $this->has_robots_txt() ) { $home = \trailingslashit( $this->set_preferred_url_scheme( \get_option( 'home' ) ) ); $path = "{$home}robots.txt"; } else { $path = ''; } return $path; } /** * Determines if the current installation is on a subdirectory. * Memoizes the return value. * * @since 2.9.0 * * @return bool */ public function is_subdirectory_installation() { return memo() ?? memo( (bool) \strlen( ltrim( parse_url( \get_option( 'home' ), PHP_URL_PATH ) ?? '', ' \\/' ) ) ); } /** * Determines whether the text has recognizable transformative syntax. * * It tests Yoast SEO before Rank Math because that one is more popular, thus more * likely to yield a result. * * @todo test all [ 'extension', 'yoast', 'aioseo', 'rankmath', 'seopress' ] * @since 4.2.7 * @since 4.2.8 Added SEOPress support. * * @param string $text The text to evaluate * @return bool */ public function has_unprocessed_syntax( $text ) { foreach ( [ 'yoast', 'rankmath', 'seopress' ] as $type ) if ( $this->{"has_{$type}_syntax"}( $text ) ) return true; return false; } /** * Determines if the input text has transformative Yoast SEO syntax. * * TODO rename to yoast_seo? * * @since 4.0.5 * @since 4.2.7 1. Added wildcard `ct_`, and `cf_` detection. * 2. Added detection for various other types * 2. Removed wildcard `cs_` detection. * @see $this->has_unprocessed_syntax(), the caller. * @link <https://yoast.com/help/list-available-snippet-variables-yoast-seo/> (This list containts false information) * @link <https://theseoframework.com/extensions/transport/#faq/what-data-is-transformed> * * @param string $text The text to evaluate. * @return bool */ public function has_yoast_syntax( $text ) { // %%id%% is the shortest valid tag... ish. Let's stop at 6. if ( \strlen( $text ) < 6 || false === strpos( $text, '%%' ) ) return false; $tags = umemo( __METHOD__ . '/tags' ); if ( ! $tags ) { $tags = umemo( __METHOD__ . '/tags', [ 'simple' => implode( '|', [ // These are Preserved by Transport. Test first, for they are more likely in text. 'focuskw', 'page', 'pagenumber', 'pagetotal', 'primary_category', 'searchphrase', 'term404', 'wc_brand', 'wc_price', 'wc_shortdesc', 'wc_sku', // These are transformed by Transport 'archive_title', 'author_first_name', 'author_last_name', 'caption', 'category', 'category_description', 'category_title', 'currentdate', 'currentday', 'currentmonth', 'currentyear', 'date', 'excerpt', 'excerpt_only', 'id', 'modified', 'name', 'parent_title', 'permalink', 'post_content', 'post_year', 'post_month', 'post_day', 'pt_plural', 'pt_single', 'sep', 'sitedesc', 'sitename', 'tag', 'tag_description', 'term_description', 'term_title', 'title', 'user_description', 'userid', ] ), 'wildcard_end' => implode( '|', [ 'ct_', 'cf_' ] ), ] ); } return preg_match( "/%%(?:{$tags['simple']})%%/", $text ) || preg_match( "/%%(?:{$tags['wildcard_end']})[^%]+?%%/", $text ); } /** * Determines if the input text has transformative Rank Math syntax. * * @since 4.2.7 * @since 4.2.8 Actualized the variable list. * @link <https://theseoframework.com/extensions/transport/#faq/what-data-is-transformed> * Rank Math has no documentation on this list, but we sampled their code. * @see $this->has_unprocessed_syntax(), the caller. * * @param string $text The text to evaluate. * @return bool */ public function has_rankmath_syntax( $text ) { // %id% is the shortest valid tag... ish. Let's stop at 4. if ( \strlen( $text ) < 4 || false === strpos( $text, '%' ) ) return false; $tags = umemo( __METHOD__ . '/tags' ); if ( ! $tags ) { $tags = umemo( __METHOD__ . '/tags', [ 'simple' => implode( '|', [ // These are Preserved by Transport. Test first, for they are more likely in text. 'currenttime', // Rank Math has two currenttime, this one is simple. 'filename', 'focuskw', 'group_desc', 'group_name', 'keywords', 'org_name', 'org_logo', 'org_url', 'page', 'pagenumber', 'pagetotal', 'post_thumbnail', 'primary_category', 'primary_taxonomy_terms', 'url', 'wc_brand', 'wc_price', 'wc_shortdesc', 'wc_sku', 'currenttime', // Rank Math has two currenttime, this one is simple. // These are transformed by Transport 'category', 'categories', 'currentdate', 'currentday', 'currentmonth', 'currentyear', 'date', 'excerpt', 'excerpt_only', 'id', 'modified', 'name', 'parent_title', 'post_author', 'pt_plural', 'pt_single', 'seo_title', 'seo_description', 'sep', 'sitedesc', 'sitename', 'tag', 'tags', 'term', 'term_description', 'title', 'user_description', 'userid', ] ), // Check out for ref RankMath\Replace_Variables\Replacer::set_up_replacements(); 'wildcard_end' => implode( '|', [ 'categories', 'count', 'currenttime', 'customfield', 'customterm', 'customterm_desc', 'date', 'modified', 'tags', ] ), ] ); } return preg_match( "/%(?:{$tags['simple']})%/", $text ) || preg_match( "/%(?:{$tags['wildcard_end']})\([^\)]+?\)%/", $text ); } /** * Determines if the input text has transformative SEOPress syntax. * * @since 4.2.8 * @link <https://theseoframework.com/extensions/transport/#faq/what-data-is-transformed> * SEOPress has no documentation on this list, but we sampled their code. * @see $this->has_unprocessed_syntax(), the caller. * * @param string $text The text to evaluate. * @return bool */ public function has_seopress_syntax( $text ) { // %%sep%% is the shortest valid tag... ish. Let's stop at 7. if ( \strlen( $text ) < 7 || false === strpos( $text, '%%' ) ) return false; $tags = umemo( __METHOD__ . '/tags' ); if ( ! $tags ) { $tags = umemo( __METHOD__ . '/tags', [ 'simple' => implode( '|', [ // These are Preserved by Transport. Test first, for they are more likely in text. 'author_website', 'current_pagination', 'currenttime', 'post_thumbnail_url', 'post_url', 'target_keyword', 'wc_single_price', 'wc_single_price_exc_tax', 'wc_sku', // These are transformed by Transport '_category_description', '_category_title', 'archive_title', 'author_bio', 'author_first_name', 'author_last_name', 'author_nickname', 'currentday', 'currentmonth', 'currentmonth_num', 'currentmonth_short', 'currentyear', 'date', 'excerpt', 'post_author', 'post_category', 'post_content', 'post_date', 'post_excerpt', 'post_modified_date', 'post_tag', 'post_title', 'sep', 'sitedesc', 'sitename', 'sitetitle', 'tag_description', 'tag_title', 'tagline', 'term_description', 'term_title', 'title', 'wc_single_cat', 'wc_single_short_desc', 'wc_single_tag', ] ), // Check out for ref somewhere in SEOPress, seopress_get_dyn_variables() is one I guess. 'wildcard_end' => implode( '|', [ '_cf_', '_ct_', '_ucf_', ] ), ] ); } return preg_match( "/%%(?:{$tags['simple']})%%/", $text ) || preg_match( "/%%(?:{$tags['wildcard_end']})[^%]+?%%/", $text ); } }