¿Cómo obtengo una lista de todas las reescrituras de clase?

¿Hay alguna forma de enumerar todas las reescrituras y quizás otros conflictos potenciales además de revisar todos los archivos de configuración? Tengo que analizar algunos proyectos con muchas extensiones y modificaciones personalizadas y me gustaría automatizar tanto como sea posible.

Lo más importante es detectar extensiones que reescriban la misma clase, pero también me gustaría tener una lista de todas las reescrituras, para mantener una visión general. Por el momento mantengo esta lista manualmente en una hoja de cálculo.

Encontré esta extensión ("Conflicto de extensión") en Magento Connect, pero a juzgar por las revisiones y las notas de la versión, parece estar desactualizada.

Echa un vistazo a la utilidad n98-magerun :

Lista de reescritura

Enumera todas las reescrituras de clase registradas:

$ n98-magerun.phar dev:module:rewrite:list

Reescribir conflictos

Enumera todas las reescrituras duplicadas y te dice qué clase carga Magento. El comando verifica la herencia de clases en el orden de las dependencias de su módulo. n98-magerun.phar dev:module:rewrite:conflicts [--log-junit="..."]

Si se establece un nombre de archivo con la opción --log-junit, la herramienta genera un archivo XML y no produce ningún resultado en stdout.

También puede registrar los conflictos en un archivo XML de estilo JUnit para su posterior análisis, por ejemplo en un servidor de integración continua.

Descargo de responsabilidad: semi-self-link / Estoy involucrado en ese proyecto

Aquí una pequeña línea que te ofrece todas las reescrituras activas:

print_r(Mage::getConfig()->getNode()->xpath('//global//rewrite'));

Para limitarlo por tipo de objeto, agregue modelos, bloques o ayudantes a xpath respectivamente.
Por ejemplo:

Mage::getConfig()->getNode()->xpath('//global/models//rewrite')

Aquí hay un pequeño script que utilizo para verificar si se sobrescriben algunos modelos, bloques o ayudantes. Desafortunadamente, no funciona para los controladores y también tiene en cuenta los módulos deshabilitados. Pero desde mi punto de vista, esto no es gran cosa.

La idea principal es analizar los archivos de configuración y buscar la <rewrite>etiqueta. Crea un archivo php en el mismo nivel que index.php. Llamémoslo rewrites.php, con este contenido:

<?php 
$folders = array('app/code/local/', 'app/code/community/');//folders to parse
$configFiles = array();
foreach ($folders as $folder){
    $files = glob($folder.'*/*/etc/config.xml');//get all config.xml files in the specified folder
    $configFiles = array_merge($configFiles, $files);//merge with the rest of the config files
}
$rewrites = array();//list of all rewrites

foreach ($configFiles as $file){
    $dom = new DOMDocument;
    $dom->loadXML(file_get_contents($file));
    $xpath = new DOMXPath($dom);
        $path = '//rewrite/*';//search for tags named 'rewrite'
        $text = $xpath->query($path);
        foreach ($text as $rewriteElement){
            $type = $rewriteElement->parentNode->parentNode->parentNode->tagName;//what is overwritten (model, block, helper)
            $parent = $rewriteElement->parentNode->parentNode->tagName;//module identifier that is being rewritten (core, catalog, sales, ...)
            $name = $rewriteElement->tagName;//element that is rewritten (layout, product, category, order)
            foreach ($rewriteElement->childNodes as $element){
                $rewrites[$type][$parent.'/'.$name][] = $element->textContent;//class that rewrites it
            }
        }
}
echo "<pre>";print_r($rewrites);

al llamarlo en un navegador, debería ver algo como esto:

Array
(
    [models] => Array
        (
            [core/layout] => Array
                (
                    [0] => Namespace_Module_Model_Core_Layout
                    [1] => Namespace1_Module1_Model_Core_Layout //if the second element is present it means there is a possible conflict
                )
            [...] => ....

        )
    [blocks] => ...
    [helpers] => ...

)

Esto significa que el modelo 'core/layout'es sobrescrito porNamespace_Module_Model_Core_Layout

Si tiene 2 o más valores en la matriz ['core / layout'] significa que hay un conflicto.

Y puede identificar fácilmente el módulo que sobrescribe algo basado en NamespaceyModule

He combinado la respuesta y obtuve una buena solución

$text = Mage::getConfig()->getNode()->xpath('//global//rewrite');
foreach ($text as $rewriteElement) {
    if ($rewriteElement->getParent()->getParent()) {
        # what is overwritten (model, block, helper)
        $type = $rewriteElement->getParent()->getParent()->getName();
        # module identifier that is being rewritten (core, catalog, sales, ...)
        $parent = $rewriteElement->getParent()->getName();
        # element that is rewritten (layout, product, category, order)
        $name = $rewriteElement->getName();
        foreach ($rewriteElement->children() as $element) {
            # class that rewrites it
            $rewrites[$type][$parent.'/'.$name][] = $element;
        }
    }
}
print_r($rewrites);
die;

Tal vez un poco sobrecarga pero es bueno trabajar con la recopilación de datos varien ... código de https://github.com/firegento/firegento-debug

$collection = new Varien_Data_Collection();

$fileName = 'config.xml';
$modules = Mage::getConfig()->getNode('modules')->children();

$rewrites = array();
foreach ($modules as $modName => $module) {
    if ($module->is('active')) {
        $configFile = Mage::getConfig()->getModuleDir('etc', $modName) . DS . $fileName;
        if (file_exists($configFile)) {
            $xml = file_get_contents($configFile);
            $xml = simplexml_load_string($xml);

            if ($xml instanceof SimpleXMLElement) {
                $rewrites[$modName] = $xml->xpath('//rewrite');
            }
        }
    }
}

foreach ($rewrites as $rewriteNodes) {
    foreach ($rewriteNodes as $n) {
        $nParent = $n->xpath('..');
        $module = (string)$nParent[0]->getName();
        $nSubParent = $nParent[0]->xpath('..');
        $component = (string)$nSubParent[0]->getName();

        if (!in_array($component, array('blocks', 'helpers', 'models'))) {
            continue;
        }

        $pathNodes = $n->children();
        foreach ($pathNodes as $pathNode) {
            $path = (string)$pathNode->getName();
            $completePath = $module . '/' . $path;

            $rewriteClassName = (string)$pathNode;

            $instance = Mage::getConfig()->getGroupedClassName(
                substr($component, 0, -1),
                $completePath
            );

            $collection->addItem(
                new Varien_Object(
                    array(
                        'path'          => $completePath,
                        'rewrite_class' => $rewriteClassName,
                        'active_class'  => $instance,
                        'status'        => ($instance == $rewriteClassName)
                    )
                )
            );
        }
    }
}

Para la salida puede usar ...

foreach ($collection as $rewrite) {
    var_dump($rewrite->getData());
}