Traiter les problèmes de modification de la mise à l'échelle de l'image (arrondi) dans 4.1 (ticket WP # 18532)

16

Je suis en train de migrer le contenu du site d'un ancien site pré-4.1 vers une nouvelle configuration et de rencontrer un problème lié à l'erreur d'arrondi de # 18532 et le correctif correspondant .

En résumé, nous avons corrigé un problème de comportement récurrent lié à WordPress:

Imaginez que nous téléchargions une image au format 693x173 et l’échelonnions à une largeur de 300:

  • pré 4.1: 300x74
  • post 4.1: 300x75

Le problème

En règle générale, cela ne pose aucun problème, car les fichiers existants et <img> ne sont pas touchés.

Mais lorsque vous régénérez des thumbs ou importez des pièces jointes à partir d'un fichier WXR, elles sont générées différemment dans le système de fichiers, laissant ainsi <img> dans post_content mort.

Vous recherchez une solution

J'ai réfléchi à diverses solutions:

Retour au mauvais vieux temps

Changeset 30660 a introduit un nouveau filtre wp_constrain_dimensions qui peut être utilisé pour supprimer simplement l'ancien comportement 4.1 retour. Cela résout le problème. Mais je me demande si cela pourrait causer des problèmes plus tard et, en général, j'aimerais bien avoir la solution. Bien que cela fonctionne, je considère que ce n'est pas idéal.

Les temps changent »

Cela nous laisse donc un autre objectif: nettoyer la base de données et remplacer toutes les références aux anciens fichiers par des références aux nouveaux fichiers. La question que je pose en fait ici maintenant est comment faire cela. Je recherche une solution efficace et généralement applicable, car je soupçonne que ce problème affecte et touchera beaucoup de gens

Mon idée actuelle est la suivante:

  1. Importer, régénérer ou peu importe ce qui nous laisse avec les nouveaux fichiers et les balises brisées.
  2. Créez une liste A à partir de tous les fichiers redimensionnés du système de fichiers ou obtenez ces informations de la base de données
  3. Analyser cette liste et créer une seconde liste B avec des noms de fichiers tous décalés d'un pixel comme avant 4.1
  4. Effectuez une recherche et un remplacement sur l'ensemble de la base de données en remplaçant toutes les occurrences de B par l'entrée correspondante dans A

Je ne sais pas si c'est le moyen le plus intelligent et le plus efficace de gérer cette situation. Cela semble aussi un peu trop brutal. Donc, avant de le mettre en œuvre, je voulais juste vérifier avec l'infinie sagesse de la foule de la WPSE;)

[edit] Après avoir lu la réponse de ck-macleod (merci!), je pense un correctif devrait résoudre ce problème une fois pour toutes afin que vous n'ayez pas besoin de garder constamment ce problème à l'arrière de votre tête. [/ edit]

[edit2] Je viens de trouver un billet associé sur Trac . Ajout pour référence. [/ edit2]

    
posée kraftner 14.09.2015 - 11:30

3 réponses

4

Il s'agit d'une autre approche que l'autre réponse qui fonctionne lors de l'importation de contenu avec l'importateur et qui corrige les URL une fois. et pour tous. Encore une fois: ce n’est pas un test de combat mais c’est la solution que j’ai choisie et qui a fonctionné.

Je préfère ceci car cela résout le problème une fois pour toutes et si cela fonctionne, cela fonctionne. Étant donné que vous ne laissez pas des éléments cassés dans la base de données et que vous ne corrigez rien, vous n'avez pas à vous soucier de la rupture ultérieure des éléments.

/*
Plugin Name:  Bugfix Ticket 31581 for WP_Importer
Plugin URI:   https://wordpress.stackexchange.com/a/206992/47733
Description:  Fixes image references after post WP 4.1 image scaling change in post content when using the WP_Importer  (see https://core.trac.wordpress.org/ticket/31581)
Version:      0.0.1
*/

class Bugfix31581WPImporter {

    protected $remaps;

