Changeset 35537 for trunk/src/wp-includes/class-wp-term.php

Timestamp:

11/05/2015 04:44:59 PM (9 years ago)

Author:

boonebgorges

Message:

Make get_term() behave more consistently in the context of shared terms.

When WP_Term was introduced in [34997], the $taxonomy parameter for
get_term() was made optional. This meant that, when the optional param was
omitted, get_term() had no way of determining which term was intended when
the term_id was shared between multiple taxonomies. As a (somewhat sneaky) way
of fixing things, get_term() split any shared terms it found. But this could
cause problems with developer expectations: it's not clear why requesting a
term should result in a database update, much less a potential change in the
ID of a term.

In place of this technique, this changeset introduces a number of changes that
make the handling of shared terms a bit less insane:

• When a taxonomy is provided to get_term(), and a cached term is found matching the term_id, make sure the taxonomy also matches before returning it.
• When a taxonomy is not provided, ensure that the term is not shared before adding it to the cache.
• When a term is shared between taxonomies and no taxonomy is provided, return a WP_Error rather than splitting the term.
• When a term is shared between taxonomies, only one of which is valid, return the term from that taxonomy.

Props boonebgorges, dlh.
Fixes #34533.

File:

• trunk/src/wp-includes/class-wp-term.php (modified) (2 diffs)

trunk/src/wp-includes/class-wp-term.php

@@ -116 +116 @@
      * @global wpdb $wpdb WordPress database abstraction object.
      *
-     * @param int $term_id Term ID.
-     * @return WP_Term|false Term object, false otherwise.
-     */
-    public static function get_instance( $term_id ) {
+     * @param int    $term_id  Term ID.
+     * @param string $taxonomy Optional. Limit matched terms to those matching `$taxonomy`. Only used for
+     *                         disambiguating potentially shared terms.
+     * @return WP_Term|WP_Error|false Term object, if found. WP_Error if `$term_id` is shared between taxonomies and
+     *                                there's insufficient data to distinguish which term is intended.
+     *                                False for other failures.
+     */
+    public static function get_instance( $term_id, $taxonomy = null ) {
         global $wpdb;
 
@@ -130 +134 @@
 
         // If there isn't a cached version, hit the database.
-        if ( ! $_term ) {
-            $_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE t.term_id = %d LIMIT 1", $term_id ) );
+        if ( ! $_term || ( $taxonomy && $taxonomy !== $_term->taxonomy ) ) {
+            // Grab all matching terms, in case any are shared between taxonomies.
+            $terms = $wpdb->get_results( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE t.term_id = %d", $term_id ) );
+            if ( ! $terms ) {
+                return false;
+            }
+
+            // If a taxonomy was specified, find a match.
+            if ( $taxonomy ) {
+                foreach ( $terms as $match ) {
+                    if ( $taxonomy === $match->taxonomy ) {
+                        $_term = $match;
+                        break;
+                    }
+                }
+
+            // If only one match was found, it's the one we want.
+            } elseif ( 1 === count( $terms ) ) {
+                $_term = reset( $terms );
+
+            // Otherwise, the term must be shared between taxonomies.
+            } else {
+                // If the term is shared only with invalid taxonomies, return the one valid term.
+                foreach ( $terms as $t ) {
+                    if ( ! taxonomy_exists( $t->taxonomy ) ) {
+                        continue;
+                    }
+
+                    // Only hit if we've already identified a term in a valid taxonomy.
+                    if ( $_term ) {
+                        return new WP_Error( 'ambiguous_term_id', __( 'Term ID is shared between multiple taxonomies' ), $term_id );
+                    }
+
+                    $_term = $t;
+                }
+            }
+
             if ( ! $_term ) {
                 return false;
             }
 
+            // Don't return terms from invalid taxonomies.
+            if ( ! taxonomy_exists( $_term->taxonomy ) ) {
+                return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) );
+            }
+
             $_term = sanitize_term( $_term, $_term->taxonomy, 'raw' );
-            wp_cache_add( $term_id, $_term, 'terms' );
+
+            // Don't cache terms that are shared between taxonomies.
+            if ( 1 === count( $terms ) ) {
+                wp_cache_add( $term_id, $_term, 'terms' );
+            }
         }