single-{$post_type}-{slug}.php para tipos de entrada personalizados

A) La Base en el Núcleo

Como puedes ver en el Codex en la explicación de la Jerarquía de Plantillas, single-{$post_type}.php ya está soportado.

B) Extendiendo la Jerarquía del Núcleo

Afortunadamente, ahora hay algunos filtros y ganchos dentro de /wp-includes/template-loader.php.

• do_action('template_redirect');
• apply_filters( 'template_include', $template )
• Y: un filtro específico dentro de get_query_template( $type, ... ) llamado: "$type}_template"

B.1) Cómo funciona

1. Dentro del archivo del cargador de plantillas, la plantilla se carga mediante una variable de consulta/condicional wp_query: is_*().
2. El condicional luego activa (en el caso de una plantilla "single"): is_single() && $template = get_single_template()
3. Esto a su vez activa get_query_template( $type, $templates ), donde $type es single
4. Luego tenemos el filtro "{$type}_template"

C) La Solución

Como solo queremos extender la jerarquía con una plantilla que se cargue antes de la plantilla actual "single-{$object->post_type}.php", interceptaremos la jerarquía y agregaremos una nueva plantilla al principio del array de plantillas.

// Extender la jerarquía
function add_posttype_slug_template( $templates )
{

    $object = get_queried_object();

    // Nueva 
    $templates[] = "single-{$object->post_type}-{$object->post_name}.php";
    // Como en el núcleo
    $templates[] = "single-{$object->post_type}.php";
    $templates[] = "single.php";

    return locate_template( $templates );    
}
// Ahora agregamos el filtro al gancho apropiado
function intercept_template_hierarchy()
{
    add_filter( 'single_template', 'add_posttype_slug_template', 10, 1 );
}
add_action( 'template_redirect', 'intercept_template_hierarchy', 20 );

^{NOTA: (Si deseas usar algo diferente al slug predeterminado del objeto) Tendrás que ajustar $slug según la estructura de tus enlaces permanentes. Simplemente usa lo que necesites del objeto global (object) $post.}

Tickets de Trac

Dado que el enfoque anterior actualmente no está soportado (solo puedes filtrar la ruta absoluta ubicada de esta manera), aquí hay una lista de tickets de trac:

• Extendiendo la jerarquía con post_type->slug
• Introducir un filtro para get_query_template()
• Filtrar la jerarquía completa - ticket más prometedor ⤎ sigue este ticket ^{por @scribu} como cc

Siguiendo la imagen de la Jerarquía de Plantillas, no veo tal opción.

Así que aquí está cómo lo haría:

Solución 1 (La mejor en mi opinión)

Crea un archivo de plantilla y asócialo a la reseña

 <?php
 /*
 Template Name: Mi Gran Reseña
 */
 ?>

Al añadir el archivo PHP de plantilla en tu directorio de tema, aparecerá como una opción de plantilla en la página de edición de tu entrada.

Solución 2

Esto probablemente se podría lograr usando el hook template_redirect.

En el archivo functions.php:

 function my_redirect()
 {
      global $post;

      if( get_post_type( $post ) == "my_cpt" && is_single() )
      {
           if( file_exists( get_template_directory() . '/single-my_cpt-' . $post->post_name . '.php' ) )
           {
                include( get_template_directory() . '/single-my_cpt-' . $post->post_name . '.php' );
                exit;
           }
      }
 }
 add_action( 'template_redirect', 'my_redirect' );

EDITADO

Añadida verificación con file_exists

La respuesta principal (de hace 4 años) ya no funciona, pero el codex de WordPress tiene la solución aquí:

<?php
function add_posttype_slug_template( $single_template )
{
    $object = get_queried_object();
    $single_postType_postName_template = locate_template("single-{$object->post_type}-{$object->post_name}.php");
    if( file_exists( $single_postType_postName_template ) )
    {
        return $single_postType_postName_template;
    } else {
        return $single_template;
    }
}
add_filter( 'single_template', 'add_posttype_slug_template', 10, 1 );
?>

En mi caso, tengo tipos de contenido personalizados (custom post types) para Álbum y Pista vinculados por una taxonomía de Álbum. Quería poder usar diferentes plantillas Single para los posts de Álbum y Pista dependiendo de su taxonomía de Álbum.

Basándome en la respuesta de Kaiser anteriormente, escribí este código. Funciona bien.
Nota: No necesité el add_action().

// Añadir una opción de plantilla adicional a la jerarquía de plantillas
add_filter( 'single_template', 'add_albumtrack_taxslug_template', 10, 1 );
function add_albumtrack_taxslug_template( $orig_template_path )
{
    // en este punto, $orig_template_path es la ruta absoluta localizada a la plantilla single preferida

    $object = get_queried_object();

    if ( ! (
        // especificar otra opción de plantilla solo para los tipos de post Álbum y Pista
        in_array( $object->post_type, array( 'gregory-cpt-album','gregory-cpt-track' )) &&
        // verificar que la taxonomía Álbum ha sido registrada
        taxonomy_exists( 'gregory-tax-album' ) &&
        // obtener el término de taxonomía Álbum para el post actual
        $album_tax = wp_get_object_terms( $object->ID, 'gregory-tax-album' )
        ))
        return $orig_template_path;

    // ensamblar el nombre de la plantilla
    // suposición: solo un término de taxonomía Álbum por post. Usamos el primer objeto del array.
    $template = "single-{$object->post_type}-{$album_tax[0]->slug}.php";
    $template = locate_template( $template );
    return ( !empty( $template ) ? $template : $orig_template_path );
}

Ahora puedo crear plantillas llamadas single-gregory-cpt-track-tax-serendipity.php y single-gregory-cpt-album-tax-serendipity.php y WP las usará automáticamente; 'tax-serendipity' es el slug para el primer término de la taxonomía Álbum.

Para referencia, el hook de filtro 'single_template' se declara en:
/wp-includes/theme.php: get_query_template()

Gracias Kaiser por el código de ejemplo.

Saludos,
Gregory

Usar Plantillas de Página

Otro enfoque para la escalabilidad sería duplicar la funcionalidad del menú desplegable de plantillas de página en el tipo de entrada page para tu tipo de entrada personalizado.

Código Reutilizable

La duplicación en el código no es una buena práctica. Con el tiempo puede causar un grave aumento en la base de código que luego dificulta mucho su gestión por parte del desarrollador. En lugar de crear una plantilla para cada slug individual, lo más probable es que necesites una plantilla de uno-a-muchos que pueda reutilizarse en lugar de una relación uno-a-uno entre entrada y plantilla.

El Código

# Define tu cadena de tipo de entrada personalizado
define('MY_CUSTOM_POST_TYPE', 'my-cpt');

/**
 * Registrar el meta box
 */
add_action('add_meta_boxes', 'page_templates_dropdown_metabox');
function page_templates_dropdown_metabox(){
    add_meta_box(
        MY_CUSTOM_POST_TYPE.'-page-template',
        __('Template', 'rainbow'),
        'render_page_template_dropdown_metabox',
        MY_CUSTOM_POST_TYPE,
        'side', #Prefiero la ubicación debajo del meta box de acciones de entrada
        'low'
    );
}

/**
 * Renderizar tu meta box - Este código es similar al que se muestra en el tipo de entrada page
 * @return void
 */
function render_page_template_dropdown_metabox(){
    global $post;
    $template = get_post_meta($post->ID, '_wp_page_template', true);
    echo "
        <label class='screen-reader-text' for='page_template'>Plantilla de Página</label>
            <select name='_wp_page_template' id='page_template'>
            <option value='default'>Plantilla por Defecto</option>";
            page_template_dropdown($template);
    echo "</select>";
}

/**
 * Guardar la plantilla de página
 * @return void
 */
function save_page_template($post_id){

    # Saltar los auto guardados
    if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE )
        return;
    elseif ( defined( 'DOING_AJAX' ) && DOING_AJAX )
        return;
    elseif ( defined( 'DOING_CRON' ) && DOING_CRON )
        return;

    # Solo actualizar el meta de plantilla de página si estamos en nuestro tipo de entrada específico
    elseif(MY_CUSTOM_POST_TYPE === $_POST['post_type'])
        update_post_meta($post_id, '_wp_page_template', esc_attr($_POST['_wp_page_template']));
}
add_action('save_post', 'save_page_template');


/**
 * Establecer la plantilla de página
 * @param string $template La plantilla determinada por WordPress
 * @return string $template Ruta completa a la plantilla predefinida o personalizada
 */
function set_page_template($template){
    global $post;
    if(MY_CUSTOM_POST_TYPE === $post->post_type){
        $custom_template = get_post_meta($post->ID, '_wp_page_template', true);
        if($custom_template)
            #como nuestro menú solo da el nombre base, usa la función locate_template() para encontrar fácilmente la ruta completa
            return locate_template($custom_template);
    }
    return $template;
}
add_filter('single_template', 'set_page_template');

Esta es una respuesta un poco tardía, pero pensé que sería valiosa ya que nadie en la web ha documentado este enfoque que yo sepa. Espero que esto ayude a alguien.

Actualización para el código de Brian, descubrí que cuando no se utilizaba el cuadro desplegable, la opción de plantilla "default" se guardaba en wp_page_template, lo que hacía que intentara encontrar una plantilla llamada default. Este cambio simplemente verifica si la opción es "default" al guardar y elimina el meta del post en su lugar (útil si cambiaste la opción de plantilla de vuelta a default)

elseif(MY_CUSTOM_POST_TYPE === $_POST['post_type']) {

if ( esc_attr($_POST['_wp_page_template']) === "default" ) :
    delete_post_meta($post_id, '_wp_page_template');
else :
    update_post_meta($post_id, '_wp_page_template', esc_attr($_POST['_wp_page_template']));
endif;
}