Completed
Push — add/image-block-detection ( ad6635 )
by Jeremy
07:10
created

Jetpack_PostImages::fit_image_url()   B

Complexity

Conditions 6
Paths 5

Size

Total Lines 36

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 6
nc 5
nop 3
dl 0
loc 36
rs 8.7217
c 0
b 0
f 0
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
Bug introduced by
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
			$meta = wp_get_attachment_metadata( $post_image->ID );
191
			// Must be larger than 200x200
192
			if ( !isset( $meta['width'] ) || $meta['width'] < $width )
193
				continue;
194
			if ( !isset( $meta['height'] ) || $meta['height'] < $height )
195
				continue;
196
197
			$url = wp_get_attachment_url( $post_image->ID );
198
199
			$images[] = array(
200
				'type'       => 'image',
201
				'from'       => 'attachment',
202
				'src'        => $url,
203
				'src_width'  => $meta['width'],
204
				'src_height' => $meta['height'],
205
				'href'       => $permalink,
206
			);
207
		}
208
209
		/*
210
		* We only want to pass back attached images that were actually inserted.
211
		* We can load up all the images found in the HTML source and then
212
		* compare URLs to see if an image is attached AND inserted.
213
		*/
214
		$html_images = self::from_html( $post_id );
215
		$inserted_images = array();
216
217
		foreach( $html_images as $html_image ) {
218
			$src = parse_url( $html_image['src'] );
219
			// strip off any query strings from src
220
			if( ! empty( $src['scheme'] ) && ! empty( $src['host'] ) ) {
221
				$inserted_images[] = $src['scheme'] . '://' . $src['host'] . $src['path'];
222
			} elseif( ! empty( $src['host'] ) ) {
223
				$inserted_images[] = set_url_scheme( 'http://' . $src['host'] . $src['path'] );
224
			} else {
225
				$inserted_images[] = site_url( '/' ) . $src['path'];
226
			}
227
		}
228
		foreach( $images as $i => $image ) {
229
			if ( !in_array( $image['src'], $inserted_images ) )
230
				unset( $images[$i] );
231
		}
232
233
		return $images;
234
	}
235
236
	/**
237
	 * Check if a Featured Image is set for this post, and return it in a similar
238
	 * format to the other images?_from_*() methods.
239
	 * @param  int $post_id The post ID to check
240
	 * @return Array containing details of the Featured Image, or empty array if none.
241
	 */
242
	static function from_thumbnail( $post_id, $width = 200, $height = 200 ) {
243
		$images = array();
244
245
		$post = get_post( $post_id );
246
247
		if ( ! empty( $post->post_password ) ) {
248
			return $images;
249
		}
250
251
		if ( ! function_exists( 'get_post_thumbnail_id' ) ) {
252
			return $images;
253
		}
254
255
		$thumb = get_post_thumbnail_id( $post_id );
256
257
		if ( $thumb ) {
258
			$meta = wp_get_attachment_metadata( $thumb );
259
			// Must be larger than requested minimums
260
			if ( !isset( $meta['width'] ) || $meta['width'] < $width )
261
				return $images;
262
			if ( !isset( $meta['height'] ) || $meta['height'] < $height )
263
				return $images;
264
265
			$too_big = ( ( ! empty( $meta['width'] ) && $meta['width'] > 1200 ) || ( ! empty( $meta['height'] ) && $meta['height'] > 1200 ) );
266
267
			if (
268
				$too_big &&
269
				(
270
					( method_exists( 'Jetpack', 'is_module_active' ) && Jetpack::is_module_active( 'photon' ) ) ||
271
					( defined( 'IS_WPCOM' ) && IS_WPCOM )
272
				)
273
			) {
274
				$img_src = wp_get_attachment_image_src( $thumb, array( 1200, 1200 ) );
275
			} else {
276
				$img_src = wp_get_attachment_image_src( $thumb, 'full' );
277
			}
278
			if ( ! is_array( $img_src ) ) {
279
				// If wp_get_attachment_image_src returns false but we know that there should be an image that could be used.
280
				// we try a bit harder and user the data that we have.
281
				$thumb_post_data = get_post( $thumb );
282
				$img_src = array( $thumb_post_data->guid, $meta['width'], $meta['height'] );
283
			}
284
285
			$url = $img_src[0];
286
			$images = array( array( // Other methods below all return an array of arrays
287
				'type'       => 'image',
288
				'from'       => 'thumbnail',
289
				'src'        => $url,
290
				'src_width'  => $img_src[1],
291
				'src_height' => $img_src[2],
292
				'href'       => get_permalink( $thumb ),
293
			) );
294
295
		}
296
297
		if ( empty( $images ) && ( defined( 'IS_WPCOM' ) && IS_WPCOM ) ) {
298
			$meta_thumbnail = get_post_meta( $post_id, '_jetpack_post_thumbnail', true );
299
			if ( ! empty( $meta_thumbnail ) ) {
300
				if ( ! isset( $meta_thumbnail['width'] ) || $meta_thumbnail['width'] < $width ) {
301
					return $images;
302
				}
303
304
				if ( ! isset( $meta_thumbnail['height'] ) || $meta_thumbnail['height'] < $height ) {
305
					return $images;
306
				}
307
308
				$images = array( array( // Other methods below all return an array of arrays
309
					'type'       => 'image',
310
					'from'       => 'thumbnail',
311
					'src'        => $meta_thumbnail['URL'],
312
					'src_width'  => $meta_thumbnail['width'],
313
					'src_height' => $meta_thumbnail['height'],
314
					'href'       => $meta_thumbnail['URL'],
315
				) );
316
			}
317
		}
318
319
		return $images;
320
	}
