fc1f42715df6da42e54249e43d55f8b443e63eb2

Committed 04 Aug 2026 12:10PM UTC coverage: 55.443% (-0.3%) from 55.778%

Build # fc1f42715df6da42e54249e43d55f8b443e63eb2

Build Type

Pull #23538

github

Committed by

web-flow

Commit Message

Merge 7f52065cc into 0de900db2

Pull Request Pull Request #23538: fix(bulk-editor): resolve post type default template when SEO title/description is empty

Coverage Stats

9798 of 17512 branches covered (55.95%)

Branch coverage included in aggregate %.

29 of 40 new or added lines in 3 files covered. (72.5%)

1 existing line in 1 file now uncovered.

39294 of 71033 relevant lines covered (55.32%)

42369.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.33

/src/bulk-editor/infrastructure/posts/indexable-posts-collector.php

<?php

// phpcs:disable Yoast.NamingConventions.NamespaceName.TooLong -- Needed in the folder structure.
namespace Yoast\WP\SEO\Bulk_Editor\Infrastructure\Posts;

use Yoast\WP\Lib\ORM;
use Yoast\WP\SEO\Bulk_Editor\Application\Posts\Posts_Collector_Interface;
use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Post;
use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Posts_List;
use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Posts_Page;
use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Posts_Query;
use Yoast\WP\SEO\Models\Indexable;
use Yoast\WP\SEO\Repositories\Indexable_Repository;

/**
 * Collects bulk editor posts by reading from the indexable table.
 *
 * This is the default used when indexables are active.
 */
class Indexable_Posts_Collector implements Posts_Collector_Interface {

        use Post_Title_Trait;
        use Searchable_Fields_Trait;

        /**
         * Maps each "needs improvement" field key to its indexable column.
         *
         * @var array<string, string>
         */
        private const FIELD_COLUMNS = [
                'seo_title'          => 'title',
                'meta_description'   => 'description',
                'social_title'       => 'open_graph_title',
                'social_description' => 'open_graph_description',
        ];

        /**
         * Maps the fields with a persisted per-field score to their indexable score column.
         *
         * The social fields have no assessors, so they match on emptiness only.
         *
         * @var array<string, string>
         */
        private const FIELD_SCORE_COLUMNS = [
                'seo_title'        => 'seo_title_score',
                'meta_description' => 'meta_description_score',
        ];

        /**
         * The indexable repository.
         *
         * @var Indexable_Repository
         */
        private $indexable_repository;

        /**
         * The resolver for the per-post edit permission.
         *
         * @var Post_Editability_Resolver
         */
        private $post_editability_resolver;

        /**
         * The resolver for the post type's default SEO title / meta description template.
         *
         * @var Default_Template_Resolver
         */
        private $default_template_resolver;

        /**
         * The constructor.
         *
         * @param Indexable_Repository      $indexable_repository      The indexable repository.
         * @param Post_Editability_Resolver $post_editability_resolver The resolver for the per-post edit permission.
         * @param Default_Template_Resolver $default_template_resolver The resolver for the default SEO title / meta description template.
         */
        public function __construct(
                Indexable_Repository $indexable_repository,
                Post_Editability_Resolver $post_editability_resolver,
                Default_Template_Resolver $default_template_resolver
        ) {
                $this->indexable_repository      = $indexable_repository;
                $this->post_editability_resolver = $post_editability_resolver;
                $this->default_template_resolver = $default_template_resolver;
        }

