La gestione intuitiva delle dipendenze con il codice include?

Sto costruendo un sistema PHP CMS che analizza i file modello e sostituisce i tag con il contenuto. A volte questo contenuto è uno snippet HTML, CSS o JS, ma può anche essere un codice incluso.

La maggior parte del codice include le dipendenze di utilizzo, già impostate nell'ambito principale: la classe dell'app, dove risiede la funzione start () e vengono caricati tutti gli oggetti dominio necessari. Alcuni di questi oggetti sono: site , URL , page , ecc.

Gli script PHP sono inclusi in un ambito diverso, quindi non posso accedere alle dipendenze nel modo che voglio - > dalla classe dell'app.

Sto pensando a Dependency Injection usando una classe contenitore di dipendenza, ma ovviamente questo non è visibile quando si lavora all'interno di un include.

Come posso mantenere accessibili le dipendenze in modo intuitivo?

Esempio di codice:

class app {

    protected $dependencyContainer;

    function __construct() {
        $this->dependencyContainer = new dependencyContainer();
    }

    // Called by index.php
    public function start() {

        // Load in navigator that contains routing information
        $this->dependencyContainer->set('navigator', new navigator($_SERVER['REQUEST_URI'], $_SERVER['HTTP_HOST']));

        // Load site data 
        $domainController = new domainController();
        $site = $domainController->loadSite($this->dependencyContainer->get('navigator'));
        $this->dependencyContainer->set('site', $site);

        $pageController = new pageController();
        $page = $pageController->loadPage($this->dependencyContainer->get('navigator'));
        $this->dependencyContainer->set('page', $page);

        // Etc...
        // Etc...

        $templatePath = $site->getTemplate();
        $this->renderDocument($templatePath);
    }

    private function renderDocument($templatePath) {       
        $template = file_get_contents($templatePath);

        $lines = explode("\n", $template);

        foreach($lines as $line) {                    
            // If a tag is found, the dependencies are asked if it contains data for this 
            if($tag = $this->filter($line)) {
                $fragments = $this->dependencyContainer->output($tag);

                foreach($fragment as $fragment) {
                    if($fragment->needDependencies()) {


                        // AT THIS POINT I TRAVERSE INTO AN OBJECT AND 
                        // INCLUDE A PHP SCRIPT

                        $fragment->render($this->dependencyContainer);
                    } else {
                        $fragment->render();
                    }
                }
            // Process lines, echo the ones that are plain HTML
            } else {
                echo $line;
            }
         }
    }
}

L'oggetto frammento a cui vengono passate le dipendenze:

class dependencyFragment {
    protected $data;
    const NEEDSDEPENDENCIES = true;

    // THIS IS THE LOCAL SCOPE OF THE INCLUDE:
    public function render($dependencies) {
        return include __PATH__ . $this->data;
    }
}

Un file di script che viene incluso:

<?php

// Do I comment in every script file that the variable $dependencies is set and is usable?
// And just call it like this?
$dependencies->get('page')...

Ho la sensazione che sia molto difficile da capire senza prima capire come e dove sono impostate e iniettate le dipendenze?

Questo è il solito modo di andare?