321
322
	/**
323
	 * Get images from Gutenberg Image blocks.
324
	 *
325
	 * @since 6.9.0
326
	 *
327
	 * @param mixed $html_or_id The HTML string to parse for images, or a post id.
328
	 * @param int   $width      Minimum Image width.
329
	 * @param int   $height     Minimum Image height.
330
	 */
331
	static function from_blocks( $html_or_id, $width = 200, $height = 200 ) {
332
		$images   = array();
333
		$post_url = '';
334
335
		// Bail early if the site does not support the block editor.
336
		if ( ! function_exists( 'parse_blocks' ) ) {
337
			return $images;
338
		}
339
340
		$html = self::get_post_html( $html_or_id );
341
342
		if ( ! $html ) {
343
			return $images;
344
		}
345
346
		// Look for block information in the HTML.
347
		$blocks = parse_blocks( $html );
348
		if ( empty( $blocks ) ) {
349
			return $images;
350
		}
351
352
		foreach ( $blocks as $block ) {
353
			/**
354
			 * Only parse content from Core Image blocks.
355
			 * If it is an image block for an image hosted on our site, it will have an ID.
356
			 * If it does not have an ID, let `from_html` parse that content later,
357
			 * and extract an image if it has size parameters.
358
			 */
359
			if (
360
				'core/image' === $block['blockName']
361
				&& ! empty( $block['attrs']['id'] )
362
			) {
363
				$images[] = self::get_attachment_data( $block['attrs']['id'], $post_url, $width, $height );
364
			}
365
		}
366
367
		return $images;
368
	}
369
370
	/**
371
	 * Very raw -- just parse the HTML and pull out any/all img tags and return their src
372
	 *
373
	 * @param mixed $html_or_id The HTML string to parse for images, or a post id.
374
	 * @param int   $width      Minimum Image width.
375
	 * @param int   $height     Minimum Image height.
376
	 *
377
	 * @uses DOMDocument
378
	 *
379
	 * @return Array containing images
380
	 */
