Jetpack_Search_Helpers::get_widgets_from_option() - Code Metrics - Inspection of "Merge branch 'master' into update/search-ui-tweaks..." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — update/search-ui-tweaks-kelly ( 8fa975...afc6a9 )

unknown

created 2018-01-30 04:23 UTC

Jetpack_Search_Helpers::get_widgets_from_option() A

↳ Parent: Jetpack_Search_Helpers

Complexity

Conditions	3
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	5
nc	2
nop	0
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0

<?php

class Jetpack_Search_Helpers {
	const FILTER_WIDGET_BASE = 'jetpack-search-filters';

	static function get_search_url() {
		$query_args = $_GET;

		// Handle the case where a permastruct is being used, such as /search/{$query}
		if ( ! isset( $query_args['s'] ) ) {
			$query_args['s'] = get_search_query();
		}

		if ( isset( $query_args['paged'] ) ) {
			unset( $query_args['paged'] );
		}

		$query = http_build_query( $query_args );
		return home_url( "?{$query}" );
	}

	static function add_query_arg( $key, $value = false, $url = false ) {
		$url = empty( $url ) ? self::get_search_url() : $url;
		if ( is_array( $key ) ) {
			return add_query_arg( $key, $url );
		}

		return add_query_arg( $key, $value, $url );
	}

	static function remove_query_arg( $key, $url = false ) {
		$url = empty( $url ) ? self::get_search_url() : $url;
		return remove_query_arg( $key, $url );
	}

	static function get_widget_option_name() {
		return sprintf( 'widget_%s', self::FILTER_WIDGET_BASE );
	}

	static function get_widgets_from_option() {
		$widget_options = get_option( self::get_widget_option_name(), array() );

		// We don't need this
		if ( ! empty( $widget_options ) && isset( $widget_options['_multiwidget'] ) ) {
			unset( $widget_options['_multiwidget'] );
		}

		return $widget_options;
	}

	static function build_widget_id( $number ) {
		return sprintf( '%s-%d', self::FILTER_WIDGET_BASE, $number );
	}

	static function is_active_widget( $widget_id ) {
		return (bool) is_active_widget( false, $widget_id, self::FILTER_WIDGET_BASE );
	}

	static function get_filters_from_widgets() {
		$filters = array();

		$widget_options = self::get_widgets_from_option();
		if ( empty( $widget_options ) ) {
			return $filters;
		}

		foreach ( (array) $widget_options as $number => $settings ) {
			$widget_id = self::build_widget_id( $number );
			if ( ! self::is_active_widget( $widget_id ) || empty( $settings['filters'] ) ) {
				continue;
			}

			foreach ( (array) $settings['filters'] as $widget_filter ) {
				$widget_filter['widget_id'] = $widget_id;
				$key = sprintf( '%s_%d', $widget_filter['type'], count( $filters ) );

				if ( empty( $widget_filter['name'] ) ) {
					$widget_filter['name'] = self::generate_widget_filter_name( $widget_filter );
				}

				$filters[ $key ] = $widget_filter;
			}
		}

		return $filters;
	}

	static function generate_widget_filter_name( $widget_filter ) {
		$name = '';

		switch ( $widget_filter['type'] ) {
			case 'post_type':
				$name = _x( 'Post Types', 'label for filtering posts', 'jetpack' );
				break;
			case 'date_histogram':
				switch ( $widget_filter['field'] ) {
					case 'post_date':
					case 'post_date_gmt':
						switch ( $widget_filter['interval'] ) {
							case 'month':
								$name = _x( 'Month', 'label for filtering posts', 'jetpack' );
								break;
							case 'year':
								$name = _x( 'Year', 'label for filtering posts', 'jetpack' );
								break;
						}
						break;
					case 'post_modified':
					case 'post_modified_gmt':
						switch ( $widget_filter['interval'] ) {
							case 'month':
								$name = _x( 'Month Updated', 'label for filtering posts', 'jetpack' );
								break;
							case 'year':
								$name = _x( 'Year Updated', 'label for filtering posts', 'jetpack' );
								break;
						}
						break;
				}
				break;
			case 'taxonomy':
				$tax = get_taxonomy( $widget_filter['taxonomy'] );
				if ( ! $tax ) {
					break;
				}

				if ( isset( $tax->label ) ) {
					$name = $tax->label;
				} else if ( isset( $tax->labels ) && isset( $tax->labels->name ) ) {
					$name = $tax->labels->name;
				}
				break;
		}

		return $name;
	}

