Changeset 30107

Timestamp:

10/30/2014 02:11:56 AM (12 years ago)

Author:

boonebgorges

Message:

In get_terms(), do not override 'hierarchical' and 'pad_counts' when 'parent' is present.

The previous behavior resulted in descendant terms being improperly excluded
from the results when passing a 'parent', even when 'hierarchical' had been
set to true.

The patch also adds unit tests that demonstrate the various interactions
between the 'child_of', 'parent', and 'hierarchical' parameters of get_terms().

Props landakram.
Fixes #29815.

Location:

trunk

Files:

• src/wp-includes/taxonomy.php (modified) (1 diff)
• tests/phpunit/tests/term/getTerms.php (modified) (2 diffs)

trunk/src/wp-includes/taxonomy.php

@@ -1629 +1629 @@
         $args['number'] = absint( $args['number'] );
         $args['offset'] = absint( $args['offset'] );
-        if ( !$single_taxonomy || ! is_taxonomy_hierarchical( reset( $taxonomies ) ) ||
-                ( '' !== $args['parent'] && 0 !== $args['parent'] ) ) {
-                $args['child_of'] = 0;
+
+        // Save queries by not crawling the tree in the case of multiple taxes or a flat tax.
+        if ( ! $single_taxonomy || ! is_taxonomy_hierarchical( reset( $taxonomies ) ) ) {
+                $args['child_of'] = false;
                 $args['hierarchical'] = false;
                 $args['pad_counts'] = false;
+        }
+
+        // 'parent' overrides 'child_of'.
+        if ( 0 < intval( $args['parent'] ) ) {
+                $args['child_of'] = false;
         }
 

trunk/tests/phpunit/tests/term/getTerms.php

@@ -821 +821 @@
         }
 
+        public function test_hierarchical_false_with_parent() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                // Case where hierarchical is false
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => false,
+                        'parent' => $initial_terms['one_term']['term_id']
+                ) );
+
+                // Verify that there are no children
+                $this->assertEquals( 0, count( $terms ) );
+        }
+
+        /**
+         * @ticket 29185
+         */
+        public function test_hierarchical_true_with_parent() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                // Case where hierarchical is true
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => true,
+                        'parent' => $initial_terms['one_term']['term_id']
+                ) );
+
+                // Verify that the children with non-empty descendants are returned
+                $expected = array(
+                        $initial_terms['two_term']['term_id'],
+                        $initial_terms['five_term']['term_id'],
+                );
+                $actual = wp_list_pluck( $terms, 'term_id' );
+                $this->assertEqualSets( $expected, $actual );
+        }
+
+        public function test_hierarchical_false_with_child_of_and_direct_child() {
+                $initial_terms = $this->create_hierarchical_terms();
+                $post_id = $this->factory->post->create();
+                wp_set_post_terms(
+                        $post_id,
+                        array( $initial_terms['seven_term']['term_id'] ),
+                        'category'
+                );
+
+                // Case where hierarchical is false
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => false,
+                        'child_of' => $initial_terms['one_term']['term_id']
+                ) );
+
+                $expected = array(
+                        $initial_terms['seven_term']['term_id'],
+                );
+
+                $actual = wp_list_pluck( $terms, 'term_id' );
+                $this->assertEqualSets( $expected, $actual );
+        }
+
+        public function test_hierarchical_false_with_child_of_should_not_return_grandchildren() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                // Case where hierarchical is false
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => false,
+                        'child_of' => $initial_terms['one_term']['term_id']
+                ) );
+
+                // Verify that there are no children
+                $this->assertEquals( 0, count( $terms ) );
+        }
+
+        public function test_hierarchical_true_with_child_of_should_return_grandchildren() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                // Case where hierarchical is true
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => true,
+                        'child_of' => $initial_terms['one_term']['term_id']
+                ) );
+
+                $expected = array(
+                        $initial_terms['two_term']['term_id'],
+                        $initial_terms['three_term']['term_id'],
+                        $initial_terms['five_term']['term_id'],
+                        $initial_terms['six_term']['term_id'],
+                );
+                $actual = wp_list_pluck( $terms, 'term_id' );
+                $this->assertEqualSets( $expected, $actual );
+        }
+
+        public function test_parent_should_override_child_of() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                $terms = get_terms( 'category', array(
+                        'hide_empty' => false,
+                        'child_of' => $initial_terms['one_term']['term_id'],
+                        'parent' => $initial_terms['one_term']['term_id']
+                ) );
+
+                // Verify that parent takes precedence over child_of and returns only direct children.
+                $expected = array(
+                        $initial_terms['two_term']['term_id'],
+                        $initial_terms['five_term']['term_id'],
+                        $initial_terms['seven_term']['term_id']
+                );
+                $actual = wp_list_pluck( $terms, 'term_id' );
+                $this->assertEqualSets( $expected, $actual );
+        }
+
+        public function test_hierarchical_false_parent_should_override_child_of() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                // Case where hierarchical is false
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => false,
+                        'child_of' => $initial_terms['one_term']['term_id'],
+                        'parent' => $initial_terms['one_term']['term_id']
+                ) );
+
+                // hierarchical=false means that descendants are not fetched.
+                $this->assertEquals( 0, count( $terms ) );
+        }
+
+        /**
+         * @ticket 29185
+         */
+        public function test_hierarchical_true_parent_overrides_child_of() {
+                $initial_terms = $this->create_hierarchical_terms();
+
+                // Case where hierarchical is true
+                $terms = get_terms( 'category', array(
+                        'hierarchical' => true,
+                        'child_of' => $initial_terms['one_term']['term_id'],
+                        'parent' => $initial_terms['one_term']['term_id'],
+                ) );
+
+                // Verify that parent takes precedence over child_of
+                $expected = array(
+                        $initial_terms['two_term']['term_id'],
+                        $initial_terms['five_term']['term_id'],
+                );
+                $actual = wp_list_pluck( $terms, 'term_id' );
+                $this->assertEqualSets( $expected, $actual );
+        }
+
         protected function create_hierarchical_terms_and_posts() {
-
                 $terms = array();
 
@@ -837 +980 @@
                 return $terms;
         }
