← All changes | includes/Core/Request.php +293 -3 4.5.4 → 4.9.2 View file →

		@@ -1,9 +1,14 @@
1	1	<?php
	2	+namespace WPDeveloper\BetterDocs\Core;
2	3
3		-namespace WPDeveloper\BetterDocs\Core;
	4	+if ( ! defined( 'ABSPATH' ) ) {
	5	+ exit;
	6	+}
4	7
	8	+
5	9	use WPDeveloper\BetterDocs\Utils\Base;
	10	+use WPDeveloper\BetterDocs\Utils\Helper;
6	11
7	12	class Request extends Base {
8	13	/**
9	14	* Flag for already parsed or not
		@@ -147,8 +152,15 @@
147	152	* Hook into template_redirect to validate category-post relationships
148	153	* Priority 0 to run before WordPress canonical redirect (priority 10)
149	154	*/
150	155	add_action( 'template_redirect', [ $this, 'validate_single_docs_category_redirect' ], 0 );
	156	+
	157	+ /**
	158	+ * Hook into template_redirect to 301 non-canonical single doc URLs.
	159	+ * Priority 5: after the validation above (0) so requests already headed for
	160	+ * a 404 are left alone, and before WordPress canonical redirect (10).
	161	+ */
	162	+ add_action( 'template_redirect', [ $this, 'redirect_to_canonical_docs_url' ], 5 );
151	163	}
152	164
153	165	public function provide_compatibility( $element_id, $uri_parts, $request_url ) {
154	166	if ( $request_url == $this->settings->get( 'docs_slug' ) ) {
		@@ -215,9 +227,9 @@
215	227	if ( $this->invalid_request_query_vars !== null ) {
216	228	return false; // Block the redirect, show 404 instead
217	229	}
218	230
219		- $actual_url = home_url( $_SERVER['REQUEST_URI'] ?? '' );
	231	+ $actual_url = home_url( isset( $_SERVER['REQUEST_URI'] ) ? esc_url_raw( wp_unslash( $_SERVER['REQUEST_URI'] ) ) : '' );
220	232
221	233	// Legacy check: if post_type=docs is already set in query vars, validate category
222	234	if ( isset( $wp_query->query_vars['post_type'] ) && $wp_query->query_vars['post_type'] === 'docs' &&
223	235	isset( $wp_query->query_vars['doc_category'] ) && isset( $wp_query->query_vars['name'] ) ) {
		@@ -390,8 +402,225 @@
390	402	}
391	403	}
392	404
393	405	/**
	406	+ * 301 redirect a single doc to its canonical permalink.
	407	+ *
	408	+ * With `enable_category_hierarchy_slugs` enabled the single doc rewrite rule
	409	+ * captures every segment between the base and the doc slug into `doc_category`
	410	+ * (see Rewrite::rules), and the category validation above only requires ONE of
	411	+ * those segments to match. That looseness is deliberate — a strict match would
	412	+ * 404 legitimate Multiple KB and WPML URLs, where the KB slug and translated
	413	+ * segments share the same capture group — but it also means a doc resolves on an
	414	+ * unlimited number of URLs, e.g. /docs/anything/real-category/doc-slug/.
	415	+ *
	416	+ * Rather than tightening the match, this compares the requested category path
	417	+ * against every path the doc legitimately has and redirects the rest. Every URL
	418	+ * that resolves today keeps resolving; only the extra ones collapse.
	419	+ */
	420	+ public function redirect_to_canonical_docs_url() {
	421	+ global $wp_query;
	422	+
	423	+ /**
	424	+ * Allow the canonical redirect to be disabled.
	425	+ *
	426	+ * @param bool $enabled Whether non-canonical single doc URLs should 301.
	427	+ */
	428	+ if ( ! apply_filters( 'betterdocs_enable_canonical_redirect', true ) ) {
	429	+ return;
	430	+ }
	431	+
	432	+ if ( is_admin() || wp_doing_ajax() || is_feed() || is_embed() || is_preview() || is_customize_preview() ) {
	433	+ return;
	434	+ }
	435	+
	436	+ $request_method = isset( $_SERVER['REQUEST_METHOD'] ) ? strtoupper( sanitize_text_field( wp_unslash( $_SERVER['REQUEST_METHOD'] ) ) ) : 'GET';
	437	+ if ( $request_method !== 'GET' ) {
	438	+ return;
	439	+ }
	440	+
	441	+ if ( ! is_singular( 'docs' ) || is_404() ) {
	442	+ return;
	443	+ }
	444	+
	445	+ /**
	446	+ * The request is already headed for a 404 — leave it alone. Note that
	447	+ * prevent_any_redirect_for_invalid_docs() cancels every wp_redirect() while
	448	+ * this flag is set, so the redirect below would be swallowed anyway.
	449	+ */
	450	+ if ( $this->invalid_request_query_vars !== null ) {
	451	+ return;
	452	+ }
	453	+
	454	+ $requested_category = isset( $wp_query->query_vars['doc_category'] ) ? $wp_query->query_vars['doc_category'] : '';
	455	+ if ( ! is_string( $requested_category ) || $requested_category === '' ) {
	456	+ return;
	457	+ }
	458	+
	459	+ $post_id = get_queried_object_id();
	460	+ if ( ! $post_id ) {
	461	+ return;
	462	+ }
	463	+
	464	+ $valid_paths = $this->get_valid_category_paths( $post_id );
	465	+ if ( empty( $valid_paths ) ) {
	466	+ return;
	467	+ }
	468	+
	469	+ $requested_category = urldecode( trim( $requested_category, '/' ) );
	470	+
	471	+ /**
	472	+ * Under Multiple KB the knowledge base segment is parsed into its own query
	473	+ * var, so put it back in front of the category chain before comparing —
	474	+ * otherwise a crossed `/kb-a/category-of-kb-b/doc/` would look canonical.
	475	+ */
	476	+ $requested_kb = isset( $wp_query->query_vars['knowledge_base'] ) ? $wp_query->query_vars['knowledge_base'] : '';
	477	+ if ( is_string( $requested_kb ) && $requested_kb !== '' ) {
	478	+ $requested_category = urldecode( trim( $requested_kb, '/' ) ) . '/' . $requested_category;
	479	+ }
	480	+
	481	+ if ( in_array( $requested_category, $valid_paths, true ) ) {
	482	+ return; // Already canonical (or another legitimate category of this doc).
	483	+ }
	484	+
	485	+ $canonical = get_permalink( $post_id );
	486	+ if ( ! $canonical ) {
	487	+ return;
	488	+ }
	489	+
	490	+ // Keep the multipage segment the rewrite rule captured.
	491	+ $page = isset( $wp_query->query_vars['page'] ) ? absint( $wp_query->query_vars['page'] ) : 0;
	492	+ if ( $page > 1 ) {
	493	+ $canonical = trailingslashit( $canonical ) . user_trailingslashit( $page, 'single_paged' );
	494	+ }
	495	+
	496	+ /**
	497	+ * Belt and braces: never redirect a URL onto itself. The allowed set is built
	498	+ * from the same term chains get_permalink() uses, so this should be
	499	+ * unreachable, but a third party filtering the permalink could otherwise turn
	500	+ * a redirect into a loop.
	501	+ */
	502	+ $requested_path = isset( $_SERVER['REQUEST_URI'] ) ? wp_parse_url( wp_unslash( $_SERVER['REQUEST_URI'] ), PHP_URL_PATH ) : '';
	503	+ $canonical_path = wp_parse_url( $canonical, PHP_URL_PATH );
	504	+ if ( untrailingslashit( urldecode( (string) $requested_path ) ) === untrailingslashit( urldecode( (string) $canonical_path ) ) ) {
	505	+ return;
	506	+ }
	507	+
	508	+ $query_string = isset( $_SERVER['QUERY_STRING'] ) ? sanitize_text_field( wp_unslash( $_SERVER['QUERY_STRING'] ) ) : '';
	509	+ if ( $query_string !== '' ) {
	510	+ $canonical .= ( strpos( $canonical, '?' ) === false ? '?' : '&' ) . $query_string;
	511	+ }
	512	+
	513	+ if ( wp_safe_redirect( $canonical, 301 ) ) {
	514	+ exit;
	515	+ }
	516	+ }
	517	+
	518	+ /**
	519	+ * Every category path a doc can legitimately be reached at.
	520	+ *
	521	+ * Includes the full parent/child chain of each assigned category, and — because
	522	+ * the hierarchy rewrite rule folds the knowledge base slug into `doc_category`
	523	+ * for the `docs/%knowledge_base%/%doc_category%` structure — the KB-prefixed
	524	+ * variants too.
	525	+ *
	526	+ * @param int $post_id The doc id.
	527	+ * @return string[] Normalised (urldecoded, unslashed) category paths.
	528	+ */
	529	+ protected function get_valid_category_paths( $post_id ) {
	530	+ $cat_terms = wp_get_object_terms( $post_id, 'doc_category' );
	531	+
	532	+ if ( is_wp_error( $cat_terms ) ) {
	533	+ return [];
	534	+ }
	535	+
	536	+ $paths = [];
	537	+ $cat_paths = [];
	538	+
	539	+ if ( empty( $cat_terms ) ) {
	540	+ $paths[] = 'uncategorized';
	541	+ } else {
	542	+ foreach ( $cat_terms as $cat_term ) {
	543	+ $path = PostType::build_category_path( $cat_term );
	544	+
	545	+ if ( $path !== '' ) {
	546	+ $paths[] = $path;
	547	+ $cat_paths[ $cat_term->term_id ] = $path;
	548	+ }
	549	+ }
	550	+ }
	551	+
	552	+ if ( taxonomy_exists( 'knowledge_base' ) ) {
	553	+ $kb_terms = wp_get_object_terms( $post_id, 'knowledge_base', [ 'fields' => 'slugs' ] );
	554	+
	555	+ if ( ! is_wp_error( $kb_terms ) && ! empty( $kb_terms ) ) {
	556	+ $kb_paths = [];
	557	+
	558	+ /**
	559	+ * Read the KB association once per category rather than once per
	560	+ * KB/category pair. The wp_get_object_terms() call above primes the
	561	+ * term meta cache for these terms (`update_term_meta_cache` defaults
	562	+ * to true), so these reads are cache hits and add no queries.
	563	+ *
	564	+ * The association mirrors how PostType::post_link() picks the
	565	+ * category via `doc_category_knowledge_base`. Without it a doc in
	566	+ * KB A / category A and KB B / category B would treat the crossed
	567	+ * `/kb-a/category-b/doc/` as canonical. A term with no association
	568	+ * meta is unassigned rather than KB specific, so it stays valid
	569	+ * under every KB — post_link() falls back the same way.
	570	+ */
	571	+ $term_kbs = [];
	572	+
	573	+ if ( ! empty( $cat_paths ) ) {
	574	+ foreach ( array_keys( $cat_paths ) as $term_id ) {
	575	+ $meta = get_term_meta( $term_id, 'doc_category_knowledge_base', true );
	576	+ $term_kbs[ $term_id ] = ( ! empty( $meta ) && is_array( $meta ) ) ? $meta : null;
	577	+ }
	578	+ }
	579	+
	580	+ foreach ( $kb_terms as $kb_slug ) {
	581	+ if ( empty( $cat_paths ) ) {
	582	+ // Uncategorised doc: the KB slug is the only prefix there is.
	583	+ foreach ( $paths as $path ) {
	584	+ $kb_paths[] = $kb_slug . '/' . $path;
	585	+ }
	586	+ continue;
	587	+ }
	588	+
	589	+ foreach ( $cat_paths as $term_id => $path ) {
	590	+ if ( $term_kbs[ $term_id ] !== null && ! in_array( $kb_slug, $term_kbs[ $term_id ], true ) ) {
	591	+ continue;
	592	+ }
	593	+
	594	+ $kb_paths[] = $kb_slug . '/' . $path;
	595	+ }
	596	+ }
	597	+
	598	+ $paths = array_merge( $paths, $kb_paths );
	599	+ }
	600	+ }
	601	+
	602	+ /**
	603	+ * Non-Latin slugs are stored URL encoded while the requested path arrives
	604	+ * decoded, so normalise both sides before comparing.
	605	+ */
	606	+ $paths = array_map(
	607	+ function ( $path ) {
	608	+ return urldecode( trim( $path, '/' ) );
	609	+ },
	610	+ $paths
	611	+ );
	612	+
	613	+ /**
	614	+ * Filter the category paths a doc is allowed to be reached at.
	615	+ *
	616	+ * @param string[] $paths Valid category paths.
	617	+ * @param int $post_id The doc id.
	618	+ */
	619	+ return array_values( array_unique( apply_filters( 'betterdocs_valid_docs_category_paths', $paths, $post_id ) ) );
	620	+ }
	621	+
	622	+ /**
394	623	* Check if a URL matches a BetterDocs single docs permalink structure
395	624	* but has invalid KB/category slugs that don't match the post.
396	625	*
397	626	* @param string $url The URL to check.
		@@ -398,9 +627,9 @@
398	627	* @return bool True if the URL is a BetterDocs docs URL with invalid slugs.
399	628	*/
400	629	protected function is_invalid_docs_url( $url ) {
401	630	// Get the path from the URL
402		- $path = trim( parse_url( $url, PHP_URL_PATH ), '/' );
	631	+ $path = trim( (string) wp_parse_url( $url, PHP_URL_PATH ), '/' );
403	632
404	633	// Check each permalink structure
405	634	foreach ( $this->perma_structure as $_type => $structure ) {
406	635	if ( $_type !== 'is_single_docs' ) {
		@@ -648,8 +877,9 @@
648	877
649	878	// Belt-and-suspenders for WPML's slug-translation feature, which may store
650	879	// the translated slug separately from the post type's rewrite['slug'].
651	880	if ( has_filter( 'wpml_get_translated_slug' ) ) {
	881	+ // phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- WPML-owned filter; name must be used verbatim.
652	882	$wpml_slug = apply_filters( 'wpml_get_translated_slug', $docs_slug, 'docs' );
653	883	if ( is_string( $wpml_slug ) && $wpml_slug !== '' ) {
654	884	$valid_slugs[] = trim( $wpml_slug, '/' );
655	885	}
		@@ -962,8 +1192,9 @@
962	1192	if ( ! isset( $query_vars['name'] ) && ! isset( $query_vars['docs'] ) ) {
963	1193	return false;
964	1194	}
965	1195
	1196	+ // phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching -- frontend single-doc URL resolution; queries vary per request and run on `parse_request`, before object cache is reliable.
966	1197	global $wpdb;
967	1198	$name = isset( $query_vars['docs'] ) ? $query_vars['docs'] : $query_vars['name'];
968	1199
969	1200
		@@ -1398,8 +1629,9 @@
1398	1629	}
1399	1630	}
1400	1631
1401	1632	return $_post_id > 0;
	1633	+ // phpcs:enable WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching
1402	1634	}
1403	1635
1404	1636	protected function is_docs_category( $query_vars ) {
1405	1637	$result = $this->term_exists( $query_vars, 'doc_category' );
		@@ -1466,8 +1698,18 @@
1466	1698
1467	1699	public function parse( $wp ) {
1468	1700	static::$already_parsed = true;
1469	1701
	1702	+ // An API Reference rewrite rule already matched (/docs/api/{slug}).
	1703	+ // The permalink magic below re-interprets the raw path against the
	1704	+ // docs/category/KB structures and would hijack the request whenever a
	1705	+ // doc_category or knowledge_base term shares the reference's slug —
	1706	+ // an explicit CPT match always wins.
	1707	+ if ( isset( $wp->query_vars['betterdocs_api_ref'] ) ) {
	1708	+ return;
	1709	+ }
	1710	+
	1711	+ // phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- legacy public filter name, retained for back-compat with Pro/extensions.
1470	1712	$this->perma_structure = apply_filters('docs_rewrite_rules', $this->perma_structure);
1471	1713
1472	1714	$this->permalink_magic( $wp );
1473	1715	}
		@@ -1497,8 +1739,15 @@
1497	1739	// Strip optional language prefix injected by Polylang/WPML (e.g. "en/", "bn/", "pt-br/")
1498	1740	// so that "bn/docs/..." matches the structure "docs/..." correctly.
1499	1741	$request_without_lang = preg_replace( '#^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})?/#', '', $request );
1500	1742
	1743	+ // When WPML translates a taxonomy base slug per language (e.g. doc_tag
	1744	+ // "docs-tag" -> "docs-tag-bn"), the incoming URL uses the translated slug,
	1745	+ // but perma_structure is built from the default-language slug. Map the
	1746	+ // leading translated slug back to its default so the raw structures match.
	1747	+ // No-op on non-WPML sites and when the slug isn't translated.
	1748	+ $request_canonical = $this->canonicalize_translated_slug( $request_without_lang );
	1749	+
1501	1750	foreach ( $this->perma_structure as $_type => $structure ) {
1502	1751	// First try the raw (possibly language-prefixed) request, then the lang-stripped variant.
1503	1752	// This ensures we still match non-multilingual sites without stripping valid slugs.
1504	1753	$_perma_vars = $this->is_perma_valid_for( $structure, $request );
		@@ -1504,8 +1753,11 @@
1504	1753	$_perma_vars = $this->is_perma_valid_for( $structure, $request );
1505	1754	if ( ! $_perma_vars && $request_without_lang !== $request ) {
1506	1755	$_perma_vars = $this->is_perma_valid_for( $structure, $request_without_lang );
1507	1756	}
	1757	+ if ( ! $_perma_vars && $request_canonical !== $request_without_lang ) {
	1758	+ $_perma_vars = $this->is_perma_valid_for( $structure, $request_canonical );
	1759	+ }
1508	1760
1509	1761	// $_valid = empty( $_valid ) && $_perma_vars ? [ 'type' => $_type, 'query_vars' => $_perma_vars ] : $_valid;
1510	1762	if ( ( $_perma_vars && method_exists( $this, $_type ) && call_user_func_array( [$this, $_type], [ & $_perma_vars] ) ) ) {
1511	1763
		@@ -1553,8 +1805,46 @@
1553	1805	unset( $wp->query_vars['attachment'] );
1554	1806	}
1555	1807	}
1556	1808	}
	1809	+
	1810	+ /**
	1811	+ * Map a leading WPML-translated taxonomy base slug back to its default-language
	1812	+ * value so the default-language perma_structure patterns can match a translated URL.
	1813	+ *
	1814	+ * Only the first path segment is considered (the taxonomy base). Returns the
	1815	+ * request unchanged when WPML is inactive or the leading segment isn't a
	1816	+ * translated BetterDocs slug.
	1817	+ *
	1818	+ * @param string $request Language-stripped request path (no leading/trailing slash).
	1819	+ * @return string
	1820	+ */
	1821	+ private function canonicalize_translated_slug( $request ) {
	1822	+ if ( $request === '' || strpos( $request, '/' ) === false ) {
	1823	+ return $request;
	1824	+ }
	1825	+
	1826	+ $slug_map = [
	1827	+ 'doc_tag' => trim( $this->settings->get( 'tag_slug', 'docs-tag' ), '/' ),
	1828	+ 'doc_category' => trim( $this->settings->get( 'category_slug', 'docs-category' ), '/' ),
	1829	+ ];
	1830	+
	1831	+ $segments = explode( '/', $request );
	1832	+
	1833	+ foreach ( $slug_map as $taxonomy => $default ) {
	1834	+ if ( $default === '' ) {
	1835	+ continue;
	1836	+ }
	1837	+
	1838	+ $translated = Helper::wpml_translated_tax_slug( $taxonomy, $default );
	1839	+ if ( $translated !== $default && $segments[0] === $translated ) {
	1840	+ $segments[0] = $default;
	1841	+ return implode( '/', $segments );
	1842	+ }
	1843	+ }
	1844	+
	1845	+ return $request;
	1846	+ }
1557	1847
1558	1848	/**
1559	1849	* This method is responsible for checking a structure is valid again a request.
1560	1850	*