	/**
	 * Whether we should rerun a search in the customizer preview or not.
	 *
	 * @since 5.8.0
	 *
	 * @return bool
	 */
	static function should_rerun_search_in_customizer_preview() {
		// Only update when in a customizer preview and data is being posted.
		// Check for $_POST removes an extra update when the customizer loads.
		//
		// Note: We use $GLOBALS['wp_customize'] here instead of is_customize_preview() to support unit tests.
		if ( ! isset( $GLOBALS['wp_customize'] ) || ! $GLOBALS['wp_customize']->is_preview() || empty( $_POST ) ) {
			return false;
		}

		return true;
	}

	/**
	 * Since PHP's built-in array_diff() works by comparing the values that are in array 1 to the other arrays,
	 * if there are less values in array 1, it's possible to get an empty diff where one might be expected.
	 *
	 * @since 5.8.0
	 *
	 * @param array $array_1
	 * @param array $array_2
	 *
	 * @return array
	 */
	static function array_diff( $array_1, $array_2 ) {
		// If the array counts are the same, then the order doesn't matter. If the count of
		// $array_1 is higher than $array_2, that's also fine. If the count of $array_2 is higher,
		// we need to swap the array order though.
		if ( count( $array_1 ) != count( $array_2 ) && count( $array_2 ) > count( $array_1 ) ) {
			$temp = $array_1;
			$array_1 = $array_2;
			$array_2 = $temp;
		}

		// Disregard keys
		return array_values( array_diff( $array_1, $array_2 ) );
	}

	/**
	 * Given the widget instance, will return true when selected post types differ from searchable post types.
	 *
	 * @since 5.8.0
	 *
	 * @param array $instance
	 * @return bool
	 */
	static function post_types_differ_searchable( $instance ) {
		if ( empty( $instance['post_types'] ) ) {
			return false;
		}

		$searchable_post_types = get_post_types( array( 'exclude_from_search' => false ) );
		$diff_of_searchable = self::array_diff( $searchable_post_types, (array) $instance['post_types'] );

		return ! empty( $diff_of_searchable );
	}

	/**
	 * Given the widget instance, will return true when selected post types differ from the post type filters
	 * applied to the search.
	 *
	 * @since 5.8.0
	 *
	 * @param array $instance
	 * @return bool
	 */
	static function post_types_differ_query( $instance ) {
		if ( empty( $instance['post_types'] ) ) {
			return false;
		}

		if ( empty( $_GET['post_type'] ) ) {
			$post_types_from_query = array();
		} else if ( is_array( $_GET['post_type'] ) ) {
			$post_types_from_query = $_GET['post_type'];
		} else {
			$post_types_from_query = (array) explode( ',',  $_GET['post_type'] );
		}

		$post_types_from_query = array_map( 'trim', $post_types_from_query );

		$diff_query = self::array_diff( (array) $instance['post_types'], $post_types_from_query );
		return ! empty( $diff_query );
	}