        /**
         * Collects a page of posts for the given query.
         *
         * A single page is fetched and counted through the database; the per-post edit permission is then
         * resolved for that page so posts the user cannot edit are returned locked and without their SEO data.
         *
         * @param Posts_Query $query The query describing the page to collect.
         *
         * @return Posts_Page The collected posts together with the totals for pagination.
         */
        public function get_posts( Posts_Query $query ): Posts_Page {
                $indexables = $this->build_query( $query )
                        ->order_by_desc( 'object_id' )
                        ->limit( $query->get_per_page() )
                        ->offset( $query->get_offset() )
                        ->find_many();

                // Deduplicate on the post, keeping the query order.
                $indexables_by_id = [];
                foreach ( $indexables as $indexable ) {
                        $indexables_by_id[ (int) $indexable->object_id ] = $indexable;
                }

                $total = $this->resolve_total( $query, \count( $indexables ), \count( $indexables_by_id ) );

                $editability = $this->post_editability_resolver->resolve( \array_keys( $indexables_by_id ) );

                $posts_list = new Posts_List();
                foreach ( $indexables_by_id as $object_id => $indexable ) {
                        $posts_list->add( $this->build_post( $indexable, ( $editability[ $object_id ] ?? false ), $query->are_scores_enabled() ) );
                }

                return new Posts_Page( $posts_list, $total, $query->get_page(), $query->get_per_page() );
        }

        /**
         * Resolves the total number of matching posts.
         *
         * A partially-filled page means the result set ended within it, so the total is known without a
         * second query: the offset plus the distinct posts on this page. Whether the page ended is judged
         * on the number of rows fetched, before duplicates are removed, since that is what reveals the
         * database had no more rows. A full or empty page does not reveal the total, so it falls back to a
         * count query. Non-editable posts are shown locked rather than removed, so they still count.
         *
         * @param Posts_Query $query    The query that produced the page.
         * @param int         $fetched  The number of rows the page returned, before duplicates are removed.
         * @param int         $distinct The number of distinct posts on the page, after duplicates are removed.
         *
         * @return int The total number of matching posts.
         */
        private function resolve_total( Posts_Query $query, int $fetched, int $distinct ): int {
                if ( $fetched > 0 && $fetched < $query->get_per_page() ) {
                        return ( $query->get_offset() + $distinct );
                }

                return (int) $this->build_query( $query )->count();
        }

        /**
         * Builds the filtered indexable query for the given query, without ordering or paging.
         *
         * Built fresh for each use so the same filters back both the total count and the page of rows.
         *
         * @param Posts_Query $query The query describing the filters to apply.
         *
         * @return ORM The filtered query.
         */
        private function build_query( Posts_Query $query ): ORM {
                $builder = $this->indexable_repository->query()
                        ->where( 'object_type', 'post' )
                        ->where( 'object_sub_type', $query->get_content_type() )
                        ->where_in( 'post_status', $query->get_statuses() )
                        // Password-protected posts (is_protected) are not shown in bulk editing.
                        ->where( 'is_protected', 0 );

                if ( $query->has_author_filter() ) {
                        $builder->where( 'author_id', $query->get_author_id() );
                }

                if ( $query->has_include() ) {
                        $builder->where_in( 'object_id', $query->get_include_ids() );
                }

                if ( $query->has_search() ) {
                        $this->apply_search( $builder, $query->get_search() );
                }

                if ( $query->get_needs_improvement() !== [] ) {
                        $this->apply_needs_improvement( $builder, $query->get_needs_improvement(), $query->are_scores_enabled() );
                }

                return $builder;
        }

        /**
         * Adds the "needs improvement" clause to the query.
         *
         * A field needs improvement when its indexable column is NULL or an empty string, or — for fields
         * with a persisted per-field score and while scoring is enabled — when that score falls in the bad/ok
         * range. The selected fields are OR-ed inside a single group so they broaden the result without
         * interfering with the other filters, and unknown field keys are ignored.
         *
         * @param ORM           $builder        The query to add the clause to.
         * @param array<string> $fields         The fields that need improvement.
         * @param bool          $scores_enabled Whether the per-field scores may back the filter.
         *
         * @return void
         */
        private function apply_needs_improvement( ORM $builder, array $fields, bool $scores_enabled ): void {
                $clauses = [];
                $values  = [];
                foreach ( $fields as $field ) {
                        if ( ! isset( self::FIELD_COLUMNS[ $field ] ) ) {
                                continue;
                        }

                        $column   = self::FIELD_COLUMNS[ $field ];
                        $clause   = $column . ' IS NULL OR ' . $column . ' = %s';
                        $values[] = '';

                        if ( $scores_enabled && isset( self::FIELD_SCORE_COLUMNS[ $field ] ) ) {
                                $clause  .= ' OR ' . self::FIELD_SCORE_COLUMNS[ $field ] . ' BETWEEN %d AND %d';
                                $values[] = self::NEEDS_IMPROVEMENT_MIN_SCORE;
                                $values[] = self::NEEDS_IMPROVEMENT_MAX_SCORE;
                        }

                        $clauses[] = '( ' . $clause . ' )';
                }

                if ( $clauses === [] ) {
                        return;
                }

                // The column names come from the internal maps, never from input; only the empty string and score bounds are bound.
                $builder->where_raw(
                        '( ' . \implode( ' OR ', $clauses ) . ' )',
                        $values,
                );
        }