381
	static function from_html( $html_or_id, $width = 200, $height = 200 ) {
382
		$images = array();
383
384
		$html = self::get_post_html( $html_or_id );
385
386
		if ( ! $html ) {
387
			return $images;
388
		}
389
390
		// Do not go any further if DOMDocument is disabled on the server.
391
		if ( ! class_exists( 'DOMDocument' ) ) {
392
			return $images;
393
		}
394
395
		// Let's grab all image tags from the HTML.
396
		$dom_doc = new DOMDocument;
397
398
		// The @ is not enough to suppress errors when dealing with libxml,
399
		// we have to tell it directly how we want to handle errors.
400
		libxml_use_internal_errors( true );
401
		@$dom_doc->loadHTML( $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...
402
		libxml_use_internal_errors( false );
403
404
		$image_tags = $dom_doc->getElementsByTagName( 'img' );
405
406
		// For each image Tag, make sure it can be added to the $images array, and add it.
407
		foreach ( $image_tags as $image_tag ) {
408
			$img_src = $image_tag->getAttribute( 'src' );
409
410
			if ( empty( $img_src ) ) {
411
				continue;
412
			}
413
414
			// Do not grab smiley images that were automatically created by WP when entering text smilies.
415
			if ( stripos( $img_src, '/smilies/' ) ) {
416
				continue;
417
			}
418
419
			$meta = array(
420
				'width'  => (int) $image_tag->getAttribute( 'width' ),
421
				'height' => (int) $image_tag->getAttribute( 'height' ),
422
			);
423
424
			/**
425
			 * Filters the switch to ignore minimum image size requirements. Can be used
426
			 * to add custom logic to image dimensions, like only enforcing one of the dimensions,
427
			 * or disabling it entirely.
428
			 *
429
			 * @since 6.4.0
430
			 *
431
			 * @param bool $ignore Should the image dimensions be ignored?
432
			 * @param array $meta Array containing image dimensions parsed from the markup.
433
			 */
434
			$ignore_dimensions = apply_filters( 'jetpack_postimages_ignore_minimum_dimensions', false, $meta );
435
436
			// Must be larger than 200x200 (or user-specified).
437
			if (
438
				! $ignore_dimensions
439
				&& (
440
					empty( $meta['width'] )
441
					|| empty( $meta['height'] )
442
					|| $meta['width'] < $width
443
					|| $meta['height'] < $height
444
				)
445
			) {
446
				continue;
447
			}
448
449
			$images[] = array(
450
				'type'  => 'image',
451
				'from'  => 'html',
452
				'src'   => $img_src,
453
				'src_width'  => $meta['width'],
454
				'src_height' => $meta['height'],
455
				'href'  => '', // No link to apply to these. Might potentially parse for that as well, but not for now.
456
			);
457
		}
458
		return $images;
459
	}
460
461
	/**
462
	 * @param    int $post_id The post ID to check
463
	 * @param    int $size
464
	 * @return Array containing details of the image, or empty array if none.
465
	 */
466
	static function from_blavatar( $post_id, $size = 96 ) {
467
468
		$permalink = get_permalink( $post_id );
469
470
		if ( function_exists( 'blavatar_domain' ) && function_exists( 'blavatar_exists' ) && function_exists( 'blavatar_url' ) ) {
471
			$domain = blavatar_domain( $permalink );
472
473
			if ( ! blavatar_exists( $domain ) ) {
474
				return array();
475
			}
476
477
			$url = blavatar_url( $domain, 'img', $size );
478
		} elseif ( function_exists( 'has_site_icon' ) && has_site_icon() ) {
479
			$url = get_site_icon_url( $size );
480
		} else {
481
			return array();
482
		}
483
484
		return array( array(
485
			'type'       => 'image',
486
			'from'       => 'blavatar',
487
			'src'        => $url,
488
			'src_width'  => $size,
489
			'src_height' => $size,
490
			'href'       => $permalink,
491
		) );
492
	}
493
494
	/**
495
	 * Gets a post image from the author avatar.
496
	 *
497
	 * @param int    $post_id The post ID to check.
498
	 * @param int    $size The size of the avatar to get.
499
	 * @param string $default The default image to use.
0 ignored issues
show
Documentation introduced by
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...
500
	 * @return Array containing details of the image, or empty array if none.
501
	 */
502
	static function from_gravatar( $post_id, $size = 96, $default = false ) {
503
		$post = get_post( $post_id );
504
		$permalink = get_permalink( $post_id );
505
506
		if ( function_exists( 'wpcom_get_avatar_url' ) ) {
507
			$url = wpcom_get_avatar_url( $post->post_author, $size, $default, true );
508
			if ( $url && is_array( $url ) ) {
509
				$url = $url[0];
510
			}
511
		} else {
512
			$url = get_avatar_url( $post->post_author, array(
513
				'size' => $size,
514
				'default' => $default,
515
			) );
516
		}
517
518
		return array(
519
			array(
520
				'type'       => 'image',
521
				'from'       => 'gravatar',
522
				'src'        => $url,
523
				'src_width'  => $size,
524
				'src_height' => $size,
525
				'href'       => $permalink,
526
			),
527
		);
528
	}
529
530
	/**
531
	 * Run through the different methods that we have available to try to find a single good
532
	 * display image for this post.
533
	 * @param  int $post_id
534
	 * @param array $args Other arguments (currently width and height required for images where possible to determine)
535
	 * @return Array containing details of the best image to be used
536
	 */
537
	static function get_image( $post_id, $args = array() ) {
538
		$image = '';
539
540
		/**
541
		 * Fires before we find a single good image for a specific post.
542
		 *
543
		 * @since 2.2.0
544
		 *
545
		 * @param int $post_id Post ID.
546
		 */
547
		do_action( 'jetpack_postimages_pre_get_image', $post_id );
548
		$media = self::get_images( $post_id, $args );
549
550
551
		if ( is_array( $media ) ) {
552
			foreach ( $media as $item ) {
553
				if ( 'image' == $item['type'] ) {
554
					$image = $item;
555
					break;
556
				}
557
			}
558
		}
559
560
		/**
561
		 * Fires after we find a single good image for a specific post.
562
		 *
563
		 * @since 2.2.0
564
		 *
565
		 * @param int $post_id Post ID.
566
		 */
567
		do_action( 'jetpack_postimages_post_get_image', $post_id );
568
569
		return $image;
570
	}
571
572
	/**
573
	 * Get an array containing a collection of possible images for this post, stopping once we hit a method
574
	 * that returns something useful.
575
	 * @param  int $post_id
576
	 * @param  array  $args Optional args, see defaults list for details
577
	 * @return Array containing images that would be good for representing this post
578
	 */
579
	static function get_images( $post_id, $args = array() ) {
580
		// Figure out which image to attach to this post.
581
		$media = false;
582
583
		/**
584
		 * Filters the array of images that would be good for a specific post.
585
		 * This filter is applied before options ($args) filter the original array.
586
		 *
587
		 * @since 2.0.0
588
		 *
589
		 * @param array $media Array of images that would be good for a specific post.
590
		 * @param int $post_id Post ID.
591
		 * @param array $args Array of options to get images.
592
		 */
593
		$media = apply_filters( 'jetpack_images_pre_get_images', $media, $post_id, $args );
594
		if ( $media )
595
			return $media;
596
597
		$defaults = array(
598
			'width'               => 200, // Required minimum width (if possible to determine)
599
			'height'              => 200, // Required minimum height (if possible to determine)
600
601
			'fallback_to_avatars' => false, // Optionally include Blavatar and Gravatar (in that order) in the image stack
602
			'avatar_size'         => 96, // Used for both Grav and Blav
603
			'gravatar_default'    => false, // Default image to use if we end up with no Gravatar
604
605
			'from_thumbnail'      => true, // Use these flags to specify which methods to use to find an image
606
			'from_slideshow'      => true,
607
			'from_gallery'        => true,
608
			'from_attachment'     => true,
609
			'from_blocks'         => true,
610
			'from_html'           => true,
611
612
			'html_content'        => '' // HTML string to pass to from_html()
613
		);
614
		$args = wp_parse_args( $args, $defaults );
615
616
		$media = false;
617
		if ( $args['from_thumbnail'] )
618
			$media = self::from_thumbnail( $post_id, $args['width'], $args['height'] );
619 View Code Duplication
		if ( !$media && $args['from_slideshow'] )
620
			$media = self::from_slideshow( $post_id, $args['width'], $args['height'] );
621
		if ( !$media && $args['from_gallery'] )
622
			$media = self::from_gallery( $post_id );
623 View Code Duplication
		if ( !$media && $args['from_attachment'] )
624
			$media = self::from_attachment( $post_id, $args['width'], $args['height'] );
625 View Code Duplication
		if ( ! $media && $args['from_blocks'] ) {
626
			if ( empty( $args['html_content'] ) )
627
				$media = self::from_blocks( $post_id, $args['width'], $args['height'] ); // Use the post_id, which will load the content
628
			else
629
				$media = self::from_blocks( $args['html_content'], $args['width'], $args['height'] ); // If html_content is provided, use that
630
		}
631 View Code Duplication
		if ( !$media && $args['from_html'] ) {
632
			if ( empty( $args['html_content'] ) )
633
				$media = self::from_html( $post_id, $args['width'], $args['height'] ); // Use the post_id, which will load the content
634
			else
635
				$media = self::from_html( $args['html_content'], $args['width'], $args['height'] ); // If html_content is provided, use that
636
		}
637
638
		if ( !$media && $args['fallback_to_avatars'] ) {
639
			$media = self::from_blavatar( $post_id, $args['avatar_size'] );
640
			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...
641
				$media = self::from_gravatar( $post_id, $args['avatar_size'], $args['gravatar_default'] );
642
		}
643
644
		/**
645
		 * Filters the array of images that would be good for a specific post.
646
		 * This filter is applied after options ($args) filter the original array.
647
		 *
648
		 * @since 2.0.0
649
		 *
650
		 * @param array $media Array of images that would be good for a specific post.
651
		 * @param int $post_id Post ID.
652
		 * @param array $args Array of options to get images.
653
		 */
654
		return apply_filters( 'jetpack_images_get_images', $media, $post_id, $args );
655
	}
656
657
	/**
658
	 * Takes an image URL and pixel dimensions then returns a URL for the
659
	 * resized and cropped image.
660
	 *
661
	 * @param  string $src
662
	 * @param  int    $dimension
0 ignored issues
show
Bug introduced by
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...
663
	 * @return string            Transformed image URL
664
	 */
665
	static function fit_image_url( $src, $width, $height ) {
666
		$width = (int) $width;
667
		$height = (int) $height;
668
669
		if ( $width < 1 || $height < 1 ) {
670
			return $src;
671
		}
672
673
		// See if we should bypass WordPress.com SaaS resizing
674
		if ( has_filter( 'jetpack_images_fit_image_url_override' ) ) {
675
			/**
676
			 * Filters the image URL used after dimensions are set by Photon.
677
			 *
678
			 * @since 3.3.0
679
			 *
680
			 * @param string $src Image URL.
681
			 * @param int $width Image width.
682
			 * @param int $width Image height.
683
			 */
684
			return apply_filters( 'jetpack_images_fit_image_url_override', $src, $width, $height );
685
		}
686
687
		// If WPCOM hosted image use native transformations
688
		$img_host = parse_url( $src, PHP_URL_HOST );
689
		if ( '.files.wordpress.com' == substr( $img_host, -20 ) ) {
690
			return add_query_arg( array( 'w' => $width, 'h' => $height, 'crop' => 1 ), set_url_scheme( $src ) );
691
		}
692
693
		// Use Photon magic
694
		if( function_exists( 'jetpack_photon_url' ) ) {
695
			return jetpack_photon_url( $src, array( 'resize' => "$width,$height" ) );
696
		}
697
698
		// Arg... no way to resize image using WordPress.com infrastructure!
699
		return $src;
700
	}
701
702
	/**
703
	 * Get HTML from given post content.
704
	 *
705
	 * @since 6.9.0
706
	 *
707
	 * @param mixed $html_or_id The HTML string to parse for images, or a post id.
708
	 *
709
	 * @return string $html Post content.
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 $images;
0 ignored issues
show
Bug introduced by
The variable $images does not exist. Did you forget to declare it?

This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug.

Loading history...
717
			}
718
719
			$html     = $post->post_content; // DO NOT apply the_content filters here, it will cause loops.
720
			$post_url = $post->post_title;
0 ignored issues
show
Unused Code introduced by
$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...
721
		} else {
722
			$html = $html_or_id;
723
		}
724
725
		return $html;
726
	}
727
728
	/**
729
	 * Get info about a WordPress attachment.
730
	 *
731
	 * @since 6.9.0
732
	 *
733
	 * @param int    $attachment_id Attachment ID.
734
	 * @param string $post_url      URL of the post, if we have one.
735
	 * @param int    $width         Minimum Image width.
736
	 * @param int    $height        Minimum Image height.
737
	 */
738
	static function get_attachment_data( $attachment_id, $post_url = '', $width, $height ) {
739
		if ( empty( $attachment_id ) ) {
740
			return array();
741
		}
742
743
		$meta = wp_get_attachment_metadata( $attachment_id );
744
745
		// The image must be larger than 200x200
746
		if ( ! isset( $meta['width'] ) || $meta['width'] < $width ) {
747
			return array();
748
		}
749
		if ( ! isset( $meta['height'] ) || $meta['height'] < $height ) {
750
			return array();
751
		}
752
753
		$url = wp_get_attachment_url( $attachment_id );
754
755
		return array(
756
			'type'       => 'image',
757
			'from'       => 'attachment',
758
			'src'        => $url,
759
			'src_width'  => $meta['width'],
760
			'src_height' => $meta['height'],
761
			'href'       => $post_url,
762
		);
763
	}
764
}
765