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

23

¿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.

Fabian Schmengler
fuente
¿No puedes usar?grep
Ben Lessani - Sonassi

Respuestas:

28

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

Alex
fuente
27

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')
Vinaí
fuente
¿Cuál es el problema con magento.SE? De todos modos, me gusta la solución, simple y directa. Debería haberlo pensado yo mismo ... ¡Danke, Vinai!
Fabian Schmengler
2
Esto funciona con un pequeño problema. Si tiene 2 extensiones reescribiendo el mismo modelo, no lo verá, porque Magento combina los archivos de configuración. Solo verá el "último". Pero es una manera rápida y simple de ver si algo se reescribe
Marius
Sí, solo muestra las reescrituras activas, eso es cierto. Si desea un análisis más avanzado, debe verificar cada módulo activo, etc / config.xml individualmente (o simplemente usar n98-magerun)
Vinai
Hola @ Vinai, ¿podemos obtener todos los conflictos en magento2 por este código?
akgola
No, no puede la configuración DI funciona de manera diferente en Magento 2.
Vinai
22

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

Marius
fuente
1
Hola, gracias por el guion. Lo utilicé en uno de mis proyectos y descubrí que la comprobación de los módulos de la comunidad no funciona. Para que funcione, hemos agregado un "/" al final de 'app / code / community', por lo que se convertirá en 'app / code / community /'
ceckoslab
@ceckoslab. Sí. Tienes razón. He editado la respuesta. Gracias.
Marius
3

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;
sunel
fuente
0

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());
}
sv3n
fuente