        /**
         * Adds the catch-all search clause to the query.
         *
         * The post title lives in the posts table, so it is matched through a subquery while the remaining
         * fields are matched directly on the indexable. All clauses are OR-ed inside a single group so they
         * do not interfere with the other filters.
         *
         * @param ORM    $builder The query to add the search clause to.
         * @param string $search  The search term.
         *
         * @return void
         */
        private function apply_search( ORM $builder, string $search ): void {
                global $wpdb;

                $like = '%' . $wpdb->esc_like( $search ) . '%';

                // The post title lives in the posts table, so match it through a subquery; the rest are indexable columns.
                $clauses = [ 'object_id IN ( SELECT ID FROM ' . $wpdb->posts . ' WHERE post_title LIKE %s )' ];
                foreach ( \array_keys( $this->searchable_fields() ) as $column ) {
                        $clauses[] = $column . ' LIKE %s';
                }

                // The ORM binds each %s through $wpdb->prepare; one bound value per clause.
                $builder->where_raw(
                        '( ' . \implode( ' OR ', $clauses ) . ' )',
                        \array_fill( 0, \count( $clauses ), $like ),
                );
        }

        /**
         * Builds a post from an indexable.
         *
         * The SEO data and edit link of a post the current user cannot edit are withheld, so the post is
         * shown in the list but stays locked and does not expose its metadata.
         *
         * @param Indexable $indexable      The indexable.
         * @param bool      $editable       Whether the current user may edit the post.
         * @param bool      $scores_enabled Whether the per-field scores may back the needs-improvement verdict.
         *
         * @return Post The post.
         */
        private function build_post( Indexable $indexable, bool $editable, bool $scores_enabled ): Post {
                $object_id = (int) $indexable->object_id;
                $title     = $this->get_normalized_title( $object_id );

                if ( ! $editable ) {
                        return new Post( $object_id, $title, (string) $indexable->post_status, '', '', '', '', '', '', false );
                }

                $post_type        = (string) $indexable->object_sub_type;
                $seo_title        = $this->default_template_resolver->resolve_seo_title( $object_id, $post_type, (string) $indexable->title );
                $meta_description = $this->default_template_resolver->resolve_meta_description( $object_id, $post_type, (string) $indexable->description );

                return new Post(
                        $object_id,
                        $title,
                        (string) $indexable->post_status,
                        (string) \get_edit_post_link( $object_id, 'raw' ),
                        (string) $indexable->primary_focus_keyword,
                        $seo_title,
                        $meta_description,
                        (string) $indexable->open_graph_title,
                        (string) $indexable->open_graph_description,
                        true,
                        $this->build_needs_improvement( $indexable, $scores_enabled, $seo_title, $meta_description ),
                );
        }

