Como obtenho uma lista de todas as reescritas de classe?

Existe uma maneira de listar todas as reescritas e talvez outros conflitos em potencial além de revisar todos os arquivos de configuração? Eu tenho que analisar alguns projetos com muitas extensões e modificações personalizadas e gostaria de automatizar o máximo possível.

O mais importante é detectar extensões que reescrevam a mesma classe, mas eu gostaria de ter também uma lista de todas as reescritas, para manter uma visão geral. No momento, mantenho essa lista manualmente em uma planilha.

Eu encontrei esta extensão ("Conflito de extensão") no Magento Connect, mas a julgar pelos comentários e notas de lançamento, parece estar desatualizada.

Dê uma olhada no utilitário n98-magerun :

Reescrever a lista

Lista todas as regravações de classe registradas:

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

Reescrever Conflitos

Lista todas as reescritas duplicadas e informa qual classe é carregada pelo Magento. O comando verifica a herança de classe na ordem das dependências do módulo. n98-magerun.phar dev:module:rewrite:conflicts [--log-junit="..."]

Se um nome de arquivo com a opção --log-junit estiver definido, a ferramenta gerará um arquivo XML e nenhuma saída para stdout.

Você também pode registrar os conflitos em um arquivo XML do JUnit Style para análises adicionais, por exemplo, em um servidor de integração contínuo.

Isenção de responsabilidade: semi-auto-link / Estou envolvido nesse projeto

Aqui está uma pequena linha que fornece todas as reescritas ativas:

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

Para limitá-lo por tipo de objeto, adicione modelos, blocos ou auxiliares ao xpath, respectivamente.
Por exemplo:

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

Aqui está um pequeno script que eu uso para verificar se algum modelo, bloco ou auxiliar é substituído. Infelizmente, ele não funciona para controladores e leva em conta os módulos desativados também. Mas, do meu ponto de vista, isso não é grande coisa.

A idéia principal é analisar os arquivos de configuração e procurar a <rewrite>tag. Crie um arquivo php no mesmo nível que index.php. Vamos chamá-lo rewrites.php, com este conteúdo:

<?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);

ao chamá-lo em um navegador, você verá algo assim:

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] => ...

)

isso significa que o modelo 'core/layout'é substituído porNamespace_Module_Model_Core_Layout

Se você tiver 2 ou mais valores na matriz ['core / layout'], isso significa que há um conflito.

E você pode identificar facilmente o módulo que substitui algo com base NamespaceeModule

eu combinei a resposta e consegui uma boa solução

$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;

Talvez um pouco sobrecarregado, mas é bom trabalhar com a coleta de dados variados ... 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 saída, você pode usar ...

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