    /**
     * Initialize class, mainly setting up hooks
     */
    public function init(){

        if (WP_IMPORTING === true){

            $this->remaps = array();

            //This hook is chosen because it is pretty close to where the actual attachment import is happening.
            //TODO: May be reconsidered.
            add_filter('wp_update_attachment_metadata', array($this, 'collectRemaps'), 10 , 2);

            add_action('import_end', array($this, 'remap'));
            add_action('import_end', array($this, 'importEnded'));
        }

    }

    /**
     * Cleans up hooks after the import has ended.
     */
    public function importEnded(){
        remove_filter('wp_update_attachment_metadata', array($this, 'collectRemaps'), 10);

        remove_action('import_end', array($this, 'remap'), 10);
        remove_action('import_end', array($this, 'importEnded'), 10);
    }

    /**
     * When an attachment is added compare the resulting sizes with the sizes from the legacy algorithm and setup remap.
     *
     * @param $data
     * @param $post_id
     *
     * @return mixed
     */
    public function collectRemaps($data, $post_id ){

        $intermediate_sizes = $this->getIntermediateSizes();

        if(empty($data) || !array_key_exists('sizes', $data)){
            return $data;
        }

        foreach($data['sizes'] as $key => $size){

            $size_new_algorithm = array($size['width'], $size['height']);

            $dest_w = $intermediate_sizes[$key]['width'];
            $dest_h = $intermediate_sizes[$key]['height'];
            $crop = $intermediate_sizes[$key]['crop'];

            add_filter('wp_constrain_dimensions', array($this, 'legacy_wp_constrain_dimensions'), 10, 5);

            $size_old_algorithm = image_resize_dimensions($data['width'], $data['height'], $dest_w, $dest_h, $crop);

            //Bail out in the rare case of 'image_resize_dimensions' returning false
            if($size_old_algorithm===false){
                continue;
            }

            $size_old_algorithm = array($size_old_algorithm[4], $size_old_algorithm[5]);

            remove_filter('wp_constrain_dimensions', array($this, 'legacy_wp_constrain_dimensions'), 10);

            // Compare the current size with the calculation of the old algorithm...
            $diff = array_diff($size_new_algorithm, $size_old_algorithm);

            // ...to detect any mismatches
            if(!empty($diff)){

                $oldFilename = $this->getOldFilename($size['file'], $size_old_algorithm);

                // If getting the old filename didn't work for some reason (probably other filename-structure) bail out.
                if($oldFilename===false){
                    continue;
                }

                if(!array_key_exists($post_id, $this->remaps)){
                    $this->remaps[$post_id] = array();
                }

                $this->remaps[$post_id][$size['file']] = array(
                    'file' => $oldFilename,
                    'size' => $key
                );
            }

        }

        return $data;
    }

    /**
     * Get resize settings for all image sizes
     *
     * Taken from wp_generate_attachment_metadata() in includes/image.php
     *
     * @return array
     */
    public function getIntermediateSizes(){

        global $_wp_additional_image_sizes;

        $sizes = array();
        foreach ( get_intermediate_image_sizes() as $s ) {
            $sizes[$s] = array( 'width' => '', 'height' => '', 'crop' => false );
            if ( isset( $_wp_additional_image_sizes[$s]['width'] ) )
                $sizes[$s]['width'] = intval( $_wp_additional_image_sizes[$s]['width'] ); // For theme-added sizes
            else
                $sizes[$s]['width'] = get_option( "{$s}_size_w" ); // For default sizes set in options
            if ( isset( $_wp_additional_image_sizes[$s]['height'] ) )
                $sizes[$s]['height'] = intval( $_wp_additional_image_sizes[$s]['height'] ); // For theme-added sizes
            else
                $sizes[$s]['height'] = get_option( "{$s}_size_h" ); // For default sizes set in options
            if ( isset( $_wp_additional_image_sizes[$s]['crop'] ) )
                $sizes[$s]['crop'] = $_wp_additional_image_sizes[$s]['crop']; // For theme-added sizes
            else
                $sizes[$s]['crop'] = get_option( "{$s}_crop" ); // For default sizes set in options
        }

        return $sizes;
    }