        /**
         * Builds the per-field needs-improvement verdict for a post, keyed by field param.
         *
         * A field needs improvement when its value is empty, or when its score falls in the bad/ok range.
         * The SEO title and meta description use their already-resolved values (which may have been filled
         * in from the post type's default template) so a post with a non-empty template is not flagged
         * as needing improvement merely because its stored value was never explicitly saved.
         *
         * @param Indexable $indexable        The indexable.
         * @param bool      $scores_enabled   Whether the per-field scores may back the verdict.
         * @param string    $seo_title        The resolved SEO title (may differ from the raw indexable value).
         * @param string    $meta_description The resolved meta description (may differ from the raw indexable value).
         *
         * @return array<string, bool> Whether each field needs improvement, keyed by field param.
         */
        private function build_needs_improvement( Indexable $indexable, bool $scores_enabled, string $seo_title, string $meta_description ): array {
                $resolved_values = [
                        'seo_title'        => $seo_title,
                        'meta_description' => $meta_description,
                ];

                $needs_improvement = [];
                foreach ( self::FIELD_COLUMNS as $field => $column ) {
                        $value    = ( $resolved_values[ $field ] ?? (string) $indexable->{$column} );
                        $is_empty = ( $value === '' );

                        $is_bad_score = false;
                        if ( $scores_enabled && isset( self::FIELD_SCORE_COLUMNS[ $field ] ) ) {
                                $score        = (int) $indexable->{self::FIELD_SCORE_COLUMNS[ $field ]};
                                $is_bad_score = ( $score >= self::NEEDS_IMPROVEMENT_MIN_SCORE && $score <= self::NEEDS_IMPROVEMENT_MAX_SCORE );
                        }

                        $needs_improvement[ $field ] = ( $is_empty || $is_bad_score );
                }

                return $needs_improvement;
        }
}

