Ticket #43298: 43298.patch

src/wp-includes/class-wp-comment-query.php

@@ -379 +379 @@
                         $this->meta_query_clauses = $this->meta_query->get_sql( 'comment', $wpdb->comments, 'comment_ID', $this );
                 }
 
+                /*
+                 * Add the blacklist filter to the query vars, as it can impact query
+                 * results and should trigger cache refreshes when modified.
+                 */
+                $this->query_vars['type__not_in'] = array_unique( array_merge(
+                        (array) $this->query_vars['type__not_in'],
+                        /** This filter is documented in wp-includes/class-wp-comment-query */
+                        (array) apply_filters( 'wp_hidden_comment_types', array() )
+                ) );
+
                 /*
                  * Only use the args defined in the query_var_defaults to compute the key,
                  * but ignore 'fields', which does not affect query results.
@@ -465 +475 @@
                 return $this->comments;
         }
 
+        /**
+         * Get an SQL clause to exclude hidden comment types.
+         *
+         * @since 5.0.0
+         *
+         * @param string $conjunction Optional. Conjunction word to use. Defaults to
+         *                            'WHERE'.
+         *
+         * @return string SQL clause that excludes hidden comment types.
+         */
+        public static function get_hidden_comment_types_clause( $conjunction = 'WHERE' ) {
+                global $wpdb;
+
+                /**
+                 * Filters the list of hidden comment types.
+                 *
+                 * Hidden comment types are excluded from the default comment queries
+                 * and comment counts.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param array Array of comment types to hide by default.
+                 */
+                $hidden_types = apply_filters( 'wp_hidden_comment_types', array() );
+                $hidden_types = array_filter( (array) $hidden_types );
+
+                $type_clauses = array();
+                foreach ( $hidden_types as $hidden_type ) {
+                        $type_clauses[] = $wpdb->prepare(
+                                'comment_type NOT IN (%s)',
+                                $hidden_type
+                        );
+                }
+
+                return ! empty( $type_clauses )
+                        ? sprintf(
+                                '%s %s',
+                                $conjunction,
+                                implode( ' AND ', $type_clauses )
+                        )
+                        : '';
+        }
+
         /**
          * Used internally to get a list of comment IDs matching the query vars.
          *
@@ -699 +752 @@
 
                 // Filtering by comment_type: 'type', 'type__in', 'type__not_in'.
                 $raw_types = array(
-                        'IN'     => array_merge( (array) $this->query_vars['type'], (array) $this->query_vars['type__in'] ),
+                        'IN'     => array_unique( array_merge(
+                                (array) $this->query_vars['type'],
+                                (array) $this->query_vars['type__in']
+                        ) ),
                         'NOT IN' => (array) $this->query_vars['type__not_in'],
                 );
 
+                /*
+                 * In case a specific comment type was requested, ensure it was not
+                 * already blacklisted at the same time.
+                 * This means that explicit type inclusion trumps type exclusion.
+                 */
+                $raw_types['NOT IN'] = array_diff( $raw_types['NOT IN'], $raw_types['IN'] );
+
                 $comment_types = array();
                 foreach ( $raw_types as $operator => $_raw_types ) {
-                        $_raw_types = array_unique( $_raw_types );
-
                         foreach ( $_raw_types as $type ) {
                                 switch ( $type ) {
                                         // An empty translates to 'all', for backward compatibility

src/wp-includes/comment.php

@@ -371 +371 @@
         $post_id = (int) $post_id;
 
         $where = '';
+
         if ( $post_id > 0 ) {
                 $where = $wpdb->prepare( 'WHERE comment_post_ID = %d', $post_id );
         }
 
+        $where .= WP_Comment_Query::get_hidden_comment_types_clause(
+                empty( $where ) ? 'WHERE' : 'AND'
+        );
+
         $totals = (array) $wpdb->get_results(
                 "
                 SELECT comment_approved, COUNT( * ) AS total
@@ -2439 +2444 @@
         $new = apply_filters( 'pre_wp_update_comment_count_now', null, $old, $post_id );
 
         if ( is_null( $new ) ) {
-                $new = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1'", $post_id ) );
+                $sql = $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1'", $post_id );
+
+                $sql .= WP_Comment_Query::get_hidden_comment_types_clause( 'AND' );
+
+                $new = (int) $wpdb->get_var( $sql );
         } else {
                 $new = (int) $new;
         }

new file tests/phpunit/tests/comment/commentTypes.php

@@ +1 @@
+<?php
+
+/**
+ * @group comment
+ */
+class Tests_Comment_Types extends WP_UnitTestCase {
+
+        public function filter_comment_type_blacklist( $blacklist ) {
+                $blacklist[] = 'test_comment_type';
+                return $blacklist;
+        }
+
+        /**
+         * @ticket 43298
+         */
+        public function test_get_comments_is_filtered_on_type() {
+                $comments = get_comments();
+                $this->assertEquals( 0, count( $comments ) );
+
+                self::factory()->comment->create(
+                        array( 'comment_type' => 'test_comment_type' )
+                );
+
+                $comments = get_comments();
+                $this->assertEquals( 1, count( $comments ) );
+
+                add_filter(
+                        'wp_hidden_comment_types',
+                        array( $this, 'filter_comment_type_blacklist' )
+                );
+
+                $comments = get_comments();
+                $this->assertEquals( 0, count( $comments ) );
+        }
+
+        /**
+         * @ticket 43298
+         */
+        public function test_get_comment_count_is_filtered_on_type() {
+                $count = get_comment_count();
+                $this->assertEquals( 0, $count['all'] );
+
+                self::factory()->comment->create(
+                        array( 'comment_type' => 'test_comment_type' )
+                );
+
+                $count = get_comment_count();
+                $this->assertEquals( 1, $count['all'] );
+
+                add_filter(
+                        'wp_hidden_comment_types',
+                        array( $this, 'filter_comment_type_blacklist' )
+                );
+
+                $count = get_comment_count();
+                $this->assertEquals( 0, $count['all'] );
+        }
+
+        /**
+         * @ticket 43298
+         */
+        public function test_wp_update_comment_count_is_filtered_on_type() {
+                $post_id = self::factory()->post->create(
+                        array( 'post_author' => 1 )
+                );
+
+                wp_update_comment_count( $post_id );
+                $post = get_post( $post_id );
+                $this->assertEquals( 0, $post->comment_count );
+
+                self::factory()->comment->create(
+                        array(
+                                'comment_post_ID' => $post_id,
+                                'comment_type' => 'test_comment_type',
+                        )
+                );
+
+                wp_update_comment_count( $post_id );
+                $post = get_post( $post_id );
+                $this->assertEquals( 1, $post->comment_count );
+
+                add_filter(
+                        'wp_hidden_comment_types',
+                        array( $this, 'filter_comment_type_blacklist' )
+                );
+
+                wp_update_comment_count( $post_id );
+                $post = get_post( $post_id );
+                $this->assertEquals( 0, $post->comment_count );
+        }
+}