    /**
     * Turn the new filename into the old filename reducing the height by one
     *
     * @param $newFilename
     * @param $size
     *
     * @return mixed
     */
    public function getOldFilename($newFilename, $size){

        $dimensions = array();

        $filetypes = $this->getAllowedImageExtentions();

        // TODO: This pattern can be different. See 'image_make_intermediate_size' in image editor implementation.
        $matchFiles = '/([0-9]{1,5})x([0-9]{1,5}).(' . $filetypes . ')$/';

        // Extract the dimensions
        preg_match($matchFiles,$newFilename,$dimensions);

        // If the file URL doesn't allow guessing the dimensions bail out.
        if(empty($dimensions)){
            return $newFilename;
        }

        $newStub = $dimensions[1] . 'x' . $dimensions[2] . '.' . $dimensions[3];

        $oldStub = $size[0] . 'x' . $size[1] . '.' . $dimensions[3];

        $oldFilename = str_replace($newStub,$oldStub,$newFilename);

        return $oldFilename;
    }

    /**
     * Extract all file extensions that match an image/* mime type
     *
     * @return string
     */
    protected function getAllowedImageExtentions(){
        $allowed_filetypes = get_allowed_mime_types();

        $allowed_images = array();

        foreach($allowed_filetypes as $extensions => $mimetype){
            if( substr($mimetype,0,6) == 'image/' ){
                $allowed_images[] = $extensions;
            }
        }

        return implode('|',$allowed_images);
    }


    /**
     * This is the heart of this class. Based on the collected remaps from earlier it does a S&R on the DB.
     */
    public function remap(){

        global $wpdb;

        foreach($this->remaps as $attachment_id => $replaces){

            foreach($replaces as $new_url => $old_data){

                $to_url = wp_get_attachment_image_src($attachment_id,$old_data['size']);
                $to_url = $to_url[0];

                $from_url = str_replace($new_url, $old_data['file'], $to_url);

                // remap urls in post_content
                $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->posts} SET post_content = REPLACE(post_content, %s, %s)", $from_url, $to_url) );

                //TODO: This is disabled as enclosures can't be images, right?
                // remap enclosure urls
                //$result = $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->postmeta} SET meta_value = REPLACE(meta_value, %s, %s) WHERE meta_key='enclosure'", $from_url, $to_url) );

            }

        }

    }

    /**
     * This is a copy of the legacy pre 4.1 wp_constrain_dimensions()
     *
     * @param $dimensions
     * @param $current_width
     * @param $current_height
     * @param $max_width
     * @param $max_height
     *
     * @return array
     */
    public function legacy_wp_constrain_dimensions($dimensions, $current_width, $current_height, $max_width, $max_height){
        if ( !$max_width and !$max_height )
            return array( $current_width, $current_height );

        $width_ratio = $height_ratio = 1.0;
        $did_width = $did_height = false;

        if ( $max_width > 0 && $current_width > 0 && $current_width > $max_width ) {
            $width_ratio = $max_width / $current_width;
            $did_width = true;
        }

        if ( $max_height > 0 && $current_height > 0 && $current_height > $max_height ) {
            $height_ratio = $max_height / $current_height;
            $did_height = true;
        }

        // Calculate the larger/smaller ratios
        $smaller_ratio = min( $width_ratio, $height_ratio );
        $larger_ratio  = max( $width_ratio, $height_ratio );

        if ( intval( $current_width * $larger_ratio ) > $max_width || intval( $current_height * $larger_ratio ) > $max_height )
            // The larger ratio is too big. It would result in an overflow.
            $ratio = $smaller_ratio;
        else
            // The larger ratio fits, and is likely to be a more "snug" fit.
            $ratio = $larger_ratio;

        // Very small dimensions may result in 0, 1 should be the minimum.
        $w = max ( 1, intval( $current_width  * $ratio ) );
        $h = max ( 1, intval( $current_height * $ratio ) );

        // Sometimes, due to rounding, we'll end up with a result like this: 465x700 in a 177x177 box is 117x176... a pixel short
        // We also have issues with recursive calls resulting in an ever-changing result. Constraining to the result of a constraint should yield the original result.
        // Thus we look for dimensions that are one pixel shy of the max value and bump them up
        if ( $did_width && $w == $max_width - 1 )
            $w = $max_width; // Round it up
        if ( $did_height && $h == $max_height - 1 )
            $h = $max_height; // Round it up

        return array( $w, $h );
    }

}

