flack / openpsa

src/midcom/routing/resolver.php

<?php
/**
 * @package midcom.routing
 * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License
 */

namespace midcom\routing;

use Symfony\Component\HttpFoundation\Request;
use midcom;
use midcom_error_forbidden;
use midcom_error_notfound;
use Symfony\Component\Routing\Router;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\HttpFoundation\Response;

/**
 * @package midcom.routing
 */
class resolver
{
    private Request $request;

    private parser $parser;

    private \midcom_core_context $context;

    public function __construct(Request $request)
    {
        $this->request = $request;
        $this->context = $request->attributes->get('context');
        $this->parser = new parser($this->context);
    }

    public static function get_router(string $component, array $request_switch = []) : Router
    {
        $loader = new loader;
        if (!empty($request_switch)) {
            return new Router($loader, $request_switch);
        }
        $identifier = str_replace('.', '_', $component);
        return new Router($loader, $component, [
            'cache_dir' => midcom::get()->getCacheDir() . '/routing/' . $identifier,
        ]);
    }

    /**
     * @throws midcom_error_notfound
     */
    public function process_midcom() : bool
    {
        if ($url = $this->parser->find_urlmethod()) {
            $router = self::get_router('midcom');
            $router->getContext()
                ->fromRequest($this->request);

            try {
                $result = $router->match($url);
            } catch (ResourceNotFoundException) {
                throw new midcom_error_notfound('This URL method is unknown.');
            }
            $this->request->attributes->add($result);

            return true;
        }
        return false;
    }

    /**
     * Basically this method will parse the URL and search for a component that can
     * handle the request. If one is found, it will process the request, if not, it
     * will report an error, depending on the situation.
     *
     * Details: The logic will traverse the node tree, and for the last node it will load
     * the component that is responsible for it. If the component
     * declares to be able to handle the call, its handle function is executed. Depending
     * if the handle was successful or not, it will either display an HTTP error page or
     * prepares the content handler to display the content later on.
     *
     * If the parsing process doesn't find any component that declares to be able to
     * handle the request, an HTTP 404 - Not Found error is triggered.
     *
     * @throws midcom_error_forbidden
     * @throws midcom_error_notfound
     */
    public function process_component()
    {
        $topic = $this->parser->find_topic();
        $argv = $this->parser->argv;

        // Get component interface class
        $component_interface = midcom::get()->componentloader->get_interface_class($topic->component);
        $viewer = $component_interface->get_viewer($topic);

        $prefix = $this->context->get_key(MIDCOM_CONTEXT_ANCHORPREFIX);

        // Check if we need to start up a plugin.
        if (   count($argv) > 1
            && $config = plugin::get_config($argv[0], $argv[1])) {
            $namespace = array_shift($argv);
            $name = array_shift($argv);
            $prefix .= $namespace . '/' . $name . '/';
            debug_add("Loading the plugin {$namespace}/{$name}");
            $viewer->load_plugin($name, new $config['class'], $config);
        }

        $url = '/';
        if (!empty($argv)) {
            $url .= implode('/', $argv);
            $uri = $this->context->get_key(MIDCOM_CONTEXT_URI);
            if ($uri !== '/' && str_ends_with($uri, '/')) {

It seems like $uri can also be of type false; however, parameter $haystack of str_ends_with() does only seem to accept string, maybe add an additional type check?

                $url .= '/';
            }
        }
        $router = $viewer->get_router();
        $router->getContext()
            ->fromRequest($this->request)
            ->setBaseUrl(substr($prefix, 0, -1));

        try {
            $result = $router->match($url);
        } catch (ResourceNotFoundException) {
            // No match
            debug_add("Component {$viewer->_component} in {$viewer->_topic->name} declared unable to handle request.", MIDCOM_LOG_INFO);
            throw new midcom_error_notfound("This page is not available on this server.");
        } catch (MethodNotAllowedException $e) {
            debug_add("Component {$viewer->_component} in {$viewer->_topic->name} declared unable to handle request (method not allowed).", MIDCOM_LOG_INFO);
            throw new midcom_error_forbidden($e->getMessage(), Response::HTTP_METHOD_NOT_ALLOWED);
        }

        $result['args'] = array_values(array_filter($result, function(string $name) {
            return !str_starts_with($name, '_');
        }, ARRAY_FILTER_USE_KEY));

        $result['__viewer'] = $viewer;
        $result['_controller'] = str_replace('::', '::_handler_', $result['_controller']);

        if (!empty($result['component'])) {
            $this->context->set_key(MIDCOM_CONTEXT_COMPONENT, $result['component']);
            $topic = new \midcom_db_topic();
            $topic->component = $result['component'];
            $this->context->set_key(MIDCOM_CONTEXT_CONTENTTOPIC, $topic);
        }

        $this->request->attributes->add($result);
        $this->context->set_key(MIDCOM_CONTEXT_SHOWCALLBACK, $viewer->show(...));
    }
}