Completed
Push — add/image-block-detection ( 7f258b...d25c39 )
by Jeremy
08:25
created

class.jetpack-post-images.php (6 issues)

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

1
<?php
2
3
/**
4
 * Useful for finding an image to display alongside/in representation of a specific post.
5
 *
6
 * Includes a few different methods, all of which return a similar-format array containing
7
 * details of any images found. Everything can (should) be called statically, it's just a
8
 * function-bucket. You can also call Jetpack_PostImages::get_image() to cycle through all of the methods until
9
 * one of them finds something useful.
10
 *
11
 * This file is included verbatim in Jetpack
12
 */
13
class Jetpack_PostImages {
14
	/**
15
	 * If a slideshow is embedded within a post, then parse out the images involved and return them
16
	 */
17
	static function from_slideshow( $post_id, $width = 200, $height = 200 ) {
18
		$images = array();
19
20
		$post = get_post( $post_id );
21
22
		if ( ! $post ) {
23
			return $images;
24
		}
25
26
		if ( ! empty( $post->post_password ) ) {
27
			return $images;
28
		}
29
30
		if ( false === has_shortcode( $post->post_content, 'slideshow' ) ) {
31
			return $images; // no slideshow - bail
32
		}
33
34
		$permalink = get_permalink( $post->ID );
35
36
		// Mechanic: Somebody set us up the bomb
37
		$old_post = $GLOBALS['post'];
38
		$GLOBALS['post'] = $post;
39
		$old_shortcodes = $GLOBALS['shortcode_tags'];
40
		$GLOBALS['shortcode_tags'] = array( 'slideshow' => $old_shortcodes['slideshow'] );
41
42
		// Find all the slideshows
43
		preg_match_all( '/' . get_shortcode_regex() . '/sx', $post->post_content, $slideshow_matches, PREG_SET_ORDER );
44
45
		ob_start(); // The slideshow shortcode handler calls wp_print_scripts and wp_print_styles... not too happy about that
46
47
		foreach ( $slideshow_matches as $slideshow_match ) {
0 ignored issues
show
The expression $slideshow_matches of type null|array<integer,array<integer,string>> is not guaranteed to be traversable. How about adding an additional type check?

There are different options of fixing this problem.

  1. If you want to be on the safe side, you can add an additional type-check:

    $collection = json_decode($data, true);
    if ( ! is_array($collection)) {
        throw new \RuntimeException('$collection must be an array.');
    }
    
    foreach ($collection as $item) { /** ... */ }
    
  2. If you are sure that the expression is traversable, you might want to add a doc comment cast to improve IDE auto-completion and static analysis:

    /** @var array $collection */
    $collection = json_decode($data, true);
    
    foreach ($collection as $item) { /** .. */ }
    
  3. Mark the issue as a false-positive: Just hover the remove button, in the top-right corner of this issue for more options.

Loading history...
48
			$slideshow = do_shortcode_tag( $slideshow_match );
49
			if ( false === $pos = stripos( $slideshow, 'jetpack-slideshow' ) ) // must be something wrong - or we changed the output format in which case none of the following will work
50
				continue;
51
			$start = strpos( $slideshow, '[', $pos );
52
			$end = strpos( $slideshow, ']', $start );
53
			$post_images = json_decode( wp_specialchars_decode( str_replace( "'", '"', substr( $slideshow, $start, $end - $start + 1 ) ), ENT_QUOTES ) ); // parse via JSON
54
			// If the JSON didn't decode don't try and act on it.
55
			if ( is_array( $post_images ) ) {
56
				foreach ( $post_images as $post_image ) {
57
					if ( !$post_image_id = absint( $post_image->id ) )
58
						continue;
59
60
					$meta = wp_get_attachment_metadata( $post_image_id );
61
62
					// Must be larger than 200x200 (or user-specified)
63
					if ( !isset( $meta['width'] ) || $meta['width'] < $width )
64
						continue;
65
					if ( !isset( $meta['height'] ) || $meta['height'] < $height )
66
						continue;
67
68
					$url = wp_get_attachment_url( $post_image_id );
69
70
					$images[] = array(
71
						'type'       => 'image',
72
						'from'       => 'slideshow',
73
						'src'        => $url,
74
						'src_width'  => $meta['width'],
75
						'src_height' => $meta['height'],
76
						'href'       => $permalink,
77
					);
78
				}
79
			}
80
		}
81
		ob_end_clean();
82
83
		// Operator: Main screen turn on
84
		$GLOBALS['shortcode_tags'] = $old_shortcodes;
85
		$GLOBALS['post'] = $old_post;
86
87
		return $images;
88
	}
89
90
	/**
91
	 * If a gallery is detected, then get all the images from it.
92
	 */
93
	static function from_gallery( $post_id ) {
94
		$images = array();
95
96
		$post = get_post( $post_id );
97
98
		if ( ! $post ) {
99
			return $images;
100
		}
101
102
		if ( ! empty( $post->post_password ) ) {
103
			return $images;
104
		}
105
106
		$permalink = get_permalink( $post->ID );
107
108
		/**
109
		 *  Juggle global post object because the gallery shortcode uses the
110
		 *  global object.
111
		 *
112
		 *  See core ticket:
113
		 *  https://core.trac.wordpress.org/ticket/39304
114
		 */
115
		if ( isset( $GLOBALS['post'] ) ) {
116
			$juggle_post = $GLOBALS['post'];
117
			$GLOBALS['post'] = $post;
118
			$galleries = get_post_galleries( $post->ID, false );
119
			$GLOBALS['post'] = $juggle_post;
120
		} else {
121
			$GLOBALS['post'] = $post;
122
			$galleries = get_post_galleries( $post->ID, false );
123
			unset( $GLOBALS['post'] );
124
		}
125
126
		foreach ( $galleries as $gallery ) {
127
			if ( isset( $gallery['type'] ) && 'slideshow' === $gallery['type'] && ! empty( $gallery['ids'] ) ) {
128
				$image_ids = explode( ',', $gallery['ids'] );
129
				$image_size = isset( $gallery['size'] ) ? $gallery['size'] : 'thumbnail';
130
				foreach ( $image_ids as $image_id ) {
131
					$image = wp_get_attachment_image_src( $image_id, $image_size );
132 View Code Duplication
					if ( ! empty( $image[0] ) ) {
133
						list( $raw_src ) = explode( '?', $image[0] ); // pull off any Query string (?w=250)
134
						$raw_src = wp_specialchars_decode( $raw_src ); // rawify it
135
						$raw_src = esc_url_raw( $raw_src ); // clean it
136
						$images[] = array(
137
							'type'  => 'image',
138
							'from'  => 'gallery',
139
							'src'   => $raw_src,
140
							'href'  => $permalink,
141
						);
142
					}
143
				}
144 View Code Duplication
			} elseif ( ! empty( $gallery['src'] ) ) {
145
				foreach ( $gallery['src'] as $src ) {
146
					list( $raw_src ) = explode( '?', $src ); // pull off any Query string (?w=250)
147
					$raw_src = wp_specialchars_decode( $raw_src ); // rawify it
148
					$raw_src = esc_url_raw( $raw_src ); // clean it
149
					$images[] = array(
150
						'type'  => 'image',
151
						'from'  => 'gallery',
152
						'src'   => $raw_src,
153
						'href'  => $permalink,
154
					);
155
				}
156
			}
157
		}
158
159
		return $images;
160
	}
161
162
	/**
163
	 * Get attachment images for a specified post and return them. Also make sure
164
	 * their dimensions are at or above a required minimum.
165
	 */
166
	static function from_attachment( $post_id, $width = 200, $height = 200 ) {
167
		$images = array();
168
169
		$post = get_post( $post_id );
170
171
		if ( ! empty( $post->post_password ) ) {
172
			return $images;
173
		}
174
175
		$post_images = get_posts( array(
176
			'post_parent' => $post_id,   // Must be children of post
177
			'numberposts' => 5,          // No more than 5
178
			'post_type' => 'attachment', // Must be attachments
179
			'post_mime_type' => 'image', // Must be images
180
			'suppress_filters' => false,
181
		) );
182
183
		if ( ! $post_images ) {
184
			return $images;
185
		}
186
187
		$permalink = get_permalink( $post_id );
188
189
		foreach ( $post_images as $post_image ) {
190
			$images[] = self::get_attachment_data( $post_image->ID, $permalink, $width, $height );
191
		}
192
193
		/*
194
		* We only want to pass back attached images that were actually inserted.
195
		* We can load up all the images found in the HTML source and then
196
		* compare URLs to see if an image is attached AND inserted.
197
		*/
198
		$html_images = self::from_html( $post_id );
199
		$inserted_images = array();
200
201
		foreach( $html_images as $html_image ) {
202
			$src = parse_url( $html_image['src'] );
203
			// strip off any query strings from src
204
			if( ! empty( $src['scheme'] ) && ! empty( $src['host'] ) ) {
205
				$inserted_images[] = $src['scheme'] . '://' . $src['host'] . $src['path'];
206
			} elseif( ! empty( $src['host'] ) ) {
207
				$inserted_images[] = set_url_scheme( 'http://' . $src['host'] . $src['path'] );
208
			} else {
209
				$inserted_images[] = site_url( '/' ) . $src['path'];
210
			}
211
		}
212
		foreach( $images as $i => $image ) {
213
			if ( !in_array( $image['src'], $inserted_images ) )
214
				unset( $images[$i] );
215
		}
216
217
		return $images;
218
	}
219
220
	/**
221
	 * Check if a Featured Image is set for this post, and return it in a similar
222
	 * format to the other images?_from_*() methods.
223
	 * @param  int $post_id The post ID to check
224
	 * @return Array containing details of the Featured Image, or empty array if none.
225
	 */
226
	static function from_thumbnail( $post_id, $width = 200, $height = 200 ) {
227
		$images = array();
228
229
		$post = get_post( $post_id );
230
231
		if ( ! empty( $post->post_password ) ) {
232
			return $images;
233
		}
234
235
		if ( ! function_exists( 'get_post_thumbnail_id' ) ) {
236
			return $images;
237
		}
238
239
		$thumb = get_post_thumbnail_id( $post_id );
240
241
		if ( $thumb ) {
242
			$meta = wp_get_attachment_metadata( $thumb );
243
			// Must be larger than requested minimums
244
			if ( !isset( $meta['width'] ) || $meta['width'] < $width )
245
				return $images;
246
			if ( !isset( $meta['height'] ) || $meta['height'] < $height )
247
				return $images;
248
249
			$too_big = ( ( ! empty( $meta['width'] ) && $meta['width'] > 1200 ) || ( ! empty( $meta['height'] ) && $meta['height'] > 1200 ) );
250
251
			if (
252
				$too_big &&
253
				(
254
					( method_exists( 'Jetpack', 'is_module_active' ) && Jetpack::is_module_active( 'photon' ) ) ||
255
					( defined( 'IS_WPCOM' ) && IS_WPCOM )
256
				)
257
			) {
258
				$img_src = wp_get_attachment_image_src( $thumb, array( 1200, 1200 ) );
259
			} else {
260
				$img_src = wp_get_attachment_image_src( $thumb, 'full' );
261
			}
262
			if ( ! is_array( $img_src ) ) {
263
				// If wp_get_attachment_image_src returns false but we know that there should be an image that could be used.
264
				// we try a bit harder and user the data that we have.
265
				$thumb_post_data = get_post( $thumb );
266
				$img_src = array( $thumb_post_data->guid, $meta['width'], $meta['height'] );
267
			}
268
269
			$url = $img_src[0];
270
			$images = array( array( // Other methods below all return an array of arrays
271
				'type'       => 'image',
272
				'from'       => 'thumbnail',
273
				'src'        => $url,
274
				'src_width'  => $img_src[1],
275
				'src_height' => $img_src[2],
276
				'href'       => get_permalink( $thumb ),
277
			) );
278
279
		}
280
281
		if ( empty( $images ) && ( defined( 'IS_WPCOM' ) && IS_WPCOM ) ) {
282
			$meta_thumbnail = get_post_meta( $post_id, '_jetpack_post_thumbnail', true );
283
			if ( ! empty( $meta_thumbnail ) ) {
284
				if ( ! isset( $meta_thumbnail['width'] ) || $meta_thumbnail['width'] < $width ) {
285
					return $images;
286
				}
287
288
				if ( ! isset( $meta_thumbnail['height'] ) || $meta_thumbnail['height'] < $height ) {
289
					return $images;
290
				}
291
292
				$images = array( array( // Other methods below all return an array of arrays
293
					'type'       => 'image',
294
					'from'       => 'thumbnail',
295
					'src'        => $meta_thumbnail['URL'],
296
					'src_width'  => $meta_thumbnail['width'],
297
					'src_height' => $meta_thumbnail['height'],
298
					'href'       => $meta_thumbnail['URL'],
299
				) );
300
			}
301
		}
302
303
		return $images;
304
	}
305
306
	/**
307
	 * Get images from Gutenberg Image blocks.
308
	 *
309
	 * @since 6.9.0
310
	 *
311
	 * @param mixed $html_or_id The HTML string to parse for images, or a post id.
312
	 * @param int   $width      Minimum Image width.
313
	 * @param int   $height     Minimum Image height.
314
	 */
315
	static function from_blocks( $html_or_id, $width = 200, $height = 200 ) {
316
		$images   = array();
317
		$post_url = '';
0 ignored issues
show
$post_url 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...
318
319
		// Bail early if the site does not support the block editor.
320
		if ( ! function_exists( 'parse_blocks' ) ) {
321
			return $images;
322
		}
323
324
		$html_info = self::get_post_html( $html_or_id );
325
326
		if ( empty( $html_info['html'] ) ) {
327
			return $images;
328
		}
329
330
		// Look for block information in the HTML.
331
		$blocks = parse_blocks( $html_info['html'] );
332
		if ( empty( $blocks ) ) {
333
			return $images;
334
		}
335
336
		foreach ( $blocks as $block ) {
337
			/**
338
			 * Parse content from Core Image blocks.
339
			 * If it is an image block for an image hosted on our site, it will have an ID.
340
			 * If it does not have an ID, let `from_html` parse that content later,
341
			 * and extract an image if it has size parameters.
342
			 */
343
			if (
344
				'core/image' === $block['blockName']
345
				&& ! empty( $block['attrs']['id'] )
346
			) {
347
				$images[] = self::get_attachment_data( $block['attrs']['id'], $html_info['post_url'], $width, $height );
348
			}
349
350
			/**
351
			 * Parse content from Core Gallery blocks and Jetpack's Tiled Gallery blocks.
352
			 * Gallery blocks include the ID of each one of the images in the gallery.
353
			 */
354
			if (
355
				( 'core/gallery' === $block['blockName'] || 'jetpack/tiled-gallery' === $block['blockName'] )
356
				&& ! empty( $block['attrs']['ids'] )
357
			) {
358
				foreach ( $block['attrs']['ids'] as $img_id ) {
359
					$images[] = self::get_attachment_data( $img_id, $html_info['post_url'], $width, $height );
360
				}
361
			}
362
		}
363
364
		return $images;
365
	}
366
367
	/**
368
	 * Very raw -- just parse the HTML and pull out any/all img tags and return their src
369
	 *
370
	 * @param mixed $html_or_id The HTML string to parse for images, or a post id.
371
	 * @param int   $width      Minimum Image width.
372
	 * @param int   $height     Minimum Image height.
373
	 *
374
	 * @uses DOMDocument
375
	 *
376
	 * @return Array containing images
377
	 */
378
	static function from_html( $html_or_id, $width = 200, $height = 200 ) {
379
		$images = array();
380
381
		$html_info = self::get_post_html( $html_or_id );
382
383
		if ( empty( $html_info['html'] ) ) {
384
			return $images;
385
		}
386
387
		// Do not go any further if DOMDocument is disabled on the server.
388
		if ( ! class_exists( 'DOMDocument' ) ) {
389
			return $images;
390
		}
391
392
		// Let's grab all image tags from the HTML.
393
		$dom_doc = new DOMDocument;
394
395
		// The @ is not enough to suppress errors when dealing with libxml,
396
		// we have to tell it directly how we want to handle errors.
397
		libxml_use_internal_errors( true );
398
		@$dom_doc->loadHTML( $html_info['html'] );
0 ignored issues
show
Security Best Practice introduced by
It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

If you suppress an error, we recommend checking for the error condition explicitly:

// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
Loading history...
399
		libxml_use_internal_errors( false );
400
401
		$image_tags = $dom_doc->getElementsByTagName( 'img' );
402
403
		// For each image Tag, make sure it can be added to the $images array, and add it.
404
		foreach ( $image_tags as $image_tag ) {
405
			$img_src = $image_tag->getAttribute( 'src' );
406
407
			if ( empty( $img_src ) ) {
408
				continue;
409
			}
410
411
			// Do not grab smiley images that were automatically created by WP when entering text smilies.
412
			if ( stripos( $img_src, '/smilies/' ) ) {
413
				continue;
414
			}
415
416
			$meta = array(
417
				'width'  => (int) $image_tag->getAttribute( 'width' ),
418
				'height' => (int) $image_tag->getAttribute( 'height' ),
419
			);
420
421
			/**
422
			 * Filters the switch to ignore minimum image size requirements. Can be used
423
			 * to add custom logic to image dimensions, like only enforcing one of the dimensions,
424
			 * or disabling it entirely.
425
			 *
426
			 * @since 6.4.0
427
			 *
428
			 * @param bool $ignore Should the image dimensions be ignored?
429
			 * @param array $meta Array containing image dimensions parsed from the markup.
430
			 */
431
			$ignore_dimensions = apply_filters( 'jetpack_postimages_ignore_minimum_dimensions', false, $meta );
432
433
			// Must be larger than 200x200 (or user-specified).
434
			if (
435
				! $ignore_dimensions
436
				&& (
437
					empty( $meta['width'] )
438
					|| empty( $meta['height'] )
439
					|| $meta['width'] < $width
440
					|| $meta['height'] < $height
441
				)
442
			) {
443
				continue;
444
			}
445
446
			$images[] = array(
447
				'type'       => 'image',
448
				'from'       => 'html',
449
				'src'        => $img_src,
450
				'src_width'  => $meta['width'],
451
				'src_height' => $meta['height'],
452
				'href'       => $html_info['post_url'],
453
			);
454
		}
455
		return $images;
456
	}
457
458
	/**
459
	 * @param    int $post_id The post ID to check
460
	 * @param    int $size
461
	 * @return Array containing details of the image, or empty array if none.
462
	 */
463
	static function from_blavatar( $post_id, $size = 96 ) {
464
465
		$permalink = get_permalink( $post_id );
466
467
		if ( function_exists( 'blavatar_domain' ) && function_exists( 'blavatar_exists' ) && function_exists( 'blavatar_url' ) ) {
468
			$domain = blavatar_domain( $permalink );
469
470
			if ( ! blavatar_exists( $domain ) ) {
471
				return array();
472
			}
473
474
			$url = blavatar_url( $domain, 'img', $size );
475
		} elseif ( function_exists( 'has_site_icon' ) && has_site_icon() ) {
476
			$url = get_site_icon_url( $size );
477
		} else {
478
			return array();
479
		}
480
481
		return array( array(
482
			'type'       => 'image',
483
			'from'       => 'blavatar',
484
			'src'        => $url,
485
			'src_width'  => $size,
486
			'src_height' => $size,
487
			'href'       => $permalink,
488
		) );
489
	}
490
491
	/**
492
	 * Gets a post image from the author avatar.
493
	 *
494
	 * @param int    $post_id The post ID to check.
495
	 * @param int    $size The size of the avatar to get.
496
	 * @param string $default The default image to use.
0 ignored issues
show
Should the type for parameter $default not be false|string?

This check looks for @param annotations where the type inferred by our type inference engine differs from the declared type.

It makes a suggestion as to what type it considers more descriptive.

Most often this is a case of a parameter that can be null in addition to its declared types.

Loading history...
497
	 * @return Array containing details of the image, or empty array if none.
498
	 */
499
	static function from_gravatar( $post_id, $size = 96, $default = false ) {
500
		$post = get_post( $post_id );
501
		$permalink = get_permalink( $post_id );
502
503
		if ( function_exists( 'wpcom_get_avatar_url' ) ) {
504
			$url = wpcom_get_avatar_url( $post->post_author, $size, $default, true );
505
			if ( $url && is_array( $url ) ) {
506
				$url = $url[0];
507
			}
508
		} else {
509
			$url = get_avatar_url( $post->post_author, array(
510
				'size' => $size,
511
				'default' => $default,
512
			) );
513
		}
514
515
		return array(
516
			array(
517
				'type'       => 'image',
518
				'from'       => 'gravatar',
519
				'src'        => $url,
520
				'src_width'  => $size,
521
				'src_height' => $size,
522
				'href'       => $permalink,
523
			),
524
		);
525
	}
526
527
	/**
528
	 * Run through the different methods that we have available to try to find a single good
529
	 * display image for this post.
530
	 * @param  int $post_id
531
	 * @param array $args Other arguments (currently width and height required for images where possible to determine)
532
	 * @return Array containing details of the best image to be used
533
	 */
534
	static function get_image( $post_id, $args = array() ) {
535
		$image = '';
536
537
		/**
538
		 * Fires before we find a single good image for a specific post.
539
		 *
540
		 * @since 2.2.0
541
		 *
542
		 * @param int $post_id Post ID.
543
		 */
544
		do_action( 'jetpack_postimages_pre_get_image', $post_id );
545
		$media = self::get_images( $post_id, $args );
546
547
548
		if ( is_array( $media ) ) {
549
			foreach ( $media as $item ) {
550
				if ( 'image' == $item['type'] ) {
551
					$image = $item;
552
					break;
553
				}
554
			}
555
		}
556
557
		/**
558
		 * Fires after we find a single good image for a specific post.
559
		 *
560
		 * @since 2.2.0
561
		 *
562
		 * @param int $post_id Post ID.
563
		 */
564
		do_action( 'jetpack_postimages_post_get_image', $post_id );
565
566
		return $image;
567
	}
568
569
	/**
570
	 * Get an array containing a collection of possible images for this post, stopping once we hit a method
571
	 * that returns something useful.
572
	 * @param  int $post_id
573
	 * @param  array  $args Optional args, see defaults list for details
574
	 * @return Array containing images that would be good for representing this post
575
	 */
576
	static function get_images( $post_id, $args = array() ) {
577
		// Figure out which image to attach to this post.
578
		$media = false;
579
580
		/**
581
		 * Filters the array of images that would be good for a specific post.
582
		 * This filter is applied before options ($args) filter the original array.
583
		 *
584
		 * @since 2.0.0
585
		 *
586
		 * @param array $media Array of images that would be good for a specific post.
587
		 * @param int $post_id Post ID.
588
		 * @param array $args Array of options to get images.
589
		 */
590
		$media = apply_filters( 'jetpack_images_pre_get_images', $media, $post_id, $args );
591
		if ( $media )
592
			return $media;
593
594
		$defaults = array(
595
			'width'               => 200, // Required minimum width (if possible to determine)
596
			'height'              => 200, // Required minimum height (if possible to determine)
597
598
			'fallback_to_avatars' => false, // Optionally include Blavatar and Gravatar (in that order) in the image stack
599
			'avatar_size'         => 96, // Used for both Grav and Blav
600
			'gravatar_default'    => false, // Default image to use if we end up with no Gravatar
601
602
			'from_thumbnail'      => true, // Use these flags to specify which methods to use to find an image
603
			'from_slideshow'      => true,
604
			'from_gallery'        => true,
605
			'from_attachment'     => true,
606
			'from_blocks'         => true,
607
			'from_html'           => true,
608
609
			'html_content'        => '' // HTML string to pass to from_html()
610
		);
611
		$args = wp_parse_args( $args, $defaults );
612
613
		$media = false;
614
		if ( $args['from_thumbnail'] )
615
			$media = self::from_thumbnail( $post_id, $args['width'], $args['height'] );
616 View Code Duplication
		if ( !$media && $args['from_slideshow'] )
617
			$media = self::from_slideshow( $post_id, $args['width'], $args['height'] );
618
		if ( !$media && $args['from_gallery'] )
619
			$media = self::from_gallery( $post_id );
620 View Code Duplication
		if ( !$media && $args['from_attachment'] )
621
			$media = self::from_attachment( $post_id, $args['width'], $args['height'] );
622 View Code Duplication
		if ( ! $media && $args['from_blocks'] ) {
623
			if ( empty( $args['html_content'] ) )
624
				$media = self::from_blocks( $post_id, $args['width'], $args['height'] ); // Use the post_id, which will load the content
625
			else
626
				$media = self::from_blocks( $args['html_content'], $args['width'], $args['height'] ); // If html_content is provided, use that
627
		}
628 View Code Duplication
		if ( !$media && $args['from_html'] ) {
629
			if ( empty( $args['html_content'] ) )
630
				$media = self::from_html( $post_id, $args['width'], $args['height'] ); // Use the post_id, which will load the content
631
			else
632
				$media = self::from_html( $args['html_content'], $args['width'], $args['height'] ); // If html_content is provided, use that
633
		}
634
635
		if ( !$media && $args['fallback_to_avatars'] ) {
636
			$media = self::from_blavatar( $post_id, $args['avatar_size'] );
637
			if ( !$media )
0 ignored issues
show
Bug Best Practice introduced by
The expression $media of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
638
				$media = self::from_gravatar( $post_id, $args['avatar_size'], $args['gravatar_default'] );
639
		}
640
641
		/**
642
		 * Filters the array of images that would be good for a specific post.
643
		 * This filter is applied after options ($args) filter the original array.
644
		 *
645
		 * @since 2.0.0
646
		 *
647
		 * @param array $media Array of images that would be good for a specific post.
648
		 * @param int $post_id Post ID.
649
		 * @param array $args Array of options to get images.
650
		 */
651
		return apply_filters( 'jetpack_images_get_images', $media, $post_id, $args );
652
	}
653
654
	/**
655
	 * Takes an image URL and pixel dimensions then returns a URL for the
656
	 * resized and cropped image.
657
	 *
658
	 * @param  string $src
659
	 * @param  int    $dimension
0 ignored issues
show
There is no parameter named $dimension. Was it maybe removed?

This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function.

Consider the following example. The parameter $italy is not defined by the method finale(...).

/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}

The most likely cause is that the parameter was removed, but the annotation was not.

Loading history...
660
	 * @return string            Transformed image URL
661
	 */
662
	static function fit_image_url( $src, $width, $height ) {
663
		$width = (int) $width;
664
		$height = (int) $height;
665
666
		if ( $width < 1 || $height < 1 ) {
667
			return $src;
668
		}
669
670
		// See if we should bypass WordPress.com SaaS resizing
671
		if ( has_filter( 'jetpack_images_fit_image_url_override' ) ) {
672
			/**
673
			 * Filters the image URL used after dimensions are set by Photon.
674
			 *
675
			 * @since 3.3.0
676
			 *
677
			 * @param string $src Image URL.
678
			 * @param int $width Image width.
679
			 * @param int $width Image height.
680
			 */
681
			return apply_filters( 'jetpack_images_fit_image_url_override', $src, $width, $height );
682
		}
683
684
		// If WPCOM hosted image use native transformations
685
		$img_host = parse_url( $src, PHP_URL_HOST );
686
		if ( '.files.wordpress.com' == substr( $img_host, -20 ) ) {
687
			return add_query_arg( array( 'w' => $width, 'h' => $height, 'crop' => 1 ), set_url_scheme( $src ) );
688
		}
689
690
		// Use Photon magic
691
		if( function_exists( 'jetpack_photon_url' ) ) {
692
			return jetpack_photon_url( $src, array( 'resize' => "$width,$height" ) );
693
		}
694
695
		// Arg... no way to resize image using WordPress.com infrastructure!
696
		return $src;
697
	}
698
699
	/**
700
	 * Get HTML from given post content.
701
	 *
702
	 * @since 6.9.0
703
	 *
704
	 * @param mixed $html_or_id The HTML string to parse for images, or a post id.
705
	 *
706
	 * @return array $html_info {
707
	 * @type string $html     Post content.
708
	 * @type string $post_url Post URL.
709
	 * }
710
	 */
711
	static function get_post_html( $html_or_id ) {
712
		if ( is_numeric( $html_or_id ) ) {
713
			$post = get_post( $html_or_id );
714
715
			if ( empty( $post ) || ! empty( $post->post_password ) ) {
716
				return '';
717
			}
718
719
			$html_info = array(
720
				'html'    => $post->post_content, // DO NOT apply the_content filters here, it will cause loops.
721
				'post_url'=> get_permalink( $post->ID ),
722
			);
723
		} else {
724
			$html_info = array(
725
				'html'    => $html_or_id,
726
				'post_url'=> '',
727
			);
728
		}
729
		return $html_info;
730
	}
731
732
	/**
733
	 * Get info about a WordPress attachment.
734
	 *
735
	 * @since 6.9.0
736
	 *
737
	 * @param int    $attachment_id Attachment ID.
738
	 * @param string $post_url      URL of the post, if we have one.
739
	 * @param int    $width         Minimum Image width.
740
	 * @param int    $height        Minimum Image height.
741
	 */
742
	static function get_attachment_data( $attachment_id, $post_url = '', $width, $height ) {
743
		if ( empty( $attachment_id ) ) {
744
			return array();
745
		}
746
747
		$meta = wp_get_attachment_metadata( $attachment_id );
748
749
		// The image must be larger than 200x200
750
		if ( ! isset( $meta['width'] ) || $meta['width'] < $width ) {
751
			return array();
752
		}
753
		if ( ! isset( $meta['height'] ) || $meta['height'] < $height ) {
754
			return array();
755
		}
756
757
		$url = wp_get_attachment_url( $attachment_id );
758
759
		return array(
760
			'type'       => 'image',
761
			'from'       => 'attachment',
762
			'src'        => $url,
763
			'src_width'  => $meta['width'],
764
			'src_height' => $meta['height'],
765
			'href'       => $post_url,
766
		);
767
	}
768
}
769