add_filter('import_start',array(new Bugfix31581WPImporter(),'init'));
    
réponse donnée kraftner 29.10.2015 - 11:31
1

Résoudre le problème de manière globale et parfaite pour TOUS les fichiers d’images (et liens) d’un grand site - étant donné la possibilité, par exemple, que des personnes aient parfois renommé des fichiers d’image imitant manuellement le style WP - ainsi que d’autres variations impaires - difficile. La recherche dans la base de données et les opérations de remplacement entraînent également des complications (et des risques!).

Pourriez-vous gérer la grande majorité des erreurs - images brisées et liens d’image brisés, je suppose - et obtenir le résultat final souhaité ou une télécopie raisonnable en appliquant la méthode suivante?

  1. Identifiez la date avant laquelle toutes les images redimensionnées ont été redimensionnées par l'ancienne méthode "intval" plutôt que par la nouvelle méthode "round". (Un type de seuil différent pourrait également être créé, mais la date semble plus facile.)

  2. Pour tous les articles publiés, < = est la date limite, exécutez preg_replace sur the_content () au moment du chargement / rendu, en capturant tous les fichiers image contenant le ou les motifs problèmes et en les remplaçant par le motif souhaité. La base de données resterait inchangée, mais la sortie serait sans erreur dans la plupart des cas. Je ne suis pas sûr que la solution doive s'appliquer à la fois au contenu de publication de page "singulier" et à l'archivage de pages ainsi qu'à d'autres processus.

Si une solution de ce type pouvait être utile, la question suivante serait alors de savoir si les modèles de problèmes et les remplacements pourraient être définis de manière adéquate. Il ressort de votre liste de solutions proposées que quelques motifs typiques pourraient en fait être isolés (peut-être pris à partir de paramètres de média précédents produisant des vignettes et d’autres images).

J'ai déjà écrit une fonction plus simple que j'utilise (et que je suis en train de transformer en plug-in), qui remplace globalement tous les fichiers image des répertoires désignés, jusqu'à une certaine date, par une image ou une image par défaut. -lien, selon le procédé décrit ci-dessus. C’était un site Web dans lequel, par excès de prudence en matière de droit d’auteur, les opérateurs supprimaient simplement toutes leurs images, ignorant qu’en plus de produire des résultats laids sur d’anciennes pages, ils étaient également en train de produire des milliers d’erreurs, deux pour chacun. image.

Si vous pouvez préciser le type de problème et préciser les cas dans lesquels la sortie doit être modifiée, je pourrais envisager de l'insérer dans mon format - ce qui n'est pas très compliqué et qui, pour un meilleur RegExer que je pourrais même être facile. Par ailleurs, je ne voudrais pas perdre votre temps ou mon temps si cette approche ne répondait pas au problème pour vous.

    
réponse donnée CK MacLeod 16.09.2015 - 23:38
1

D'accord, il s'agit d'une approche de base pour remplacer des images brisées à la volée. Sachez que ceci est davantage une preuve de concept qu'une solution testée au combat. Cela ne dépend que du filtre the_content qui peut (probablement) avoir des effets secondaires indésirables dans certaines situations. Manipuler avec soin. :)

Bien que le code l'indique également, je souhaite également créditer @Rarst pour cette réponse utilisée dans mon code.

/*
Plugin Name:  Bugfix 31581 Live
Plugin URI:   https://wordpress.stackexchange.com/a/206986/47733
Description:  Fixes image references in post content after post 4.1 image scaling change (see https://core.trac.wordpress.org/ticket/31581)
Version:      0.0.1
*/

class Bugfix31581Live {

    protected $matchURLs;
    protected $matchFiles;

    protected $remaps;

    public function init(){

        $filetypes = $this->get_allowed_image_extentions();

        $baseurl = wp_upload_dir();
        $baseurl = preg_quote($baseurl['baseurl'], '/');

        $this->matchURLs = '/' . $baseurl . '\/.??([a-zA-Z0-9_-]*?\.(?:' . $filetypes . '))/';

        //TODO: This pattern can be different. See 'image_make_intermediate_size' in image editor implementation
        $this->matchFiles = '/([0-9]{1,4})x([0-9]{1,4}).(' . $filetypes . ')$/';

        add_filter('the_content', array($this, 'update_urls') );
    }