+
+        protected function create_hierarchical_terms() {
+                // Set up the following hierarchy:
+                // - One
+                //   - Two
+                //     - Three (1)
+                //     - Four
+                //   - Five
+                //     - Six (1)
+                //   - Seven
+                $one_term = wp_insert_term(
+                        'One',
+                        'category'
+                );
+                $two_term = wp_insert_term(
+                        'Two',
+                        'category',
+                        array(
+                                'parent' => $one_term['term_id']
+                        )
+                );
+                $three_term = wp_insert_term(
+                        'Three',
+                        'category',
+                        array(
+                                'parent' => $two_term['term_id']
+                        )
+                );
+                $four_term = wp_insert_term(
+                        'Four',
+                        'category',
+                        array(
+                                'parent' => $two_term['term_id']
+                        )
+                );
+                $five_term = wp_insert_term(
+                        'Five',
+                        'category',
+                        array(
+                                'parent' => $one_term['term_id']
+                        )
+                );
+                $six_term = wp_insert_term(
+                        'Six',
+                        'category',
+                        array(
+                                'parent' => $five_term['term_id']
+                        )
+                );
+                $seven_term = wp_insert_term(
+                        'Seven',
+                        'category',
+                        array(
+                                'parent' => $one_term['term_id']
+                        )
+                );
+
+                // Ensure child terms are not empty
+                $first_post_id = $this->factory->post->create();
+                $second_post_id = $this->factory->post->create();
+                wp_set_post_terms( $first_post_id, array( $three_term['term_id'] ), 'category' );
+                wp_set_post_terms( $second_post_id, array( $six_term['term_id'] ), 'category' );
+
+                return array(
+                        'one_term' => $one_term,
+                        'two_term' => $two_term,
+                        'three_term' => $three_term,
+                        'four_term' => $four_term,
+                        'five_term' => $five_term,
+                        'six_term' => $six_term,
+                        'seven_term' => $seven_term
+                );
+        }
 }