1	<?php
2
3	// phpcs:disable Yoast.NamingConventions.NamespaceName.TooLong -- Needed in the folder structure.
4	namespace Yoast\WP\SEO\Bulk_Editor\Infrastructure\Posts;
5
6	use Yoast\WP\Lib\ORM;
7	use Yoast\WP\SEO\Bulk_Editor\Application\Posts\Posts_Collector_Interface;
8	use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Post;
9	use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Posts_List;
10	use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Posts_Page;
11	use Yoast\WP\SEO\Bulk_Editor\Domain\Posts\Posts_Query;
12	use Yoast\WP\SEO\Models\Indexable;
13	use Yoast\WP\SEO\Repositories\Indexable_Repository;
14
15	/**
16	* Collects bulk editor posts by reading from the indexable table.
17	*
18	* This is the default used when indexables are active.
19	*/
20	class Indexable_Posts_Collector implements Posts_Collector_Interface {
21
22	use Post_Title_Trait;
23	use Searchable_Fields_Trait;
24
25	/**
26	* Maps each "needs improvement" field key to its indexable column.
27	*
28	* @var array<string, string>
29	*/
30	private const FIELD_COLUMNS = [
31	'seo_title' => 'title',
32	'meta_description' => 'description',
33	'social_title' => 'open_graph_title',
34	'social_description' => 'open_graph_description',
35	];
36
37	/**
38	* Maps the fields with a persisted per-field score to their indexable score column.
39	*
40	* The social fields have no assessors, so they match on emptiness only.
41	*
42	* @var array<string, string>
43	*/
44	private const FIELD_SCORE_COLUMNS = [
45	'seo_title' => 'seo_title_score',
46	'meta_description' => 'meta_description_score',
47	];
48
49	/**
50	* The indexable repository.
51	*
52	* @var Indexable_Repository
53	*/
54	private $indexable_repository;
55
56	/**
57	* The resolver for the per-post edit permission.
58	*
59	* @var Post_Editability_Resolver
60	*/
61	private $post_editability_resolver;
62
63	/**
64	* The resolver for the post type's default SEO title / meta description template.
65	*
66	* @var Default_Template_Resolver
67	*/
68	private $default_template_resolver;
69
70	/**
71	* The constructor.
72	*
73	* @param Indexable_Repository $indexable_repository The indexable repository.
74	* @param Post_Editability_Resolver $post_editability_resolver The resolver for the per-post edit permission.
75	* @param Default_Template_Resolver $default_template_resolver The resolver for the default SEO title / meta description template.
76	*/
77	public function __construct(	×
78	Indexable_Repository $indexable_repository,
79	Post_Editability_Resolver $post_editability_resolver,
80	Default_Template_Resolver $default_template_resolver
81	) {
82	$this->indexable_repository = $indexable_repository;	×
83	$this->post_editability_resolver = $post_editability_resolver;	×
NEW 84	$this->default_template_resolver = $default_template_resolver;	×
85	}
86
87	/**
88	* Collects a page of posts for the given query.
89	*
90	* A single page is fetched and counted through the database; the per-post edit permission is then
91	* resolved for that page so posts the user cannot edit are returned locked and without their SEO data.
92	*
93	* @param Posts_Query $query The query describing the page to collect.
94	*
95	* @return Posts_Page The collected posts together with the totals for pagination.
96	*/
97	public function get_posts( Posts_Query $query ): Posts_Page {	22✔
98	$indexables = $this->build_query( $query )	22✔
99	->order_by_desc( 'object_id' )	22✔
100	->limit( $query->get_per_page() )	22✔
101	->offset( $query->get_offset() )	22✔
102	->find_many();	22✔
103
104	// Deduplicate on the post, keeping the query order.
105	$indexables_by_id = [];	22✔
106	foreach ( $indexables as $indexable ) {	22✔
107	$indexables_by_id[ (int) $indexable->object_id ] = $indexable;	12✔
108	}
109
110	$total = $this->resolve_total( $query, \count( $indexables ), \count( $indexables_by_id ) );	22✔
111
112	$editability = $this->post_editability_resolver->resolve( \array_keys( $indexables_by_id ) );	22✔
113
114	$posts_list = new Posts_List();	22✔
115	foreach ( $indexables_by_id as $object_id => $indexable ) {	22✔
116	$posts_list->add( $this->build_post( $indexable, ( $editability[ $object_id ] ?? false ), $query->are_scores_enabled() ) );	12✔
117	}
118
119	return new Posts_Page( $posts_list, $total, $query->get_page(), $query->get_per_page() );	22✔
120	}
121
122	/**
123	* Resolves the total number of matching posts.
124	*
125	* A partially-filled page means the result set ended within it, so the total is known without a
126	* second query: the offset plus the distinct posts on this page. Whether the page ended is judged
127	* on the number of rows fetched, before duplicates are removed, since that is what reveals the
128	* database had no more rows. A full or empty page does not reveal the total, so it falls back to a
129	* count query. Non-editable posts are shown locked rather than removed, so they still count.
130	*
131	* @param Posts_Query $query The query that produced the page.
132	* @param int $fetched The number of rows the page returned, before duplicates are removed.
133	* @param int $distinct The number of distinct posts on the page, after duplicates are removed.
134	*
135	* @return int The total number of matching posts.
136	*/
137	private function resolve_total( Posts_Query $query, int $fetched, int $distinct ): int {	22✔
138	if ( $fetched > 0 && $fetched < $query->get_per_page() ) {	22✔
139	return ( $query->get_offset() + $distinct );	10✔
140	}
141
142	return (int) $this->build_query( $query )->count();	12✔
143	}
144
145	/**
146	* Builds the filtered indexable query for the given query, without ordering or paging.
147	*
148	* Built fresh for each use so the same filters back both the total count and the page of rows.
149	*
150	* @param Posts_Query $query The query describing the filters to apply.
151	*
152	* @return ORM The filtered query.
153	*/
154	private function build_query( Posts_Query $query ): ORM {	22✔
155	$builder = $this->indexable_repository->query()	22✔
156	->where( 'object_type', 'post' )	22✔
157	->where( 'object_sub_type', $query->get_content_type() )	22✔
158	->where_in( 'post_status', $query->get_statuses() )	22✔
159	// Password-protected posts (is_protected) are not shown in bulk editing.	22✔
160	->where( 'is_protected', 0 );	22✔
161
162	if ( $query->has_author_filter() ) {	22✔
163	$builder->where( 'author_id', $query->get_author_id() );	×
164	}
165
166	if ( $query->has_include() ) {	22✔
167	$builder->where_in( 'object_id', $query->get_include_ids() );	2✔
168	}
169
170	if ( $query->has_search() ) {	22✔
171	$this->apply_search( $builder, $query->get_search() );	2✔
172	}
173
174	if ( $query->get_needs_improvement() !== [] ) {	22✔
175	$this->apply_needs_improvement( $builder, $query->get_needs_improvement(), $query->are_scores_enabled() );	6✔
176	}
177
178	return $builder;	22✔
179	}
180
181	/**
182	* Adds the "needs improvement" clause to the query.
183	*
184	* A field needs improvement when its indexable column is NULL or an empty string, or — for fields
185	* with a persisted per-field score and while scoring is enabled — when that score falls in the bad/ok
186	* range. The selected fields are OR-ed inside a single group so they broaden the result without
187	* interfering with the other filters, and unknown field keys are ignored.
188	*
189	* @param ORM $builder The query to add the clause to.
190	* @param array<string> $fields The fields that need improvement.
191	* @param bool $scores_enabled Whether the per-field scores may back the filter.
192	*
193	* @return void
194	*/
195	private function apply_needs_improvement( ORM $builder, array $fields, bool $scores_enabled ): void {	6✔
196	$clauses = [];	6✔
197	$values = [];	6✔
198	foreach ( $fields as $field ) {	6✔
199	if ( ! isset( self::FIELD_COLUMNS[ $field ] ) ) {	6✔
200	continue;	×
201	}
202
203	$column = self::FIELD_COLUMNS[ $field ];	6✔
204	$clause = $column . ' IS NULL OR ' . $column . ' = %s';	6✔
205	$values[] = '';	6✔
206
207	if ( $scores_enabled && isset( self::FIELD_SCORE_COLUMNS[ $field ] ) ) {	6✔
208	$clause .= ' OR ' . self::FIELD_SCORE_COLUMNS[ $field ] . ' BETWEEN %d AND %d';	2✔
209	$values[] = self::NEEDS_IMPROVEMENT_MIN_SCORE;	2✔
210	$values[] = self::NEEDS_IMPROVEMENT_MAX_SCORE;	2✔
211	}
212
213	$clauses[] = '( ' . $clause . ' )';	6✔
214	}
215
216	if ( $clauses === [] ) {	6✔
217	return;	×
218	}
219
220	// The column names come from the internal maps, never from input; only the empty string and score bounds are bound.
221	$builder->where_raw(	6✔
222	'( ' . \implode( ' OR ', $clauses ) . ' )',	6✔
223	$values,	6✔
224	);	6✔
225	}
226
227	/**
228	* Adds the catch-all search clause to the query.
229	*
230	* The post title lives in the posts table, so it is matched through a subquery while the remaining
231	* fields are matched directly on the indexable. All clauses are OR-ed inside a single group so they
232	* do not interfere with the other filters.
233	*
234	* @param ORM $builder The query to add the search clause to.
235	* @param string $search The search term.
236	*
237	* @return void
238	*/
239	private function apply_search( ORM $builder, string $search ): void {	2✔
240	global $wpdb;	2✔
241
242	$like = '%' . $wpdb->esc_like( $search ) . '%';	2✔
243
244	// The post title lives in the posts table, so match it through a subquery; the rest are indexable columns.
245	$clauses = [ 'object_id IN ( SELECT ID FROM ' . $wpdb->posts . ' WHERE post_title LIKE %s )' ];	2✔
246	foreach ( \array_keys( $this->searchable_fields() ) as $column ) {	2✔
247	$clauses[] = $column . ' LIKE %s';	2✔
248	}
249
250	// The ORM binds each %s through $wpdb->prepare; one bound value per clause.
251	$builder->where_raw(	2✔
252	'( ' . \implode( ' OR ', $clauses ) . ' )',	2✔
253	\array_fill( 0, \count( $clauses ), $like ),	2✔
254	);	2✔
255	}
256
257	/**
258	* Builds a post from an indexable.
259	*
260	* The SEO data and edit link of a post the current user cannot edit are withheld, so the post is
261	* shown in the list but stays locked and does not expose its metadata.
262	*
263	* @param Indexable $indexable The indexable.
264	* @param bool $editable Whether the current user may edit the post.
265	* @param bool $scores_enabled Whether the per-field scores may back the needs-improvement verdict.
266	*
267	* @return Post The post.
268	*/
269	private function build_post( Indexable $indexable, bool $editable, bool $scores_enabled ): Post {	12✔
270	$object_id = (int) $indexable->object_id;	12✔
271	$title = $this->get_normalized_title( $object_id );	12✔
272
273	if ( ! $editable ) {	12✔
274	return new Post( $object_id, $title, (string) $indexable->post_status, '', '', '', '', '', '', false );	2✔
275	}
276
277	$post_type = (string) $indexable->object_sub_type;	10✔
278	$seo_title = $this->default_template_resolver->resolve_seo_title( $object_id, $post_type, (string) $indexable->title );	10✔
279	$meta_description = $this->default_template_resolver->resolve_meta_description( $object_id, $post_type, (string) $indexable->description );	10✔
280
281	return new Post(	10✔
282	$object_id,	10✔
283	$title,	10✔
284	(string) $indexable->post_status,	10✔
285	(string) \get_edit_post_link( $object_id, 'raw' ),	10✔
286	(string) $indexable->primary_focus_keyword,	10✔
287	$seo_title,	10✔
288	$meta_description,	10✔
289	(string) $indexable->open_graph_title,	10✔
290	(string) $indexable->open_graph_description,	10✔
291	true,	10✔
292	$this->build_needs_improvement( $indexable, $scores_enabled, $seo_title, $meta_description ),	10✔
293	);	10✔
294	}
295
296	/**
297	* Builds the per-field needs-improvement verdict for a post, keyed by field param.
298	*
299	* A field needs improvement when its value is empty, or when its score falls in the bad/ok range.
300	* The SEO title and meta description use their already-resolved values (which may have been filled
301	* in from the post type's default template) so a post with a non-empty template is not flagged
302	* as needing improvement merely because its stored value was never explicitly saved.
303	*
304	* @param Indexable $indexable The indexable.
305	* @param bool $scores_enabled Whether the per-field scores may back the verdict.
306	* @param string $seo_title The resolved SEO title (may differ from the raw indexable value).
307	* @param string $meta_description The resolved meta description (may differ from the raw indexable value).
308	*
309	* @return array<string, bool> Whether each field needs improvement, keyed by field param.
310	*/
311	private function build_needs_improvement( Indexable $indexable, bool $scores_enabled, string $seo_title, string $meta_description ): array {	10✔
312	$resolved_values = [	10✔
313	'seo_title' => $seo_title,	10✔
314	'meta_description' => $meta_description,	10✔
315	];	10✔
316
317	$needs_improvement = [];	10✔
318	foreach ( self::FIELD_COLUMNS as $field => $column ) {	10✔
319	$value = ( $resolved_values[ $field ] ?? (string) $indexable->{$column} );	10✔
320	$is_empty = ( $value === '' );	10✔
321
322	$is_bad_score = false;	10✔
323	if ( $scores_enabled && isset( self::FIELD_SCORE_COLUMNS[ $field ] ) ) {	10✔
324	$score = (int) $indexable->{self::FIELD_SCORE_COLUMNS[ $field ]};	10✔
325	$is_bad_score = ( $score >= self::NEEDS_IMPROVEMENT_MIN_SCORE && $score <= self::NEEDS_IMPROVEMENT_MAX_SCORE );	10✔
326	}
327
328	$needs_improvement[ $field ] = ( $is_empty \|\| $is_bad_score );	10✔
329	}
330
331	return $needs_improvement;	10✔
332	}
333	}

Yoast / wordpress-seo / fc1f42715df6da42e54249e43d55f8b443e63eb2

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous