obtener atributos / parte del código corto de la galería

2

Estoy intentando capturar todas las ID de imagen asociadas con el código abreviado [galería] que se enumeran como excluir. Por ejemplo: si mi publicación tiene [gallery exclude="1,2,3"] me gustaría obtener una variable que tenga un eco como este echo $excludes; resultado 1,2,3 gracias por la ayuda que puede ofrecer.

    
pregunta sosukeinu 25.10.2012 - 15:43

3 respuestas

1

Me tomó un tiempo encontrar una solución que funcionara para mí, pero como todo lo que buscaba era la lista delimitada de ID de adjuntos asociada con un determinado atributo como exclude o hide , esto funcionó para mí:

# Grab the list of "hide" attribute
$regex_pattern = get_shortcode_regex();
preg_match ('/'.$regex_pattern.'/s', $post->post_content, $regex_matches);
    if ($regex_matches[2] == 'gallery') :
     $attribureStr = str_replace (" ", "&", trim ($regex_matches[3]));
     $attribureStr = str_replace ('"', '', $attribureStr);
     //  Parse the attributes
      $defaults = array (
      'hide' => '1',
     );
    $attributes = wp_parse_args ($attribureStr, $defaults);
     if (isset ($attributes["hide"])) :
      $excludeID = get_post_thumbnail_id() . ',' . $attributes["hide"];
     else :
      $excludeID = get_post_thumbnail_id();
   endif;
endif;
    
respondido por el sosukeinu 21.11.2012 - 19:23
3

La tarea

No es tan fácil, como parece a primera vista. El problema principal es que puede definir su propio código corto [gallery] y simplemente anular el valor predeterminado. En realidad, eso es lo que hacen algunos temas (¡culpe a los autores de ThemeForest!). En este caso, el simple hecho de enlazar con post_gallery no funcionará en todos los casos.

Inconvenientes para post_gallery

El problema es que tanto el código abreviado como la devolución de llamada del núcleo se pueden anular y, por lo tanto, cada devolución de llamada simplemente se eliminará.

Inconvenientes para the_content

Si está cambiando a otro filtro y toma la salida en bruto, entonces tendrá que negociar (en otro momento) con el Regex. Esto es lento y en su mayoría no será simple.

Entonces, ¿qué hacer ahora? Fácil. Interactúa con el global $shortcode_tags . Mantiene la devolución de llamada como segundo argumento, por lo que en realidad no es demasiado difícil determinar en qué caso lo somos. Entonces podemos simplemente cambiar en la demanda. De esta manera tenemos un buen equilibrio entre confiabilidad y rendimiento.

Construye un complemento base

Aquí hay un complemento que define una clase abstract (uno que debe obtener extend ed para que funcione). Hay tres cosas que necesitan definición en la clase secundaria:

  • $part : la parte que desea recuperar
  • $type - el tipo de coincidencia que necesitas. Válido son digit/alphanumeric/alpha
  • process_atts() - el método que procesa su salida - lo que quiera hacer con el resultado

Simplemente cargue esto a través de (S) FTP en su carpeta de complementos y active.

<?php
/** Plugin Name: (#70451) »kaiser« Get Gallery attributes (Base) */
if ( ! class_exists( 'wpse70451_extract_gallery_atts' ) )
{

abstract class wpse70451_extract_gallery_atts
{
    public $atts  = array();

    public $error;

    // Must get defined in extending class
    public $part;
    public $type;

    public static function init()
    {
        is_null( self :: $instance ) AND self :: $instance = new self;
        return self :: $instance;
    }

    public function __construct()
    {
        ! isset( $this->part ) AND new WP_Error();

        add_action( 'loop_start', array( $this, 'error_handler' ) );

        // The value of the array is the callback fn name
        // If it's the default, then we're on the safe side,
        // as the core fn is no pluggable and can't get overridden.
        if ( 'gallery_shortcode' === $GLOBALS['shortcode_tags'] )
        {
            add_filter( 'post_gallery', array( $this, 'get_gallery_atts' ), 0, 2 );
        }
        // Else we have to go with a slower regex
        else
        {
            add_filter( 'the_content', array( $this, 'get_gallery_ids' ), 0 );
        }
    }

    public function error_handler()
    {
        if (
            ! in_array(
                 $this->type
                ,array(
                     'digit'
                    ,'alphanumeric'
                    ,'alpha'
                 )
            )
            OR ! empty( $this->type )
        )
            return new WP_Error( 
                 'invalid_type'
                ,__( 'Invalid type set.', 'wpse70451_textdomain' )
                ,__FILE__
            );
    }

    public function __toString()
    {
        $is_error = $this->error;

        if ( ! is_wp_error( $is_error ) )
            return;

        // No error message for Guests or Subscribers
        // Assuming that no one has activated caching plugins when debugging
        // and not set WP_DEBUG to TRUE on a live site
        if ( 
            ! is_user_logged_in()
            AND ! current_user_can( 'edit_posts' ) 
            AND ( ! defined( 'WP_DEBUG' ) OR ! WP_DEBUG )
        )
            return '';

        // Error output for development
        return "{$is_error->get_error_message( 'invalid_type' )}: {$is_error->get_error_data()}";
    }

    public function get_gallery_ids( $content )
    {
        $pattern = get_shortcode_regex( $content );
        preg_match_all( "/{$pattern}/s", $content, $matches );
        $atts = explode( " ", array_shift( $matches[3] ) );
        foreach ( $atts as $att )
        {
            if ( strstr( $att, $this->part ) )
                break;
        }
        preg_match_all( $this->get_regex( $this->type ), trim( $att ), $atts );
        $this->atts = array_filter( $atts );

        return $content;
    }

    // Build pattern
    public function get_regex( $type )
    {
        switch ( $type )
        {
            case 'digit' :
                $pattern_atts = '/(\d*)/';
                break;

            case 'alphanumeric' :
                $pattern_atts = '/([A-Za-z0-9]*)/';
                break;

            case 'alpha' :
                $pattern_atts = '/([A-Za-z]*)/';
                break;

            default :
                // Add a method name 'get_pattern()' to the extending class
                // to work with a custom regex pattern.
                if (  method_exists( $this, 'get_pattern' ) )
                {
                    $pattern_atts = $this->get_pattern();
                    break;
                }
                $pattern_atts = $this->get_regex( 'alphanumeric' );
                break;
        }

        return $pattern_atts;
    }

    public function get_gallery_atts( $content, $atts )
    {
        $this->atts = $atts[ $this->part ];

        // Allow overrides to trigger
        // at this point we already got what we need
        return $content;
    }

    // Must get defined in extending class
    public abstract function process_atts() {}
} // END Class

} // endif;

Manejar una tarea, obtener un hijo

Aquí puedes ver el complemento de procesamiento real. Primero se engancha estáticamente al gancho init y luego ejecuta el método de los padres __construct() para recuperar los atributos.

Luego, debe definir qué atributos desea recuperar (consulte las propiedades de las clases $part y $type , que ya están predeterminadas para lo que solicitó).

Las dos últimas decisiones que debes tomar son

  1. ¿Qué quiero hacer con mi resultado? Ver process_atts()
  2. ¿Cuándo desea generar el resultado? Vea __construct() y donde process_atts() está conectado.

Es tan fácil como eso.

Si necesita una expresión regular personalizada, solo agregue un método llamado get_regex() a su clase extendida y return su patrón personalizado. Luego, establezca $type en y vacíe la cadena '' y estará listo para comenzar.

<?php
/** Plugin Name: (#70451) »kaiser« Get Gallery excludes */

if ( ! class_exists( 'wpse70451_extract_gallery_excludes' ) )
{
    add_action( 'init', array( 'wpse70451_extract_gallery_excludes', 'init' ) );

final class wpse70451_extract_gallery_excludes extends wpse70451_extract_gallery_atts
{
    public static $instance;

    public $part = 'exclude';

    public $type = 'digit';

    public static function init()
    {
        is_null( self :: $instance ) AND self :: $instance = new self;
        return self :: $instance;
    }

    public function __construct()
    {
        parent :: __construct();

        // Example hook: 'loop_end'
        add_action( 'loop_end', array( $this, 'process_atts' ) );
    }

    public function process_atts()
    {
        $markup = '';
        // Do something with $this->atts;
        return print $markup;
    }
} // END Class

} // endif;

Modifique lo que necesita y luego otra vez: simplemente cargue esto a través de (S) FTP en su carpeta de complementos y active.

    
respondido por el kaiser 25.10.2012 - 17:00
1

Si también necesita mostrar el contenido en la misma página, ¿qué sucede con el uso del filtro post_gallery ? No necesitarás ninguna expresión regular entonces

add_filter('post_gallery', 'gallery_shortcode_excludes', 10, 2);
function gallery_shortcode_excludes($content, $attr) {
    $excludes = $attr['excludes'];
    // maybe also save it in some global/class/static variable

    //  return empty string to let wordpress continue to the shortcode output
    return '';
}
    
respondido por el Mridul Aggarwal 25.10.2012 - 16:01

Lea otras preguntas en las etiquetas