	static function get_widget_tracks_value( $old_value, $new_value ) {
		$old_value = (array) $old_value;
		if ( isset( $old_value['_multiwidget'] ) ) {
			unset( $old_value['_multiwidget'] );
		}

		$new_value = (array) $new_value;
		if ( isset( $new_value['_multiwidget'] ) ) {
			unset( $new_value['_multiwidget'] );
		}

		$action = '';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$old_keys = array_keys( $old_value );
		$new_keys = array_keys( $new_value );

		if ( count( $new_keys ) > count( $old_keys ) ) { // This is the case for a widget being added
			$diff = self::array_diff( $new_keys, $old_keys );
			$action = 'widget_added';
			$widget = empty( $diff ) || ! isset( $new_value[ $diff[0] ] )
				? false
				: $new_value[ $diff[0] ];
		} else if ( count( $old_keys ) > count( $new_keys ) ) { // This is the case for a widget being deleted
			$diff = self::array_diff( $old_keys, $new_keys );
			$action = 'widget_deleted';
			$widget = empty( $diff ) || ! isset( $old_value[ $diff[0] ] )
				? false
				: $old_value[ $diff[0] ];
		} else {
			$action = 'widget_updated';
			$widget = false;

			// This is a bit crazy. Since there can be multiple widgets stored in a single option,
			// we need to diff the old and new values to figure out which widget was updated.
			foreach ( $new_value as $key => $new_instance ) {
				if ( ! isset( $old_value[ $key ] ) ) {
					continue;
				}
				$old_instance = $old_value[ $key ];

				// First, let's test the keys of each instance
				$diff = self::array_diff( array_keys( $new_instance ), array_keys( $old_instance ) );
				if ( ! empty( $diff ) ) {
					$widget = $new_instance;
					break;
				}

				// Next, lets's loop over each value and compare it
				foreach ( $new_instance as $k => $v ) {
					if ( is_scalar( $v ) && (string) $v !== (string) $old_instance[ $k ] ) {
						$widget = $new_instance;
						break;
					}

					if ( 'filters' == $k ) {
						if ( count( $new_instance['filters'] ) != count( $old_instance['filters'] ) ) {
							$widget = $new_instance;
							break;
						}

						foreach ( $v as $filter_key => $new_filter_value ) {
							$diff = self::array_diff( $new_filter_value, $old_instance[ 'filters' ][ $filter_key ] );
							if ( ! empty( $diff ) ) {
								$widget = $new_instance;
								break;
							}
						}
					}
				}
			}
		}

		if ( empty( $action ) || empty( $widget ) ) {
			return false;
		}

		return array(
			'action' => $action,
			'widget' => self::get_widget_properties_for_tracks( $widget ),
		);
	}

	static function get_widget_properties_for_tracks( $widget ) {
		$sanitized = array();

		foreach ( (array) $widget as $key => $value ) {
			if ( '_multiwidget' == $key ) {
				continue;
			}
			if ( is_scalar( $value ) ) {
				$key = str_replace( '-', '_', sanitize_key( $key ) );
				$key = "widget_{$key}";
				$sanitized[ $key ] = $value;
			}
		}

		$filters_properties = ! empty( $widget['filters'] )
			? self::get_filter_properties_for_tracks( $widget['filters'] )
			: array();

		return array_merge( $sanitized, $filters_properties );
	}

	static function get_filter_properties_for_tracks( $filters ) {
		if ( empty( $filters ) ) {
			return $filters;
		}

		$filters_properties = array(
			'widget_filter_count' => count( $filters ),
		);

		foreach ( $filters as $filter ) {
			if ( empty( $filter['type'] ) ) {
				continue;
			}

			$key = sprintf( 'widget_filter_type_%s', $filter['type'] );
			if ( isset( $filters_properties[ $key ] ) ) {
				$filters_properties[ $key ]++;
			} else {
				$filters_properties[ $key ] = 1;
			}
		}

		return $filters_properties;
	}

	/**
	 * Gets the active post types given a set of filters.
	 *
	 * @param array $filters The active filters for the current query.
	 * @param array $default_post_types The default post types.
	 *
	 * @return array
	 */
	public static function get_active_post_types( $filters, $default_post_types ) {
		$active_post_types = array();
		foreach( $filters as $item ) {
			if ( ( 'post_type' == $item['type'] ) && isset( $item['query_vars']['post_type'] ) ) {
				$active_post_types[] = $item['query_vars']['post_type'];
			}
		}
		return $active_post_types;
	}

	/**
	 * Sets active to false on all post type buckets.
	 *
	 * @param array $filters The available filters for the current query.
	 *
	 * @return array $modified The filters for the current query with modified active field.
	 */
	public static function remove_active_from_post_type_buckets( $filters ) {
		$modified = $filters;
		foreach ( $filters as $key => $filter ) {
			if ( 'post_type' === $filter['type'] && ! empty( $filter['buckets'] ) ) {
				foreach ( $filter['buckets'] as $k => $bucket ) {
					$bucket['active']                  = false;
					$modified[ $key ]['buckets'][ $k ] = $bucket;
				}
			}
		}

		return $modified;
	}

