Ticket #55443: 55443-multi-mime-with-edit-and-restore-flows.diff

src/wp-admin/includes/image-edit.php

@@ -735 +735 @@
  */
 function wp_restore_image( $post_id ) {
         $meta             = wp_get_attachment_metadata( $post_id );
+        $old_meta         = $meta;
         $file             = get_attached_file( $post_id );
         $backup_sizes     = get_post_meta( $post_id, '_wp_attachment_backup_sizes', true );
         $old_backup_sizes = $backup_sizes;
+        $backup_sources   = get_post_meta( $post_id, '_wp_attachment_backup_sources', true );
         $restored         = false;
         $msg              = new stdClass;
 
@@ -799 +801 @@
                 }
         }
 
+        // Get the next available `full-{orig or hash}` key on the images if the name
+        // has not been used as part of the backup sources it would be used if no size is
+        // found or backup exists `null` would be used instead.
+        $next_full_size_key_from_backup = null;
+        foreach ( array_keys( $backup_sizes ) as $size_name ) {
+                // If the target already has the sources attributes find the next one.
+                if ( isset( $backup_sources[ $size_name ] ) ) {
+                        continue;
+                }
+
+                // We are only interested in the `full-` sizes.
+                if ( strpos( $size_name, 'full-' ) === false ) {
+                        continue;
+                }
+
+                $next_full_size_key_from_backup = $size_name;
+                break;
+        }
+
+        if ( null !== $next_full_size_key_from_backup ) {
+                $backup_sources[ $next_full_size_key_from_backup ] = $old_meta['sources'];
+                // Store the `sources` property into the full size if present.
+                update_post_meta( $post_id, '_wp_attachment_backup_sources', $backup_sources );
+        }
+
+        if ( isset( $backup_sources['full-orig'] ) && is_array( $backup_sources['full-orig'] ) ) {
+                $meta['sources'] = $backup_sources['full-orig'];
+        }
+
         if ( ! wp_update_attachment_metadata( $post_id, $meta ) ||
                 ( $old_backup_sizes !== $backup_sizes && ! update_post_meta( $post_id, '_wp_attachment_backup_sizes', $backup_sizes ) ) ) {
 
@@ -873 +904 @@
                 return $return;
         }
 
-        $meta         = wp_get_attachment_metadata( $post_id );
-        $backup_sizes = get_post_meta( $post->ID, '_wp_attachment_backup_sizes', true );
+        $meta           = wp_get_attachment_metadata( $post_id );
+        $backup_sizes   = get_post_meta( $post->ID, '_wp_attachment_backup_sizes', true );
+        $backup_sources = get_post_meta( $post->ID, '_wp_attachment_backup_sources', true );
 
         if ( ! is_array( $meta ) ) {
                 $return->error = esc_js( __( 'Image data does not exist. Please re-upload the image.' ) );
                 return $return;
         }
 
+        $old_metadata = $meta;
+
         if ( ! is_array( $backup_sizes ) ) {
                 $backup_sizes = array();
         }
 
+        if ( ! is_array( $backup_sources ) ) {
+                $backup_sources = array();
+        }
+
+        $transforms      = wp_upload_image_mime_transforms( $post_id );
+        $mime_transforms = array();
+
+        if ( ! empty( $transforms[ $post->post_mime_type ] ) ) {
+                $mime_transforms = $transforms[ $post->post_mime_type ];
+        }
+
         // Generate new filename.
         $path = get_attached_file( $post_id );
 
@@ -982 +1027 @@
                 foreach ( $meta['sizes'] as $size ) {
                         if ( ! empty( $size['file'] ) && preg_match( '/-e[0-9]{13}-/', $size['file'] ) ) {
                                 $delete_file = path_join( $dirname, $size['file'] );
-                                wp_delete_file( $delete_file );
+                                if ( file_exists( $delete_file ) ) {
+                                        wp_delete_file( $delete_file );
+                                }
+
+                                // Delete generated secondary mimes.
+                                foreach ( $mime_transforms as $mime ) {
+                                        if ( ! empty( $size['sources'][ $mime ]['file'] ) ) {
+                                                $delete_file = path_join( $dirname, $size['sources'][ $mime ]['file'] );
+
+                                                if ( file_exists( $delete_file ) ) {
+                                                        wp_delete_file( $delete_file );
+                                                }
+                                        }
+                                }
                         }
                 }
         }
 
