Inspector.php

Go to the documentation of this file.

<?php
namespace Elgg\Debug;

use Elgg\Debug\Inspector\ViewComponent;

class Inspector {

    public function getEvents() {
        return $this->buildHandlerTree(_elgg_services()->events->getAllHandlers());
    }

    public function getPluginHooks() {
        return $this->buildHandlerTree(_elgg_services()->hooks->getAllHandlers());
    }

    public function getViewtypes() {
        return array_keys($this->getViewsData()['locations']);
    }

    public function getViews($viewtype = 'default') {
        global $CONFIG;

        $view_data = $this->getViewsData();

        // maps view name to array of ViewComponent[] with priority as keys
        $views = array();

        // add plugins and handle overrides
        foreach ($view_data['locations'][$viewtype] as $view => $location) {
            $component = new ViewComponent();
            $component->view = $view;
            $component->file = $location;

            $views[$view] = [500 => $component];
        }

        // now extensions
        foreach ($view_data['extensions'] as $view => $extensions) {
            $view_list = array();
            foreach ($extensions as $priority => $ext_view) {
                if (isset($views[$ext_view])) {
                    $view_list[$priority] = $views[$ext_view][500];
                }
            }
            if (count($view_list) > 0) {
                $views[$view] = $view_list;
            }
        }

        ksort($views);

        // now overrides
        foreach ($views as $view => $view_list) {
            if (!empty($view_data['overrides'][$viewtype][$view])) {
                $overrides_list = array();
                foreach ($view_data['overrides'][$viewtype][$view] as $i => $location) {
                    $component = new ViewComponent();
                    $component->overridden = true;
                    $component->view = $view;
                    $component->file = $location;

                    $overrides_list["o:$i"] = $component;
                }
                $views[$view] = $overrides_list + $view_list;
            }
        }

        // view handlers
        $handlers = _elgg_services()->hooks->getAllHandlers();

        $input_filtered_views = array();
        if (!empty($handlers['view_vars'])) {
            $input_filtered_views = array_keys($handlers['view_vars']);
        }

        $filtered_views = array();
        if (!empty($handlers['view'])) {
            $filtered_views = array_keys($handlers['view']);
        }

        $global_hooks = array();
        if (!empty($handlers['view_vars']['all'])) {
            $global_hooks[] = 'view_vars, all';
        }
        if (!empty($handlers['view']['all'])) {
            $global_hooks[] = 'view, all';
        }

        return array(
            'views' => $views,
            'global_hooks' => $global_hooks,
            'input_filtered_views' => $input_filtered_views,
            'filtered_views' => $filtered_views,
        );
    }

    public function getWidgets() {
        $tree = array();
        foreach (_elgg_services()->widgets->getAllTypes() as $handler => $handler_obj) {
            $tree[$handler] = array($handler_obj->name, implode(',', array_values($handler_obj->context)));
        }

        ksort($tree);

        return $tree;
    }


    public function getActions() {
        $tree = array();
        $access = array(
            'public' => 'public',
            'logged_in' => 'logged in only',
            'admin' => 'admin only',
        );
        $start = strlen(elgg_get_root_path());
        foreach (_elgg_services()->actions->getAllActions() as $action => $info) {
            $info['file'] = substr($info['file'], $start);
            $tree[$action] = array($info['file'], $access[$info['access']]);
        }
        ksort($tree);
        return $tree;
    }

    public function getSimpleCache() {
        
        $simplecache = elgg_extract('simplecache', $this->getViewsData(), []);
        $locations = elgg_extract('locations', $this->getViewsData(), []);
        
        $tree = [];
        foreach ($simplecache as $view => $foo) {
            $tree[$view] = '';
        }
        
        // add all static views
        foreach ($locations as $viewtype) {
            foreach ($viewtype as $view => $location) {
                if (pathinfo($location, PATHINFO_EXTENSION) !== 'php') {
                    $tree[$view] = '';
                }
            }
        }

        ksort($tree);

        return $tree;
    }

    public function getWebServices() {
        global $API_METHODS;

        $tree = array();
        foreach ($API_METHODS as $method => $info) {
            $params = implode(', ', array_keys(elgg_extract('parameters', $info, [])));
            if (!$params) {
                $params = 'none';
            }
            $tree[$method] = array(
                $info['function'],
                "params: $params",
                $info['call_method'],
                ($info['require_api_auth']) ? 'API authentication required' : 'No API authentication required',
                ($info['require_user_auth']) ? 'User authentication required' : 'No user authentication required',
            );
        }

        ksort($tree);

        return $tree;
    }