	/**
	 * Given a url and an array of post types, will ensure that the post types are properly applied to the URL as args.
	 *
	 * @param string $url        The URL to add post types to.
	 * @param array  $post_types An array of post types that should be added to the URL.
	 *
	 * @return string $url The URL with added post types.
	 */
	public static function add_post_types_to_url( $url, $post_types ) {
		$url = Jetpack_Search_Helpers::remove_query_arg( 'post_type', $url );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		if ( empty( $post_types ) ) {
			return $url;
		}

		$url = Jetpack_Search_Helpers::add_query_arg(
			'post_type',
			implode( ',', $post_types ),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			$url
		);

		return $url;
	}

	/**
	 * Since we provide support for the widget restricting post types by adding the selected post types as
	 * active filters, if removing a post type filter would result in there no longer be post_type args in the URL,
	 * we need to be sure to add them back.
	 *
	 * @param array $filters    An array of possible filters for the current query.
	 * @param array $post_types The post types to ensure are on the link.
	 *
	 * @return array $modified The updated array of filters with post typed added to the remove URLs.
	 */
	public static function ensure_post_types_on_remove_url( $filters, $post_types ) {
		$modified = $filters;

		foreach ( (array) $filters as $filter_key => $filter ) {
			if ( 'post_type' !== $filter['type'] || empty( $filter['buckets'] ) ) {
				$modified[ $filter_key ] = $filter;
				continue;
			}

			foreach ( (array) $filter['buckets'] as $bucket_key => $bucket ) {
				if ( empty( $bucket['remove_url'] ) ) {
					continue;
				}

				$parsed = wp_parse_url( $bucket['remove_url'] );
				if ( ! $parsed ) {
					continue;
				}

				$query = array();
				if ( ! empty( $parsed['query'] ) ) {
					wp_parse_str( $parsed['query'], $query );
				}

				if ( empty( $query['post_type'] ) ) {
					$modified[ $filter_key ]['buckets'][ $bucket_key ]['remove_url'] = self::add_post_types_to_url(
						$bucket['remove_url'],
						$post_types
					);
				}
			}
		}

		return $modified;
	}

	/**
	 * Given an array of filters or active buckets, will filter out any that are post types.
	 *
	 * @param array $filters The array of filters or active buckets.
	 * @return array
	 */
	public static function filter_post_types( $filters ) {
		$no_post_types = array();

		foreach ( (array) $filters as $key => $filter ) {
			if ( empty( $filter['type'] ) || 'post_type' !== $filter['type'] ) {
				if ( is_int( $key ) ) {
					$no_post_types[] = $filter;
				} else {
					$no_post_types[ $key ] = $filter;
				}
			}
		}

		return $no_post_types;
	}

	/**
	 * Returns a boolen for whether the current site has a VIP index.
	 *
	 * @return bool
	 */
	public static function site_has_vip_index() {
		$has_vip_index = (
			Jetpack_Constants::is_defined( 'JETPACK_SEARCH_VIP_INDEX' ) &&
			Jetpack_Constants::get_constant( 'JETPACK_SEARCH_VIP_INDEX' )
		);

		/**
		 * Allows developers to filter whether the current site has a VIP index.
		 *
		 * @module search
		 *
		 * @since 5.8.0
		 *
		 * @param bool $has_vip_index Whether the current site has a VIP index.
		 */
		return apply_filters( 'jetpack_search_has_vip_index', $has_vip_index );
	}

	/**
	 * Returns the maximum posts per page for a search query
	 *
	 * @return int
	 */
	public static function get_max_posts_per_page() {
		return self::site_has_vip_index() ? 1000 : 100;
	}

	/**
	 * Returns the maximum offset for a search query
	 *
	 * @return int
	 */
	public static function get_max_offset() {
		return self::site_has_vip_index() ? 9000 : 1000;
	}
}