+        $_sizes = array();
         if ( isset( $sizes ) ) {
-                $_sizes = array();
 
                 foreach ( $sizes as $size ) {
                         $tag = false;
@@ -1026 +1084 @@
                 $meta['sizes'] = array_merge( $meta['sizes'], $img->multi_resize( $_sizes ) );
         }
 
+        $original_directory = pathinfo( $new_path, PATHINFO_DIRNAME );
+        $filename           = pathinfo( $new_path, PATHINFO_FILENAME );
+        $main_images        = array();
+        $subsized_images    = array();
+
+        foreach ( $mime_transforms as $targeted_mime ) {
+                if ( $targeted_mime !== $post->post_mime_type ) {
+                        if ( ! $img::supports_mime_type( $targeted_mime ) ) {
+                                continue;
+                        }
+
+                        $extension = wp_get_default_extension_for_mime_type( $targeted_mime );
+                        if ( false === $extension ) {
+                                continue;
+                        }
+                        $img->set_output_mime_type( $targeted_mime );
+
+                        if ( 'thumbnail' === $target ) {
+                                if ( ! isset( $subsized_images[ $post->post_mime_type ]['thumbnail']['file'] ) ) {
+                                        continue;
+                                }
+
+                                $result = $img->make_subsize( $subsized_images[ $post->post_mime_type ]['thumbnail'] );
+
+                                if ( is_wp_error( $result ) ) {
+                                        continue;
+                                }
+
+                                $subsized_images[ $targeted_mime ] = array( 'thumbnail' => $result );
+                        } else {
+                                $result = $img->save( $img->generate_filename( '', $filename, $extension ) );
+
+                                if ( is_wp_error( $result ) ) {
+                                        continue;
+                                }
+
+                                $main_images[ $targeted_mime ] = $result;
+                                if ( method_exists( $img, 'make_subsize' ) ) {
+                                        foreach ( $_sizes as $size_name => $size_data ) {
+                                                $size_meta = $img->make_subsize( $size_data );
+
+                                                if ( ! is_wp_error( $size_meta ) ) {
+                                                        $subsized_images[ $targeted_mime ][ $size_name ] = $size_meta;
+                                                }
+                                        }
+                                } else {
+                                        $subsized_images[ $targeted_mime ] = $img->multi_resize( $_sizes );
+                                }
+                        }
+                } else {
+                        // If the target is `thumbnail` make sure it is the only selected size.
+                        // When the targeted thumbnail is selected no additional size and subsize is set.
+                        if ( 'thumbnail' === $target && isset( $meta['sizes']['thumbnail'] ) ) {
+                                $subsized_images[ $targeted_mime ] = array( 'thumbnail' => $meta['sizes']['thumbnail'] );
+                        } else {
+                                $main_images[ $targeted_mime ]     = array(
+                                        'path' => $new_path,
+                                        'file' => pathinfo( $new_path, PATHINFO_BASENAME ),
+                                );
+                                $subsized_images[ $targeted_mime ] = $meta['sizes'];
+                        }
+                }
+
+                if ( isset( $main_images[ $targeted_mime ]['path'], $main_images[ $targeted_mime ]['file'] ) && file_exists( $main_images[ $targeted_mime ]['path'] ) ) {
+                        // Add sources to original image metadata.
+                        $meta['sources'][ $targeted_mime ] = array(
+                                'file'     => $main_images[ $targeted_mime ]['file'],
+                                'filesize' => isset( $main_images[ $targeted_mime ]['filesize'] ) ? $main_images[ $targeted_mime ]['filesize'] : wp_filesize( $main_images[ $targeted_mime ]['path'] ),
+                        );
+                }
+
+                foreach ( $_sizes as $size_name => $size_details ) {
+                        if ( empty( $subsized_images[ $targeted_mime ][ $size_name ]['file'] ) ) {
+                                continue;
+                        }
+
+                        // Add sources to resized image metadata.
+                        $subsize_path = path_join( $original_directory, $subsized_images[ $targeted_mime ][ $size_name ]['file'] );
+                        if ( ! file_exists( $subsize_path ) ) {
+                                continue;
+                        }
+
+                        $meta['sizes'][ $size_name ]['sources'][ $targeted_mime ] = array(
+                                'file'     => $subsized_images[ $targeted_mime ][ $size_name ]['file'],
+                                'filesize' => wp_filesize( $subsize_path ),
+                        );
+                }
+        }
+
         unset( $img );
 
         if ( $success ) {
                 wp_update_attachment_metadata( $post_id, $meta );
                 update_post_meta( $post_id, '_wp_attachment_backup_sizes', $backup_sizes );
 
+                $next_target_size_name_from_source = null;
+                // Store the provided sources for the attachment ID in the `_wp_attachment_backup_sources` with the next available target if target is `null` no source would be stored.
+                foreach ( array_keys( $backup_sizes ) as $size_name ) {
+                        // If the target already has the sources attributes find the next one.
+                        if ( isset( $backup_sources[ $size_name ] ) ) {
+                                continue;
+                        }
+
+                        // We are only interested in the `full-` sizes.
+                        if ( strpos( $size_name, 'full-' ) === false ) {
+                                continue;
+                        }
+
+                        $next_target_size_name_from_source = $size_name;
+                }
+
+                if ( null !== $next_target_size_name_from_source && ! empty( $old_metadata['sources'] ) ) {
+                        $backup_sources[ $next_target_size_name_from_source ] = $old_metadata['sources'];
+                        // Store the `sources` property into the full size if present.
+                        update_post_meta( $post_id, '_wp_attachment_backup_sources', $backup_sources );
+                }
+
                 if ( 'thumbnail' === $target || 'all' === $target || 'full' === $target ) {
                         // Check if it's an image edit from attachment edit screen.
                         if ( ! empty( $_REQUEST['context'] ) && 'edit-attachment' === $_REQUEST['context'] ) {

src/wp-includes/post.php

@@ -6388 +6388 @@
         delete_post_meta( $post_id, '_wp_trash_meta_status' );
         delete_post_meta( $post_id, '_wp_trash_meta_time' );
 
-        $meta         = wp_get_attachment_metadata( $post_id );
-        $backup_sizes = get_post_meta( $post->ID, '_wp_attachment_backup_sizes', true );
-        $file         = get_attached_file( $post_id );
+        $meta           = wp_get_attachment_metadata( $post_id );
+        $backup_sizes   = get_post_meta( $post->ID, '_wp_attachment_backup_sizes', true );
+        $backup_sources = get_post_meta( $post->ID, '_wp_attachment_backup_sources', true );
+        $file           = get_attached_file( $post_id );
 
         if ( is_multisite() && is_string( $file ) && ! empty( $file ) ) {
                 clean_dirsize_cache( $file );
@@ -6436 +6437 @@
         /** This action is documented in wp-includes/post.php */
         do_action( 'deleted_post', $post_id, $post );
 
-        wp_delete_attachment_files( $post_id, $meta, $backup_sizes, $file );
+        wp_delete_attachment_files( $post_id, $meta, $backup_sizes, $file, $backup_sources );
 
         clean_post_cache( $post );
 
@@ -6450 +6451 @@
  *
  * @global wpdb $wpdb WordPress database abstraction object.
  *
- * @param int    $post_id      Attachment ID.
- * @param array  $meta         The attachment's meta data.
- * @param array  $backup_sizes The meta data for the attachment's backup images.
- * @param string $file         Absolute path to the attachment's file.
+ * @param int    $post_id        Attachment ID.
+ * @param array  $meta           The attachment's meta data.
+ * @param array  $backup_sizes   The meta data for the attachment's backup images.
+ * @param string $file           Absolute path to the attachment's file.
+ * @param array  $backup_sources The meta data for the attachment's backup sources images.
  * @return bool True on success, false on failure.
  */
-function wp_delete_attachment_files( $post_id, $meta, $backup_sizes, $file ) {
+function wp_delete_attachment_files( $post_id, $meta, $backup_sizes, $file, $backup_sources ) {
         global $wpdb;
 
         $uploadpath = wp_get_upload_dir();
@@ -6580 +6582 @@
                 }
         }
 
+        // Delete full sizes backup sources mime types.
+        if ( is_array( $backup_sources ) ) {
+                foreach ( $backup_sources as $backup_source ) {
+
+                        foreach ( $backup_source as $properties ) {
+                                if ( ! is_array( $properties ) || empty( $properties['file'] ) ) {
+                                        continue;
+                                }
+
+                                $source_file = str_replace( wp_basename( $file ), $properties['file'], $file );
+                                $del_file    = path_join( $uploadpath['basedir'], $source_file );
+                                if ( ! wp_delete_file_from_directory( $del_file, $intermediate_dir ) ) {
+                                        $deleted = false;
+                                }
+                        }
+                }
+        }
+
         return $deleted;
 }
 

tests/phpunit/tests/image/editor.php

@@ -627 +627 @@
                 );
         }
 
+        /**
+         * Test removing the backup sources files when image is removed after edited.
+         *
+         * @ticket 55443
+         */
+        public function it_should_remove_the_backup_sizes_and_sources_if_the_attachment_is_deleted_after_edit() {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $attachment_id = $this->factory->attachment->create_upload_object(
+                        DIR_TESTDATA . '/tests/testdata/modules/images/leafs.jpg'
+                );
+
+                $file    = get_attached_file( $attachment_id, true );
+                $dirname = pathinfo( $file, PATHINFO_DIRNAME );
+
+                $this->assertIsString( $file );
+                $this->assertFileExists( $file );
+
+                $_REQUEST['action']  = 'image-editor';
+                $_REQUEST['context'] = 'edit-attachment';
+                $_REQUEST['postid']  = $attachment_id;
+                $_REQUEST['target']  = 'all';
+                $_REQUEST['do']      = 'save';
+                $_REQUEST['history'] = '[{"r":-90}]';
+
+                wp_save_image( $attachment_id );
+
+                $backup_sources = get_post_meta( $attachment_id, '_wp_attachment_backup_sources', true );
+                $this->assertNotEmpty( $backup_sources );
+                $this->assertIsArray( $backup_sources );
+
+                $backup_sizes = get_post_meta( $attachment_id, '_wp_attachment_backup_sizes', true );
+                $this->assertNotEmpty( $backup_sizes );
+                $this->assertIsArray( $backup_sizes );
+
+                wp_delete_attachment( $attachment_id, true );
+
+                $this->assertFileDoesNotExist( path_join( $dirname, $backup_sources['full-orig']['image/webp']['file'] ) );
+                $this->assertFileDoesNotExist( path_join( $dirname, $backup_sizes['thumbnail-orig']['sources']['image/webp']['file'] ) );
+        }
+
         /**
          * Test avoiding the change of URLs of images that are not part of the media library.
          *

tests/phpunit/tests/image/functions.php

@@ -248 +248 @@
                 fclose( $handle );
         }
 
+        /**
+         * Backup the sources structure alongside the full size
+         *
+         * @ticket 55443
+         */
+        public function test_backup_the_sources_structure_alongside_the_full_size() {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $attachment_id = self::factory()->attachment->create_upload_object( DIR_TESTDATA . '/images/canola.jpg' );
+
+                $metadata = wp_get_attachment_metadata( $attachment_id );
+                $this->assertEmpty( get_post_meta( $attachment_id, '_wp_attachment_backup_sizes', true ) );
+                $this->assertEmpty( get_post_meta( $attachment_id, '_wp_attachment_backup_sources', true ) );
+
+                $_REQUEST['action']  = 'image-editor';
+                $_REQUEST['context'] = 'edit-attachment';
+                $_REQUEST['postid']  = $attachment_id;
+                $_REQUEST['target']  = 'all';
+                $_REQUEST['do']      = 'save';
+                $_REQUEST['history'] = '[{"r":-90}]';
+
+                $ret = wp_save_image( $attachment_id );
+
+                $backup_sizes = get_post_meta( $attachment_id, '_wp_attachment_backup_sizes', true );
+
+                $this->assertNotEmpty( $backup_sizes );
+                $this->assertIsArray( $backup_sizes );
+
+                $backup_sources = get_post_meta( $attachment_id, '_wp_attachment_backup_sources', true );
+                $this->assertIsArray( $backup_sources );
+                $this->assertArrayHasKey( 'full-orig', $backup_sources );
+                $this->assertSame( $metadata['sources'], $backup_sources['full-orig'] );
+
+                foreach ( $backup_sizes as $size => $properties ) {
+                        $size_name = str_replace( '-orig', '', $size );
+
+                        if ( 'full-orig' === $size ) {
+                                continue;
+                        }
+
+                        $this->assertArrayHasKey( 'sources', $properties );
+                        $this->assertSame( $metadata['sizes'][ $size_name ]['sources'], $properties['sources'] );
+                }
+        }
+
+        /**
+         * Restore the sources array from the backup when an image is edited
+         *
+         * @ticket 55443
+         */
+        public function test_restore_the_sources_array_from_the_backup_when_an_image_is_edited() {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $attachment_id = self::factory()->attachment->create_upload_object( DIR_TESTDATA . '/images/canola.jpg' );
+
+                $metadata = wp_get_attachment_metadata( $attachment_id );
+
+                $_REQUEST['action']  = 'image-editor';
+                $_REQUEST['context'] = 'edit-attachment';
+                $_REQUEST['postid']  = $attachment_id;
+                $_REQUEST['target']  = 'all';
+                $_REQUEST['do']      = 'save';
+                $_REQUEST['history'] = '[{"r":-90}]';
+
+                $ret = wp_save_image( $attachment_id );
+
+                $backup_sources = get_post_meta( $attachment_id, '_wp_attachment_backup_sources', true );
+
+                $this->assertArrayHasKey( 'full-orig', $backup_sources );
+                $this->assertIsArray( $backup_sources['full-orig'] );
+                $this->assertSame( $metadata['sources'], $backup_sources['full-orig'] );
+
+                wp_restore_image( $attachment_id );
+
+                $metadata               = wp_get_attachment_metadata( $attachment_id );
+                $updated_backup_sources = get_post_meta( $attachment_id, '_wp_attachment_backup_sources', true );
+
+                $this->assertSame( $backup_sources['full-orig'], $metadata['sources'] );
+                $this->assertNotSame( $backup_sources, $updated_backup_sources );
+                $this->assertCount( 1, $backup_sources );
+                $this->assertCount( 2, $updated_backup_sources );
+
+                $backup_sizes = get_post_meta( $attachment_id, '_wp_attachment_backup_sizes', true );
+                foreach ( $backup_sizes as $size_name => $properties ) {
+                        // We are only interested in the original filenames to be compared against the backup and restored values.
+                        if ( false === strpos( $size_name, '-orig' ) ) {
+                                continue;
+                        }
+
+                        $size_name = str_replace( '-orig', '', $size_name );
+                        // Full name is verified above.
+                        if ( 'full' === $size_name ) {
+                                continue;
+                        }
+
+                        $this->assertArrayHasKey( $size_name, $metadata['sizes'] );
+                        $this->assertArrayHasKey( 'sources', $metadata['sizes'][ $size_name ] );
+                        $this->assertSame( $properties['sources'], $metadata['sizes'][ $size_name ]['sources'] );
+                }
+        }
+
         /**
          * Tests wp_save_image_file() and mime types.
          *