    public function getMenus() {

        $menus = elgg_get_config('menus');

        // get JIT menu items
        // note that 'river' is absent from this list - hooks attempt to get object/subject entities cause problems
        $jit_menus = array('annotation', 'entity', 'login', 'longtext', 'owner_block', 'user_hover', 'widget');

        // create generic ElggEntity, ElggAnnotation, ElggUser, ElggWidget
        $annotation = new \ElggAnnotation();
        $annotation->id = 999;
        $annotation->name = 'generic_comment';
        $annotation->value = 'testvalue';

        $entity = new \ElggObject();
        $entity->guid = 999;
        $entity->subtype = 'blog';
        $entity->title = 'test entity';
        $entity->access_id = ACCESS_PUBLIC;

        $user = new \ElggUser();
        $user->guid = 999;
        $user->name = "Test User";
        $user->username = 'test_user';

        $widget = new \ElggWidget();
        $widget->guid = 999;
        $widget->title = 'test widget';

        // call plugin hooks
        foreach ($jit_menus as $type) {
            $params = array('entity' => $entity, 'annotation' => $annotation, 'user' => $user);
            switch ($type){
                case 'owner_block':
                case 'user_hover':
                    $params['entity'] = $user;
                    break;
                case 'widget':
                    // this does not work because you cannot set a guid on an entity
                    $params['entity'] = $widget;
                    break;
                case 'longtext':
                    $params['id'] = rand();
                    break;
                default:
                    break;
            }
            $menus[$type] = elgg_trigger_plugin_hook('register', "menu:$type", $params, array());
        }

        // put the menus in tree form for inspection
        $tree = array();

        foreach ($menus as $menu_name => $attributes) {
            foreach ($attributes as $item) {
                /* @var \ElggMenuItem $item */
                $name = $item->getName();
                $text = htmlspecialchars($item->getText(), ENT_QUOTES, 'UTF-8', false);
                $href = $item->getHref();
                if ($href === false) {
                    $href = 'not a link';
                } elseif ($href === "") {
                    $href = 'not a direct link - possibly ajax';
                }
                $section = $item->getSection();
                $parent = $item->getParentName();
                if (!$parent) {
                    $parent = 'none';
                }

                $tree[$menu_name][$name] = array(
                    "text: $text",
                    "href: $href",
                    "section: $section",
                    "parent: $parent",
                );
            }
        }

        ksort($tree);

        return $tree;
    }

    public function describeCallable($callable, $file_root = '') {
        if (is_string($callable)) {
            return $callable;
        }
        if (is_array($callable) && array_keys($callable) === array(0, 1) && is_string($callable[1])) {
            if (is_string($callable[0])) {
                return "{$callable[0]}::{$callable[1]}";
            }
            return "(" . get_class($callable[0]) . ")->{$callable[1]}";
        }
        if ($callable instanceof \Closure) {
            $ref = new \ReflectionFunction($callable);
            $file = $ref->getFileName();
            $line = $ref->getStartLine();

            if ($file_root && 0 === strpos($file, $file_root)) {
                $file = substr($file, strlen($file_root));
            }

            return "(Closure {$file}:{$line})";
        }
        if (is_object($callable)) {
            return "(" . get_class($callable) . ")->__invoke()";
        }
        return print_r($callable, true);
    }

    protected function buildHandlerTree($all_handlers) {
        $tree = array();
        $root = elgg_get_root_path();

        foreach ($all_handlers as $hook => $types) {
            foreach ($types as $type => $priorities) {
                ksort($priorities);

                foreach ($priorities as $priority => $handlers) {
                    foreach ($handlers as $callable) {
                        $description = $this->describeCallable($callable, $root);
                        $callable = "$priority: $description";
                        $tree["$hook, $type"][] = $callable;
                    }
                }
            }
        }

        ksort($tree);

        return $tree;
    }

    private function getViewsData() {
        static $data;
        if ($data === null) {
            $data = _elgg_services()->views->getInspectorData();
        }
        return $data;
    }
}