    public function update_urls($content){

        $urls = array();

        preg_match_all($this->matchURLs,$content,$urls);

        // Bail out early if we don't have any match.
        if($urls === false || empty($urls[0])){
            return $content;
        }

        // Loop through all matches
        foreach($urls[0] as $url){

            // Try to resolve this URL to an attachment ID
            $id = $this->get_attachment_id($url);

            // If not  let's see if this might be a URL that has been broken by our beloved Changeset 30660
            if( $id === false ){

                $dimensions = array();

                // Extract the dimensions
                preg_match($this->matchFiles,$url,$dimensions);

                // If the file URL doesn't allow guessing the dimensions bail out.
                if(empty($dimensions)){
                    continue;
                }

                // Old filename
                $old = $dimensions[1] . 'x' . $dimensions[2] . '.' . $dimensions[3];

                // New filename (not sure if this exists yet)
                $new = $dimensions[1] . 'x' . ($dimensions[2]+1) . '.' . $dimensions[3];

                // Build the new URL (not sure if this exists yet)
                $new_url = str_replace($old,$new,$url);

                // Try to get the attachment with the new url
                $id = $this->get_attachment_id($new_url);

                // Bad luck. This also doesn't exist.
                if( $id === false ) {
                    continue;
                }

                // Just to be sure everything is in sync we get the URL built from id and size.
                $db_url = wp_get_attachment_image_src($id,array($dimensions[1], $dimensions[2]+1));

                // Check if the URL we created and the one wp_get_attachment_image_src builds are the same.
                if($new_url === $db_url[0]){

                    // Awesome let's replace the broken URL.
                    $content = str_replace($url,$new_url,$content);
                }

            }

        }

        return $content;
    }

    /**
     * Get the Attachment ID for a given image URL.
     *
     * @link   https://wordpress.stackexchange.com/a/7094
     *
     * @param  string $url
     *
     * @return boolean|integer
     */
    protected function get_attachment_id( $url ) {

        $dir = wp_upload_dir();

        // baseurl never has a trailing slash
        if ( false === strpos( $url, $dir['baseurl'] . '/' ) ) {
            // URL points to a place outside of upload directory
            return false;
        }

        $file  = basename( $url );
        $query = array(
            'post_type'  => 'attachment',
            'fields'     => 'ids',
            'meta_query' => array(
                array(
                    'value'   => $file,
                    'compare' => 'LIKE',
                ),
            )
        );

        $query['meta_query'][0]['key'] = '_wp_attached_file';

        // query attachments
        $ids = get_posts( $query );

        if ( ! empty( $ids ) ) {

            foreach ( $ids as $id ) {

                $tmp = wp_get_attachment_image_src( $id, 'full' );

                // first entry of returned array is the URL
                if ( $url === array_shift( $tmp ) )
                    return $id;
            }
        }

        $query['meta_query'][0]['key'] = '_wp_attachment_metadata';

        // query attachments again
        $ids = get_posts( $query );

        if ( empty( $ids) )
            return false;

        foreach ( $ids as $id ) {

            $meta = wp_get_attachment_metadata( $id );

            foreach ( $meta['sizes'] as $size => $values ) {

                $tmp = wp_get_attachment_image_src( $id, $size );

                if ( $values['file'] === $file && $url === array_shift( $tmp ) )
                    return $id;
            }
        }

        return false;
    }

    protected function get_allowed_image_extentions(){
        $allowed_filetypes = get_allowed_mime_types();

        $allowed_images = array();

        foreach($allowed_filetypes as $extensions => $mimetype){
            if( substr($mimetype,0,6) == 'image/' ){
                $allowed_images[] = $extensions;
            }
        }

        return implode('|',$allowed_images);
    }

}

add_filter('init',array(new Bugfix31581Live(),'init'));
    
réponse donnée kraftner 29.10.2015 - 11:17

Lire d'autres questions sur les étiquettes