← All changes | libraries/cmb2/includes/CMB2_Utils.php +764 -0 5.7.4 → 6.0.3 View file →

		@@ -1,0 +1,764 @@
	1	+<?php
	2	+/**
	3	+ * CMB2 Utilities
	4	+ *
	5	+ * @since 1.1.0
	6	+ *
	7	+ * @category WordPress_Plugin
	8	+ * @package CMB2
	9	+ * @author CMB2 team
	10	+ * @license GPL-2.0+
	11	+ * @link https://cmb2.io
	12	+ */
	13	+class CMB2_Utils {
	14	+
	15	+ /**
	16	+ * The WordPress ABSPATH constant.
	17	+ *
	18	+ * @var string
	19	+ * @since 2.2.3
	20	+ */
	21	+ protected static $ABSPATH = ABSPATH;
	22	+
	23	+ /**
	24	+ * The url which is used to load local resources.
	25	+ *
	26	+ * @var string
	27	+ * @since 2.0.0
	28	+ */
	29	+ protected static $url = '';
	30	+
	31	+ /**
	32	+ * Utility method that attempts to get an attachment's ID by it's url
	33	+ *
	34	+ * @since 1.0.0
	35	+ * @param string $img_url Attachment url.
	36	+ * @return int|false Attachment ID or false
	37	+ */
	38	+ public static function image_id_from_url( $img_url ) {
	39	+ $attachment_id = 0;
	40	+ $dir = wp_upload_dir();
	41	+
	42	+ // Is URL in uploads directory?
	43	+ if ( false === strpos( $img_url, $dir['baseurl'] . '/' ) ) {
	44	+ return false;
	45	+ }
	46	+
	47	+ $file = basename( $img_url );
	48	+
	49	+ $query_args = array(
	50	+ 'post_type' => 'attachment',
	51	+ 'post_status' => 'inherit',
	52	+ 'fields' => 'ids',
	53	+ 'meta_query' => array( // phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_query -- Required to resolve an attachment ID from its file URL; no non-meta alternative.
	54	+ array(
	55	+ 'value' => $file,
	56	+ 'compare' => 'LIKE',
	57	+ 'key' => '_wp_attachment_metadata',
	58	+ ),
	59	+ ),
	60	+ );
	61	+
	62	+ $query = new WP_Query( $query_args );
	63	+
	64	+ if ( $query->have_posts() ) {
	65	+
	66	+ foreach ( $query->posts as $post_id ) {
	67	+ $meta = wp_get_attachment_metadata( $post_id );
	68	+ $original_file = basename( $meta['file'] );
	69	+ $cropped_image_files = isset( $meta['sizes'] ) ? wp_list_pluck( $meta['sizes'], 'file' ) : array();
	70	+ if ( $original_file === $file || in_array( $file, $cropped_image_files ) ) {
	71	+ $attachment_id = $post_id;
	72	+ break;
	73	+ }
	74	+ }
	75	+ }
	76	+
	77	+ return 0 === $attachment_id ? false : $attachment_id;
	78	+ }
	79	+
	80	+ /**
	81	+ * Utility method to get a combined list of default and custom registered image sizes
	82	+ *
	83	+ * @since 2.2.4
	84	+ * @link http://core.trac.wordpress.org/ticket/18947
	85	+ * @global array $_wp_additional_image_sizes
	86	+ * @return array The image sizes
	87	+ */
	88	+ public static function get_available_image_sizes() {
	89	+ global $_wp_additional_image_sizes;
	90	+
	91	+ $default_image_sizes = array( 'thumbnail', 'medium', 'large' );
	92	+ $image_sizes = array();
	93	+ foreach ( $default_image_sizes as $size ) {
	94	+ $image_sizes[ $size ] = array(
	95	+ 'height' => intval( get_option( "{$size}_size_h" ) ),
	96	+ 'width' => intval( get_option( "{$size}_size_w" ) ),
	97	+ 'crop' => get_option( "{$size}_crop" ) ? get_option( "{$size}_crop" ) : false,
	98	+ );
	99	+ }
	100	+
	101	+ if ( isset( $_wp_additional_image_sizes ) && count( $_wp_additional_image_sizes ) ) {
	102	+ $image_sizes = array_merge( $image_sizes, $_wp_additional_image_sizes );
	103	+ }
	104	+
	105	+ return $image_sizes;
	106	+ }
	107	+
	108	+ /**
	109	+ * Utility method to return the closest named size from an array of values
	110	+ *
	111	+ * Based off of WordPress's image_get_intermediate_size()
	112	+ * If the size matches an existing size then it will be used. If there is no
	113	+ * direct match, then the nearest image size larger than the specified size
	114	+ * will be used. If nothing is found, then the function will return false.
	115	+ * Uses get_available_image_sizes() to get all available sizes.
	116	+ *
	117	+ * @since 2.2.4
	118	+ * @param array|string $size Image size. Accepts an array of width and height (in that order).
	119	+ * @return false|string Named image size e.g. 'thumbnail'
	120	+ */
	121	+ public static function get_named_size( $size ) {
	122	+ $data = array();
	123	+
	124	+ // Find the best match when '$size' is an array.
	125	+ if ( is_array( $size ) ) {
	126	+ $image_sizes = self::get_available_image_sizes();
	127	+ $candidates = array();
	128	+
	129	+ foreach ( $image_sizes as $_size => $data ) {
	130	+
	131	+ // If there's an exact match to an existing image size, short circuit.
	132	+ if ( $data['width'] == $size[0] && $data['height'] == $size[1] ) {
	133	+ $candidates[ $data['width'] * $data['height'] ] = array( $_size, $data );
	134	+ break;
	135	+ }
	136	+
	137	+ // If it's not an exact match, consider larger sizes with the same aspect ratio.
	138	+ if ( $data['width'] >= $size[0] && $data['height'] >= $size[1] ) {
	139	+
	140	+ /**
	141	+ * To test for varying crops, we constrain the dimensions of the larger image
	142	+ * to the dimensions of the smaller image and see if they match.
	143	+ */
	144	+ if ( $data['width'] > $size[0] ) {
	145	+ $constrained_size = wp_constrain_dimensions( $data['width'], $data['height'], $size[0] );
	146	+ $expected_size = array( $size[0], $size[1] );
	147	+ } else {
	148	+ $constrained_size = wp_constrain_dimensions( $size[0], $size[1], $data['width'] );
	149	+ $expected_size = array( $data['width'], $data['height'] );
	150	+ }
	151	+
	152	+ // If the image dimensions are within 1px of the expected size, we consider it a match.
	153	+ $matched = ( abs( $constrained_size[0] - $expected_size[0] ) <= 1 && abs( $constrained_size[1] - $expected_size[1] ) <= 1 );
	154	+
	155	+ if ( $matched ) {
	156	+ $candidates[ $data['width'] * $data['height'] ] = array( $_size, $data );
	157	+ }
	158	+ }
	159	+ }
	160	+
	161	+ if ( ! empty( $candidates ) ) {
	162	+ // Sort the array by size if we have more than one candidate.
	163	+ if ( 1 < count( $candidates ) ) {
	164	+ ksort( $candidates );
	165	+ }
	166	+
	167	+ $data = array_shift( $candidates );
	168	+ $data = $data[0];
	169	+ } elseif ( ! empty( $image_sizes['thumbnail'] ) && $image_sizes['thumbnail']['width'] >= $size[0] && $image_sizes['thumbnail']['width'] >= $size[1] ) {
	170	+ /*
	171	+ * When the size requested is smaller than the thumbnail dimensions, we
	172	+ * fall back to the thumbnail size.
	173	+ */
	174	+ $data = 'thumbnail';
	175	+ } else {
	176	+ return false;
	177	+ }
	178	+ } elseif ( ! empty( $image_sizes[ $size ] ) ) {
	179	+ $data = $size;
	180	+ }// End if.
	181	+
	182	+ // If we still don't have a match at this point, return false.
	183	+ if ( empty( $data ) ) {
	184	+ return false;
	185	+ }
	186	+
	187	+ return $data;
	188	+ }
	189	+
	190	+ /**
	191	+ * Utility method that returns time string offset by timezone
	192	+ *
	193	+ * @since 1.0.0
	194	+ * @param string $tzstring Time string.
	195	+ * @return string Offset time string
	196	+ */
	197	+ public static function timezone_offset( $tzstring ) {
	198	+ $tz_offset = 0;
	199	+
	200	+ if ( ! empty( $tzstring ) && is_string( $tzstring ) ) {
	201	+ if ( 'UTC' === substr( $tzstring, 0, 3 ) ) {
	202	+ $tzstring = str_replace( array( ':15', ':30', ':45' ), array( '.25', '.5', '.75' ), $tzstring );
	203	+ return intval( floatval( substr( $tzstring, 3 ) ) * HOUR_IN_SECONDS );
	204	+ }
	205	+
	206	+ try {
	207	+ $date_time_zone_selected = new DateTimeZone( $tzstring );
	208	+ $tz_offset = timezone_offset_get( $date_time_zone_selected, date_create() );
	209	+ } catch ( Exception $e ) {
	210	+ self::log_if_debug( __METHOD__, __LINE__, $e->getMessage() );
	211	+ }
	212	+ }
	213	+
	214	+ return $tz_offset;
	215	+ }
	216	+
	217	+ /**
	218	+ * Utility method that returns a timezone string representing the default timezone for the site.
	219	+ *
	220	+ * Roughly copied from WordPress, as get_option('timezone_string') will return
	221	+ * an empty string if no value has been set on the options page.
	222	+ * A timezone string is required by the wp_timezone_choice() used by the
	223	+ * select_timezone field.
	224	+ *
	225	+ * @since 1.0.0
	226	+ * @return string Timezone string
	227	+ */
	228	+ public static function timezone_string() {
	229	+ $current_offset = get_option( 'gmt_offset' );
	230	+ $tzstring = get_option( 'timezone_string' );
	231	+
	232	+ // Remove old Etc mappings. Fallback to gmt_offset.
	233	+ if ( false !== strpos( $tzstring, 'Etc/GMT' ) ) {
	234	+ $tzstring = '';
	235	+ }
	236	+
	237	+ if ( empty( $tzstring ) ) { // Create a UTC+- zone if no timezone string exists.
	238	+ if ( 0 == $current_offset ) {
	239	+ $tzstring = 'UTC+0';
	240	+ } elseif ( $current_offset < 0 ) {
	241	+ $tzstring = 'UTC' . $current_offset;
	242	+ } else {
	243	+ $tzstring = 'UTC+' . $current_offset;
	244	+ }
	245	+ }
	246	+
	247	+ return $tzstring;
	248	+ }
	249	+
	250	+ /**
	251	+ * Returns a unix timestamp, first checking if value already is a timestamp.
	252	+ *
	253	+ * @since 2.0.0
	254	+ * @param string|int $string Possible timestamp string.
	255	+ * @return int Time stamp.
	256	+ */
	257	+ public static function make_valid_time_stamp( $string ) {
	258	+ if ( ! $string ) {
	259	+ return 0;
	260	+ }
	261	+
	262	+ $valid = self::is_valid_time_stamp( $string );
	263	+ if ( $valid ) {
	264	+ $timestamp = (int) $string;
	265	+ $length = strlen( (string) $timestamp );
	266	+ $unixlength = strlen( (string) time() );
	267	+ $diff = $length - $unixlength;
	268	+
	269	+ // If value is larger than a unix timestamp, we need to round to the
	270	+ // nearest unix timestamp (in seconds).
	271	+ if ( $diff > 0 ) {
	272	+ $divider = (int) '1' . str_repeat( '0', $diff );
	273	+ $timestamp = round( $timestamp / $divider );
	274	+ }
	275	+ } else {
	276	+ $timestamp = @strtotime( (string) $string ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged -- Intentionally suppress notices on arbitrary input; false return is the error check.
	277	+ }
	278	+
	279	+ return $timestamp;
	280	+ }
	281	+
	282	+ /**
	283	+ * Determine if a value is a valid date.
	284	+ *
	285	+ * @since 2.9.1
	286	+ * @param mixed $date Value to check.
	287	+ * @return boolean Whether value is a valid date
	288	+ */
	289	+ public static function is_valid_date( $date ) {
	290	+ // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged -- Intentionally suppress notices on arbitrary input; the boolean result is the validity check.
	291	+ return ( is_string( $date ) && @strtotime( $date ) )
	292	+ || self::is_valid_time_stamp( $date );
	293	+ }
	294	+
	295	+ /**
	296	+ * Determine if a value is a valid timestamp
	297	+ *
	298	+ * @since 2.0.0
	299	+ * @param mixed $timestamp Value to check.
	300	+ * @return boolean Whether value is a valid timestamp
	301	+ */
	302	+ public static function is_valid_time_stamp( $timestamp ) {
	303	+ return (string) (int) $timestamp === (string) $timestamp
	304	+ && $timestamp <= PHP_INT_MAX
	305	+ && $timestamp >= ~PHP_INT_MAX;
	306	+ }
	307	+
	308	+ /**
	309	+ * Checks if a value is 'empty'. Still accepts 0.
	310	+ *
	311	+ * @since 2.0.0
	312	+ * @param mixed $value Value to check.
	313	+ * @return bool True or false
	314	+ */
	315	+ public static function isempty( $value ) {
	316	+ return null === $value || '' === $value || false === $value || array() === $value;
	317	+ }
	318	+
	319	+ /**
	320	+ * Checks if a value is not 'empty'. 0 doesn't count as empty.
	321	+ *
	322	+ * @since 2.2.2
	323	+ * @param mixed $value Value to check.
	324	+ * @return bool True or false
	325	+ */
	326	+ public static function notempty( $value ) {
	327	+ return null !== $value && '' !== $value && false !== $value && array() !== $value;
	328	+ }
	329	+
	330	+ /**
	331	+ * Filters out empty values (not including 0).
	332	+ *
	333	+ * @since 2.2.2
	334	+ * @param mixed $value Value to check.
	335	+ * @return array True or false.
	336	+ */
	337	+ public static function filter_empty( $value ) {
	338	+ return array_filter( $value, array( __CLASS__, 'notempty' ) );
	339	+ }
	340	+
	341	+ /**
	342	+ * Insert a single array item inside another array at a set position
	343	+ *
	344	+ * @since 2.0.2
	345	+ * @param array $array Array to modify. Is passed by reference, and no return is needed. Passed by reference.
	346	+ * @param array $new New array to insert.
	347	+ * @param int $position Position in the main array to insert the new array.
	348	+ */
	349	+ public static function array_insert( &$array, $new, $position ) {
	350	+ $before = array_slice( $array, 0, $position - 1 );
	351	+ $after = array_diff_key( $array, $before );
	352	+ $array = array_merge( $before, $new, $after );
	353	+ }
	354	+
	355	+ /**
	356	+ * Defines the url which is used to load local resources.
	357	+ * This may need to be filtered for local Window installations.
	358	+ * If resources do not load, please check the wiki for details.
	359	+ *
	360	+ * @since 1.0.1
	361	+ *
	362	+ * @param string $path URL path.
	363	+ * @return string URL to CMB2 resources
	364	+ */
	365	+ public static function url( $path = '' ) {
	366	+ if ( self::$url ) {
	367	+ return self::$url . $path;
	368	+ }
	369	+
	370	+ $cmb2_url = self::get_url_from_dir( cmb2_dir() );
	371	+
	372	+ /**
	373	+ * Filter the CMB location url.
	374	+ *
	375	+ * @param string $cmb2_url Currently registered url.
	376	+ */
	377	+ self::$url = trailingslashit( apply_filters( 'cmb2_meta_box_url', $cmb2_url, CMB2_VERSION ) );
	378	+
	379	+ return self::$url . $path;
	380	+ }
	381	+
	382	+ /**
	383	+ * Converts a system path to a URL
	384	+ *
	385	+ * @since 2.2.2
	386	+ * @param string $dir Directory path to convert.
	387	+ * @return string Converted URL.
	388	+ */
	389	+ public static function get_url_from_dir( $dir ) {
	390	+ $dir = self::normalize_path( $dir );
	391	+
	392	+ // Let's test if We are in the plugins or mu-plugins dir.
	393	+ $test_dir = trailingslashit( $dir ) . 'unneeded.php';
	394	+ if (
	395	+ 0 === strpos( $test_dir, self::normalize_path( WPMU_PLUGIN_DIR ) )
	396	+ || 0 === strpos( $test_dir, self::normalize_path( WP_PLUGIN_DIR ) )
	397	+ ) {
	398	+ // Ok, then use plugins_url, as it is more reliable.
	399	+ return trailingslashit( plugins_url( '', $test_dir ) );
	400	+ }
	401	+
	402	+ // Ok, now let's test if we are in the theme dir.
	403	+ $theme_root = self::normalize_path( get_theme_root() );
	404	+ if ( 0 === strpos( $dir, $theme_root ) ) {
	405	+ // Ok, then use get_theme_root_uri.
	406	+ return set_url_scheme(
	407	+ trailingslashit(
	408	+ str_replace(
	409	+ untrailingslashit( $theme_root ),
	410	+ untrailingslashit( get_theme_root_uri() ),
	411	+ $dir
	412	+ )
	413	+ )
	414	+ );
	415	+ }
	416	+
	417	+ // Check to see if it's anywhere in the root directory.
	418	+ $site_dir = self::get_normalized_abspath();
	419	+ $site_url = trailingslashit( is_multisite() ? network_site_url() : site_url() );
	420	+
	421	+ $url = str_replace(
	422	+ array( $site_dir, WP_PLUGIN_DIR ),
	423	+ array( $site_url, WP_PLUGIN_URL ),
	424	+ $dir
	425	+ );
	426	+
	427	+ return set_url_scheme( $url );
	428	+ }
	429	+
	430	+ /**
	431	+ * Get the normalized absolute path defined by WordPress.
	432	+ *
	433	+ * @since 2.2.6
	434	+ *
	435	+ * @return string Normalized absolute path.
	436	+ */
	437	+ protected static function get_normalized_abspath() {
	438	+ return self::normalize_path( self::$ABSPATH );
	439	+ }
	440	+
	441	+ /**
	442	+ * `wp_normalize_path` wrapper for back-compat. Normalize a filesystem path.
	443	+ *
	444	+ * On windows systems, replaces backslashes with forward slashes
	445	+ * and forces upper-case drive letters.
	446	+ * Allows for two leading slashes for Windows network shares, but
	447	+ * ensures that all other duplicate slashes are reduced to a single.
	448	+ *
	449	+ * @since 2.2.0
	450	+ *
	451	+ * @param string $path Path to normalize.
	452	+ * @return string Normalized path.
	453	+ */
	454	+ protected static function normalize_path( $path ) {
	455	+ if ( function_exists( 'wp_normalize_path' ) ) {
	456	+ return wp_normalize_path( $path );
	457	+ }
	458	+
	459	+ // Replace newer WP's version of wp_normalize_path.
	460	+ $path = str_replace( '\\', '/', $path );
	461	+ $path = preg_replace( '|(?<=.)/+|', '/', $path );
	462	+ if ( ':' === substr( $path, 1, 1 ) ) {
	463	+ $path = ucfirst( $path );
	464	+ }
	465	+
	466	+ return $path;
	467	+ }
	468	+
	469	+ /**
	470	+ * Get timestamp from text date
	471	+ *
	472	+ * @since 2.2.0
	473	+ * @param string $value Date value.
	474	+ * @param string $date_format Expected date format.
	475	+ * @return mixed Unix timestamp representing the date.
	476	+ */
	477	+ public static function get_timestamp_from_value( $value, $date_format ) {
	478	+ $date_object = date_create_from_format( $date_format, $value );
	479	+ return $date_object ? $date_object->setTime( 0, 0, 0 )->getTimeStamp() : strtotime( $value );
	480	+ }
	481	+
	482	+ /**
	483	+ * Takes a php date() format string and returns a string formatted to suit for the date/time pickers
	484	+ * It will work only with the following subset of date() options:
	485	+ *
	486	+ * Formats: d, l, j, z, m, F, n, y, and Y.
	487	+ *
	488	+ * A slight effort is made to deal with escaped characters.
	489	+ *
	490	+ * Other options are ignored, because they would either bring compatibility problems between PHP and JS, or
	491	+ * bring even more translation troubles.
	492	+ *
	493	+ * @since 2.2.0
	494	+ * @param string $format PHP date format.
	495	+ * @return string reformatted string
	496	+ */
	497	+ public static function php_to_js_dateformat( $format ) {
	498	+
	499	+ // order is relevant here, since the replacement will be done sequentially.
	500	+ $supported_options = array(
	501	+ 'd' => 'dd', // Day, leading 0.
	502	+ 'j' => 'd', // Day, no 0.
	503	+ 'z' => 'o', // Day of the year, no leading zeroes.
	504	+ // 'D' => 'D', // Day name short, not sure how it'll work with translations.
	505	+ 'l ' => 'DD ', // Day name full, idem before.
	506	+ 'l, ' => 'DD, ', // Day name full, idem before.
	507	+ 'm' => 'mm', // Month of the year, leading 0.
	508	+ 'n' => 'm', // Month of the year, no leading 0.
	509	+ // 'M' => 'M', // Month, Short name.
	510	+ 'F ' => 'MM ', // Month, full name.
	511	+ 'F, ' => 'MM, ', // Month, full name.
	512	+ 'y' => 'y', // Year, two digit.
	513	+ 'Y' => 'yy', // Year, full.
	514	+ 'H' => 'HH', // Hour with leading 0 (24 hour).
	515	+ 'G' => 'H', // Hour with no leading 0 (24 hour).
	516	+ 'h' => 'hh', // Hour with leading 0 (12 hour).
	517	+ 'g' => 'h', // Hour with no leading 0 (12 hour).
	518	+ 'i' => 'mm', // Minute with leading 0.
	519	+ 's' => 'ss', // Second with leading 0.
	520	+ 'a' => 'tt', // am/pm.
	521	+ 'A' => 'TT', // AM/PM.
	522	+ );
	523	+
	524	+ foreach ( $supported_options as $php => $js ) {
	525	+ // replaces every instance of a supported option, but skips escaped characters.
	526	+ $format = preg_replace( "~(?<!\\\\)$php~", $js, $format );
	527	+ }
	528	+
	529	+ $supported_options = array(
	530	+ 'l' => 'DD', // Day name full, idem before.
	531	+ 'F' => 'MM', // Month, full name.
	532	+ );
	533	+
	534	+ if ( isset( $supported_options[ $format ] ) ) {
	535	+ $format = $supported_options[ $format ];
	536	+ }
	537	+
	538	+ $format = preg_replace_callback( '~(?:\\\.)+~', array( __CLASS__, 'wrap_escaped_chars' ), $format );
	539	+
	540	+ return $format;
	541	+ }
	542	+
	543	+ /**
	544	+ * Get a DateTime object from a value.
	545	+ *
	546	+ * @since 2.11.0
	547	+ *
	548	+ * @param string $value The value to convert to a DateTime object.
	549	+ *
	550	+ * @return DateTime|null
	551	+ */
	552	+ public static function get_datetime_from_value( $value ) {
	553	+ return is_serialized( $value )
	554	+ // Ok, we need to unserialize the value
	555	+ // -- allows back-compat for older field values with serialized DateTime objects.
	556	+ ? self::unserialize_datetime( $value )
	557	+ // Handle new json formatted values.
	558	+ : self::json_to_datetime( $value );
	559	+ }
	560	+
	561	+ /**
	562	+ * Unserialize a datetime value string.
	563	+ *
	564	+ * This is a back-compat method for older field values with serialized DateTime objects.
	565	+ *
	566	+ * @since 2.11.0
	567	+ *
	568	+ * @param string $date_value The serialized datetime value.
	569	+ *
	570	+ * @return DateTime|null
	571	+ */
	572	+ public static function unserialize_datetime( $date_value ) {
	573	+ $datetime = @unserialize( trim( $date_value ), array( 'allowed_classes' => array( 'DateTime' ) ) );
	574	+
	575	+ return $datetime && $datetime instanceof DateTime ? $datetime : null;
	576	+ }
	577	+
	578	+ /**
	579	+ * Convert a json datetime value string to a DateTime object.
	580	+ *
	581	+ * @since 2.11.0
	582	+ *
	583	+ * @param string $json_string The json value string.
	584	+ *
	585	+ * @return DateTime|null
	586	+ */
	587	+ public static function json_to_datetime( $json_string ) {
	588	+ if ( ! is_string( $json_string ) ) {
	589	+ return null;
	590	+ }
	591	+
	592	+ $json = json_decode( $json_string );
	593	+
	594	+ // Check if json decode was successful
	595	+ if ( json_last_error() !== JSON_ERROR_NONE ) {
	596	+ return null;
	597	+ }
	598	+
	599	+ // If so, convert to DateTime object.
	600	+ return self::unserialize_datetime( str_replace(
	601	+ 'stdClass',
	602	+ 'DateTime',
	603	+ serialize( $json )
	604	+ ) );
	605	+ }
	606	+
	607	+ /**
	608	+ * Helper function for CMB_Utils::php_to_js_dateformat().
	609	+ *
	610	+ * @since 2.2.0
	611	+ * @param string $value Value to wrap/escape.
	612	+ * @return string Modified value
	613	+ */
	614	+ public static function wrap_escaped_chars( $value ) {
	615	+ return '&#39;' . str_replace( '\\', '', $value[0] ) . '&#39;';
	616	+ }
	617	+
	618	+ /**
	619	+ * Send to debug.log if WP_DEBUG is defined and true
	620	+ *
	621	+ * @since 2.2.0
	622	+ *
	623	+ * @param string $function Function name.
	624	+ * @param int $line Line number.
	625	+ * @param mixed $msg Message to output.
	626	+ * @param mixed $debug Variable to print_r.
	627	+ */
	628	+ public static function log_if_debug( $function, $line, $msg, $debug = null ) {
	629	+ if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
	630	+ error_log( "In $function, $line:" . print_r( $msg, true ) . ( $debug ? print_r( $debug, true ) : '' ) );
	631	+ }
	632	+ }
	633	+
	634	+ /**
	635	+ * Determine a file's extension
	636	+ *
	637	+ * @since 1.0.0
	638	+ * @param string $file File url.
	639	+ * @return string|false File extension or false
	640	+ */
	641	+ public static function get_file_ext( $file ) {
	642	+ $parsed = parse_url( $file, PHP_URL_PATH );
	643	+ return $parsed ? strtolower( pathinfo( $parsed, PATHINFO_EXTENSION ) ) : false;
	644	+ }
	645	+
	646	+ /**
	647	+ * Get the file name from a url
	648	+ *
	649	+ * @since 2.0.0
	650	+ * @param string $value File url or path.
	651	+ * @return string File name
	652	+ */
	653	+ public static function get_file_name_from_path( $value ) {
	654	+ $parts = explode( '/', $value );
	655	+ return is_array( $parts ) ? end( $parts ) : $value;
	656	+ }
	657	+
	658	+ /**
	659	+ * Check if WP version is at least $version.
	660	+ *
	661	+ * @since 2.2.2
	662	+ * @param string $version WP version string to compare.
	663	+ * @return bool Result of comparison check.
	664	+ */
	665	+ public static function wp_at_least( $version ) {
	666	+ return version_compare( get_bloginfo( 'version' ), $version, '>=' );
	667	+ }
	668	+
	669	+ /**
	670	+ * Combines attributes into a string for a form element.
	671	+ *
	672	+ * @since 1.1.0
	673	+ * @param array $attrs Attributes to concatenate.
	674	+ * @param array $attr_exclude Attributes that should NOT be concatenated.
	675	+ * @return string String of attributes for form element.
	676	+ */
	677	+ public static function concat_attrs( $attrs, $attr_exclude = array() ) {
	678	+ $attr_exclude[] = 'rendered';
	679	+ $attr_exclude[] = 'js_dependencies';
	680	+
	681	+ $attributes = '';
	682	+ foreach ( $attrs as $attr => $val ) {
	683	+ $excluded = in_array( $attr, (array) $attr_exclude, true );
	684	+ $empty = false === $val && 'value' !== $attr;
	685	+ if ( ! $excluded && ! $empty ) {
	686	+ $val = is_array( $val ) ? implode( ',', $val ) : $val;
	687	+
	688	+ // if data attribute, use single quote wraps, else double.
	689	+ $quotes = self::is_data_attribute( $attr ) ? "'" : '"';
	690	+ $attributes .= sprintf( ' %1$s=%3$s%2$s%3$s', $attr, $val, $quotes );
	691	+ }
	692	+ }
	693	+ return $attributes;
	694	+ }
	695	+
	696	+ /**
	697	+ * Check if given attribute is a data attribute.
	698	+ *
	699	+ * @since 2.2.5
	700	+ *
	701	+ * @param string $att HTML attribute.
	702	+ * @return boolean
	703	+ */
	704	+ public static function is_data_attribute( $att ) {
	705	+ return 0 === stripos( $att, 'data-' );
	706	+ }
	707	+
	708	+ /**
	709	+ * Ensures value is an array.
	710	+ *
	711	+ * @since 2.2.3
	712	+ *
	713	+ * @param mixed $value Value to ensure is array.
	714	+ * @param array $default Default array. Defaults to empty array.
	715	+ *
	716	+ * @return array The array.
	717	+ */
	718	+ public static function ensure_array( $value, $default = array() ) {
	719	+ if ( empty( $value ) ) {
	720	+ return $default;
	721	+ }
	722	+
	723	+ if ( is_array( $value ) || is_object( $value ) ) {
	724	+ return (array) $value;
	725	+ }
	726	+
	727	+ // Not sure anything would be non-scalar that is not an array or object?
	728	+ if ( ! is_scalar( $value ) ) {
	729	+ return $default;
	730	+ }
	731	+
	732	+ return (array) $value;
	733	+ }
	734	+
	735	+ /**
	736	+ * If number is numeric, normalize it with floatval or intval, depending on if decimal is found.
	737	+ *
	738	+ * @since 2.2.6
	739	+ *
	740	+ * @param mixed $value Value to normalize (if numeric).
	741	+ * @return mixed Possibly normalized value.
	742	+ */
	743	+ public static function normalize_if_numeric( $value ) {
	744	+ if ( is_numeric( $value ) ) {
	745	+ $value = false !== strpos( $value, '.' ) ? floatval( $value ) : intval( $value );
	746	+ }
	747	+
	748	+ return $value;
	749	+ }
	750	+
	751	+ /**
	752	+ * Generates a 12 character unique hash from a string.
	753	+ *
	754	+ * @since 2.4.0
	755	+ *
	756	+ * @param string $string String to create a hash from.
	757	+ *
	758	+ * @return string
	759	+ */
	760	+ public static function generate_hash( $string ) {
	761	+ return substr( base_convert( md5( $string ), 16, 32 ), 0, 12 );
	762	+ }
	763	+
	764	+}