1		<?php
2
3		class Jetpack_Search_Helpers {
4		const FILTER_WIDGET_BASE = 'jetpack-search-filters';
5
6		static function get_search_url() {
7		$query_args = $_GET;
8
9		// Handle the case where a permastruct is being used, such as /search/{$query}
10		if ( ! isset( $query_args['s'] ) ) {
11		$query_args['s'] = get_search_query();
12		}
13
14		if ( isset( $query_args['paged'] ) ) {
15		unset( $query_args['paged'] );
16		}
17
18		$query = http_build_query( $query_args );
19		return home_url( "?{$query}" );
20		}
21
22		static function add_query_arg( $key, $value = false, $url = false ) {
23		$url = empty( $url ) ? self::get_search_url() : $url;
24		if ( is_array( $key ) ) {
25		return add_query_arg( $key, $url );
26		}
27
28		return add_query_arg( $key, $value, $url );
29		}
30
31		static function remove_query_arg( $key, $url = false ) {
32		$url = empty( $url ) ? self::get_search_url() : $url;
33		return remove_query_arg( $key, $url );
34		}
35
36		static function get_widget_option_name() {
37		return sprintf( 'widget_%s', self::FILTER_WIDGET_BASE );
38		}
39
40		static function get_widgets_from_option() {
41		$widget_options = get_option( self::get_widget_option_name(), array() );
42
43		// We don't need this
44		if ( ! empty( $widget_options ) && isset( $widget_options['_multiwidget'] ) ) {
45		unset( $widget_options['_multiwidget'] );
46		}
47
48		return $widget_options;
49		}
50
51		static function build_widget_id( $number ) {
52		return sprintf( '%s-%d', self::FILTER_WIDGET_BASE, $number );
53		}
54
55		static function is_active_widget( $widget_id ) {
56		return (bool) is_active_widget( false, $widget_id, self::FILTER_WIDGET_BASE );
57		}
58
59		static function get_filters_from_widgets() {
60		$filters = array();
61
62		$widget_options = self::get_widgets_from_option();
63		if ( empty( $widget_options ) ) {
64		return $filters;
65		}
66
67		foreach ( (array) $widget_options as $number => $settings ) {
68		$widget_id = self::build_widget_id( $number );
69		if ( ! self::is_active_widget( $widget_id ) \|\| empty( $settings['filters'] ) ) {
70		continue;
71		}
72
73		foreach ( (array) $settings['filters'] as $widget_filter ) {
74		$widget_filter['widget_id'] = $widget_id;
75		$key = sprintf( '%s_%d', $widget_filter['type'], count( $filters ) );
76
77		if ( empty( $widget_filter['name'] ) ) {
78		$widget_filter['name'] = self::generate_widget_filter_name( $widget_filter );
79		}
80
81		$filters[ $key ] = $widget_filter;
82		}
83		}
84
85		return $filters;
86		}
87
88		static function generate_widget_filter_name( $widget_filter ) {
89		$name = '';
90
91		switch ( $widget_filter['type'] ) {
92		case 'post_type':
93		$name = _x( 'Post Types', 'label for filtering posts', 'jetpack' );
94		break;
95		case 'date_histogram':
96		switch ( $widget_filter['field'] ) {
97		case 'post_date':
98	View Code Duplication	case 'post_date_gmt':
99		switch ( $widget_filter['interval'] ) {
100		case 'month':
101		$name = _x( 'Month', 'label for filtering posts', 'jetpack' );
102		break;
103		case 'year':
104		$name = _x( 'Year', 'label for filtering posts', 'jetpack' );
105		break;
106		}
107		break;
108		case 'post_modified':
109	View Code Duplication	case 'post_modified_gmt':
110		switch ( $widget_filter['interval'] ) {
111		case 'month':
112		$name = _x( 'Month Updated', 'label for filtering posts', 'jetpack' );
113		break;
114		case 'year':
115		$name = _x( 'Year Updated', 'label for filtering posts', 'jetpack' );
116		break;
117		}
118		break;
119		}
120		break;
121		case 'taxonomy':
122		$tax = get_taxonomy( $widget_filter['taxonomy'] );
123		if ( ! $tax ) {
124		break;
125		}
126
127		if ( isset( $tax->label ) ) {
128		$name = $tax->label;
129		} else if ( isset( $tax->labels ) && isset( $tax->labels->name ) ) {
130		$name = $tax->labels->name;
131		}
132		break;
133		}
134
135		return $name;
136		}
137
138		/**
139		* Whether we should rerun a search in the customizer preview or not.
140		*
141		* @since 5.8.0
142		*
143		* @return bool
144		*/
145		static function should_rerun_search_in_customizer_preview() {
146		// Only update when in a customizer preview and data is being posted.
147		// Check for $_POST removes an extra update when the customizer loads.
148		//
149		// Note: We use $GLOBALS['wp_customize'] here instead of is_customize_preview() to support unit tests.
150		if ( ! isset( $GLOBALS['wp_customize'] ) \|\| ! $GLOBALS['wp_customize']->is_preview() \|\| empty( $_POST ) ) {
151		return false;
152		}
153
154		return true;
155		}
156
157		/**
158		* Since PHP's built-in array_diff() works by comparing the values that are in array 1 to the other arrays,
159		* if there are less values in array 1, it's possible to get an empty diff where one might be expected.
160		*
161		* @since 5.8.0
162		*
163		* @param array $array_1
164		* @param array $array_2
165		*
166		* @return array
167		*/
168		static function array_diff( $array_1, $array_2 ) {
169		// If the array counts are the same, then the order doesn't matter. If the count of
170		// $array_1 is higher than $array_2, that's also fine. If the count of $array_2 is higher,
171		// we need to swap the array order though.
172		if ( count( $array_1 ) != count( $array_2 ) && count( $array_2 ) > count( $array_1 ) ) {
173		$temp = $array_1;
174		$array_1 = $array_2;
175		$array_2 = $temp;
176		}
177
178		// Disregard keys
179		return array_values( array_diff( $array_1, $array_2 ) );
180		}
181
182		/**
183		* Given the widget instance, will return true when selected post types differ from searchable post types.
184		*
185		* @since 5.8.0
186		*
187		* @param array $instance
188		* @return bool
189		*/
190		static function post_types_differ_searchable( $instance ) {
191		if ( empty( $instance['post_types'] ) ) {
192		return false;
193		}
194
195		$searchable_post_types = get_post_types( array( 'exclude_from_search' => false ) );
196		$diff_of_searchable = self::array_diff( $searchable_post_types, (array) $instance['post_types'] );
197
198		return ! empty( $diff_of_searchable );
199		}
200
201		/**
202		* Given the widget instance, will return true when selected post types differ from the post type filters
203		* applied to the search.
204		*
205		* @since 5.8.0
206		*
207		* @param array $instance
208		* @return bool
209		*/
210		static function post_types_differ_query( $instance ) {
211		if ( empty( $instance['post_types'] ) ) {
212		return false;
213		}
214
215		if ( empty( $_GET['post_type'] ) ) {
216		$post_types_from_query = array();
217		} else if ( is_array( $_GET['post_type'] ) ) {
218		$post_types_from_query = $_GET['post_type'];
219		} else {
220		$post_types_from_query = (array) explode( ',', $_GET['post_type'] );
221		}
222
223		$post_types_from_query = array_map( 'trim', $post_types_from_query );
224
225		$diff_query = self::array_diff( (array) $instance['post_types'], $post_types_from_query );
226		return ! empty( $diff_query );
227		}
228
229		static function get_widget_tracks_value( $old_value, $new_value ) {
230		$old_value = (array) $old_value;
231		if ( isset( $old_value['_multiwidget'] ) ) {
232		unset( $old_value['_multiwidget'] );
233		}
234
235		$new_value = (array) $new_value;
236		if ( isset( $new_value['_multiwidget'] ) ) {
237		unset( $new_value['_multiwidget'] );
238		}
239
240		$action = '';
		0 ignored issues – show Unused Code introduced 2018-01-23 22:50 UTC by Report Bug Copy Issue Report `$action` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
241		$old_keys = array_keys( $old_value );
242		$new_keys = array_keys( $new_value );
243
244		if ( count( $new_keys ) > count( $old_keys ) ) { // This is the case for a widget being added
245		$diff = self::array_diff( $new_keys, $old_keys );
246		$action = 'widget_added';
247		$widget = empty( $diff ) \|\| ! isset( $new_value[ $diff[0] ] )
248		? false
249		: $new_value[ $diff[0] ];
250		} else if ( count( $old_keys ) > count( $new_keys ) ) { // This is the case for a widget being deleted
251		$diff = self::array_diff( $old_keys, $new_keys );
252		$action = 'widget_deleted';
253		$widget = empty( $diff ) \|\| ! isset( $old_value[ $diff[0] ] )
254		? false
255		: $old_value[ $diff[0] ];
256		} else {
257		$action = 'widget_updated';
258		$widget = false;
259
260		// This is a bit crazy. Since there can be multiple widgets stored in a single option,
261		// we need to diff the old and new values to figure out which widget was updated.
262		foreach ( $new_value as $key => $new_instance ) {
263		if ( ! isset( $old_value[ $key ] ) ) {
264		continue;
265		}
266		$old_instance = $old_value[ $key ];
267
268		// First, let's test the keys of each instance
269		$diff = self::array_diff( array_keys( $new_instance ), array_keys( $old_instance ) );
270		if ( ! empty( $diff ) ) {
271		$widget = $new_instance;
272		break;
273		}
274
275		// Next, lets's loop over each value and compare it
276		foreach ( $new_instance as $k => $v ) {
277		if ( is_scalar( $v ) && (string) $v !== (string) $old_instance[ $k ] ) {
278		$widget = $new_instance;
279		break;
280		}
281
282		if ( 'filters' == $k ) {
283		if ( count( $new_instance['filters'] ) != count( $old_instance['filters'] ) ) {
284		$widget = $new_instance;
285		break;
286		}
287
288		foreach ( $v as $filter_key => $new_filter_value ) {
289		$diff = self::array_diff( $new_filter_value, $old_instance[ 'filters' ][ $filter_key ] );
290		if ( ! empty( $diff ) ) {
291		$widget = $new_instance;
292		break;
293		}
294		}
295		}
296		}
297		}
298		}
299
300		if ( empty( $action ) \|\| empty( $widget ) ) {
301		return false;
302		}
303
304		return array(
305		'action' => $action,
306		'widget' => self::get_widget_properties_for_tracks( $widget ),
307		);
308		}
309
310		static function get_widget_properties_for_tracks( $widget ) {
311		$sanitized = array();
312
313		foreach ( (array) $widget as $key => $value ) {
314		if ( '_multiwidget' == $key ) {
315		continue;
316		}
317		if ( is_scalar( $value ) ) {
318		$key = str_replace( '-', '_', sanitize_key( $key ) );
319		$key = "widget_{$key}";
320		$sanitized[ $key ] = $value;
321		}
322		}
323
324		$filters_properties = ! empty( $widget['filters'] )
325		? self::get_filter_properties_for_tracks( $widget['filters'] )
326		: array();
327
328		return array_merge( $sanitized, $filters_properties );
329		}
330
331		static function get_filter_properties_for_tracks( $filters ) {
332		if ( empty( $filters ) ) {
333		return $filters;
334		}
335
336		$filters_properties = array(
337		'widget_filter_count' => count( $filters ),
338		);
339
340		foreach ( $filters as $filter ) {
341		if ( empty( $filter['type'] ) ) {
342		continue;
343		}
344
345		$key = sprintf( 'widget_filter_type_%s', $filter['type'] );
346		if ( isset( $filters_properties[ $key ] ) ) {
347		$filters_properties[ $key ]++;
348		} else {
349		$filters_properties[ $key ] = 1;
350		}
351		}
352
353		return $filters_properties;
354		}
355
356		/**
357		* Gets the active post types given a set of filters.
358		*
359		* @param array $filters The active filters for the current query.
360		* @param array $default_post_types The default post types.
361		*
362		* @return array
363		*/
364		public static function get_active_post_types( $filters, $default_post_types ) {
365		$active_post_types = array();
366		foreach( $filters as $item ) {
367		if ( ( 'post_type' == $item['type'] ) && isset( $item['query_vars']['post_type'] ) ) {
368		$active_post_types[] = $item['query_vars']['post_type'];
369		}
370		}
371		return $active_post_types;
372		}
373
374		/**
375		* Sets active to false on all post type buckets.
376		*
377		* @param array $filters The available filters for the current query.
378		*
379		* @return array $modified The filters for the current query with modified active field.
380		*/
381		public static function remove_active_from_post_type_buckets( $filters ) {
382		$modified = $filters;
383		foreach ( $filters as $key => $filter ) {
384		if ( 'post_type' === $filter['type'] && ! empty( $filter['buckets'] ) ) {
385		foreach ( $filter['buckets'] as $k => $bucket ) {
386		$bucket['active'] = false;
387		$modified[ $key ]['buckets'][ $k ] = $bucket;
388		}
389		}
390		}
391
392		return $modified;
393		}
394
395		/**
396		* Given a url and an array of post types, will ensure that the post types are properly applied to the URL as args.
397		*
398		* @param string $url The URL to add post types to.
399		* @param array $post_types An array of post types that should be added to the URL.
400		*
401		* @return string $url The URL with added post types.
402		*/
403		public static function add_post_types_to_url( $url, $post_types ) {
404		$url = Jetpack_Search_Helpers::remove_query_arg( 'post_type', $url );
		0 ignored issues – show Documentation introduced 2018-01-25 02:03 UTC by Report Bug Copy Issue Report `$url` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
405		if ( empty( $post_types ) ) {
406		return $url;
407		}
408
409		$url = Jetpack_Search_Helpers::add_query_arg(
410		'post_type',
411		implode( ',', $post_types ),
		0 ignored issues – show Documentation introduced 2018-01-19 01:21 UTC by Report Bug Copy Issue Report `implode(',', $post_types)` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
412		$url
413		);
414
415		return $url;
416		}
417
418		/**
419		* Since we provide support for the widget restricting post types by adding the selected post types as
420		* active filters, if removing a post type filter would result in there no longer be post_type args in the URL,
421		* we need to be sure to add them back.
422		*
423		* @param array $filters An array of possible filters for the current query.
424		* @param array $post_types The post types to ensure are on the link.
425		*
426		* @return array $modified The updated array of filters with post typed added to the remove URLs.
427		*/
428		public static function ensure_post_types_on_remove_url( $filters, $post_types ) {
429		$modified = $filters;
430
431		foreach ( (array) $filters as $filter_key => $filter ) {
432		if ( 'post_type' !== $filter['type'] \|\| empty( $filter['buckets'] ) ) {
433		$modified[ $filter_key ] = $filter;
434		continue;
435		}
436
437		foreach ( (array) $filter['buckets'] as $bucket_key => $bucket ) {
438		if ( empty( $bucket['remove_url'] ) ) {
439		continue;
440		}
441
442		$parsed = wp_parse_url( $bucket['remove_url'] );
443		if ( ! $parsed ) {
444		continue;
445		}
446
447		$query = array();
448		if ( ! empty( $parsed['query'] ) ) {
449		wp_parse_str( $parsed['query'], $query );
450		}
451
452		if ( empty( $query['post_type'] ) ) {
453		$modified[ $filter_key ]['buckets'][ $bucket_key ]['remove_url'] = self::add_post_types_to_url(
454		$bucket['remove_url'],
455		$post_types
456		);
457		}
458		}
459		}
460
461		return $modified;
462		}
463
464		/**
465		* Given an array of filters or active buckets, will filter out any that are post types.
466		*
467		* @param array $filters The array of filters or active buckets.
468		* @return array
469		*/
470		public static function filter_post_types( $filters ) {
471		$no_post_types = array();
472
473		foreach ( (array) $filters as $key => $filter ) {
474		if ( empty( $filter['type'] ) \|\| 'post_type' !== $filter['type'] ) {
475		if ( is_int( $key ) ) {
476		$no_post_types[] = $filter;
477		} else {
478		$no_post_types[ $key ] = $filter;
479		}
480		}
481		}
482
483		return $no_post_types;
484		}
485
486		/**
487		* Returns a boolen for whether the current site has a VIP index.
488		*
489		* @return bool
490		*/
491		public static function site_has_vip_index() {
492		$has_vip_index = (
493		Jetpack_Constants::is_defined( 'JETPACK_SEARCH_VIP_INDEX' ) &&
494		Jetpack_Constants::get_constant( 'JETPACK_SEARCH_VIP_INDEX' )
495		);
496
497		/**
498		* Allows developers to filter whether the current site has a VIP index.
499		*
500		* @module search
501		*
502		* @since 5.8.0
503		*
504		* @param bool $has_vip_index Whether the current site has a VIP index.
505		*/
506		return apply_filters( 'jetpack_search_has_vip_index', $has_vip_index );
507		}
508
509		/**
510		* Returns the maximum posts per page for a search query
511		*
512		* @return int
513		*/
514		public static function get_max_posts_per_page() {
515		return self::site_has_vip_index() ? 1000 : 100;
516		}
517
518		/**
519		* Returns the maximum offset for a search query
520		*
521		* @return int
522		*/
523		public static function get_max_offset() {
524		return self::site_has_vip_index() ? 9000 : 1000;
525		}
526		}
527

Automattic / jetpack

Push — update/search-ui-tweaks-kelly ( 8fa975...afc6a9 )

Jetpack_Search_Helpers::get_widgets_from_option() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like