This simply adds some classes with a prefix

@param string 	$name
@param path 		$path
@return void
320335
public static function package( $dir, $classes ) 
	{
		foreach( $classes as $name => $path ) 
		{
			static::$classes[$name] = $dir.$path;
		}
	}
894178
private function addNameAndPattern($name, $pattern)
    {
        $this->arguments[] = $name;
        if ($pattern !== null) {
            $this->arguments[] = $pattern;
        }
    }
1361850
protected function createRoutes(string $name): void
    {
        $apiFile = base_path($this->moduleName().'/'.$name.'/Routes/api.php');
        if (! $this->files->exists($apiFile)) {
            $this->files->put($apiFile, $this->files->get(__DIR__.'/stubs/routes/api.stub'));
        }

        $webFile = base_path($this->moduleName().'/'.$name.'/Routes/web.php');
        if (! $this->files->exists($webFile)) {
            $this->files->put($webFile, $this->files->get(__DIR__.'/stubs/routes/web.stub'));
        }
    }
1002811
public function configure($name)
    {
        if (isset($this->loadedConfigurations[$name])) {
            return;
        }

        $this->loadedConfigurations[$name] = true;

        $path = $this->getConfigurationPath($name);

        if (! \is_null($path)) {
            $this->make('config')->set(Arr::dot([
                $name => require $path,
            ]));
        }
    }
711926
public function load($name)
    {
        if (null === ($path = $this->path($name)))
            return;
        if ($this->fileExists && (!file_exists($path))) {
            return;
        }
        include_once $path;
    }
1330474
private function addRoute($name, array $route)
    {
        extract($this->defaults($route));

        $requirements[RouteCollectionBuilder::K_NAME] = $name;

        $this->builder->addRoute($method, $pattern, $handler, $requirements, $defaults);
    }
1182138
public static function addPath($path)
    {
        $path = str_replace('//', '/', rtrim($path, '/'));
        if (is_dir($path) && !in_array($path, self::$_paths)) {
            array_unshift(self::$_paths, $path);
        }
    }
745624
protected function compileGroupClasses($name, array $classes)
    {
        $path = "{$this->path}/{$name}";

        if (! $this->files->isDirectory($path)) {
            return ;
        }

        foreach ($classes as $class) {
            $file = "{$path}/{$class}.php";

            if ($this->files->exists($file)) {
                $this->collection['added'][] = $file;
            } else {
                $this->collection['missing'][] = $file;
            }
        }
    }
936014
public function addPathHeader(string $name, $path)
    {
        return $this->add(new PathHeader($name, $path instanceof Address ? $path : new Address($path)));
    }
492948
protected function _mkfile($path, $name) {
		return $this->make($path, $name, 'text/plain') ? $this->_joinPath($path, $name) : false;
	}
707646
public function patch($path, $callable, $name = null) {
		return $this->add($path, $callable, $name, self::HTTP_METHOD_PATCH);
	}
593643
protected function fixClasses($prefix, $classes, $path = false)
    {
        $classes = value($classes);

        if (is_string($classes)) {
            $classes = explode(' ', $classes);
        }

        return Collection::make($classes)
            ->map($this->getBuilder($prefix, $path))
            ->flatten();
    }
1159085
public function updateConfig($name, $path)
    {
        $name = str_replace('\\', '/', $name);
        $configFile = static::configFile($this->vendorDir);
        $this->ensureConfigFile($configFile);

        $return = include $configFile;
        if (is_array($return) && empty($config)) {
            $config = $return;
        }
        if (!isset($config)) {
            $this->io->write(
                'ERROR - `vendor/skinny-plugins.php` file is invalid. ' .
                'Plugin path configuration not updated.'
            );
            return;
        }
        if (!isset($config['plugins'])) {
            $config['plugins'] = [];
        }
        if ($path == null) {
            unset($config['plugins'][$name]);
        } else {
            $config['plugins'][$name] = $path;
        }
        $root = dirname($this->vendorDir);
        static::writeConfigFile($configFile, $config['plugins'], $root);
    }
1125693
protected function convertTwigToPhp($path, $name)
    {
        $results = array();

        $dir = dirname($path);

        if (!file_exists($dir)) {
            mkdir($dir, 0755, true);
        }

        $templates = array();
        if ( $name === 'app' ) {
            $templates = $this->findFilesInFolder($dir . '/../../', 'twig');
        } else {
            $templates = $this->findFilesInFolder($dir . '/../views', 'twig');
        }

        $php  = "<?php\n";
        $twig = $this->getContainer()->get('twig');
        $twig->setLoader(new \Twig_Loader_String());
        foreach ($templates as $templateFileName) {
            $stream = $twig->tokenize(file_get_contents($templateFileName));
            $nodes = $twig->parse($stream);
            $template = $twig->compile($nodes);
            // remove first line
            $template = substr($template, strpos($template, "\n")+strlen("\n"));
            $php .= "/*\n * Resource: $name\n * File: $templateFileName\n */\n";
            $php .= $template;
            $results[$templateFileName]='Scanned';
        }

        if (!file_put_contents($path, $php)) {
            throw new \Exception('Cannot write intermediate PHP code for twig templates to twig.cache.php in: '.$path);
        }

        return $results;
    }
509012
public function on($method, $path, $handler, $name = '') {
		if (!$this->result->hasHandler()
			&& $this->prefixMatched
			&& $this->request->isMethod($method)
		) {
			if ($this->matchPartial($path, true)) {
				$handlers = (array)$handler;

				if ($this->namespace) {
					foreach ($handlers as &$handler) {
						$handler = $this->namespace . $handler;
					}
				}

				if ($this->middlewares) {
					$handlers = array_merge($this->middlewares, $handlers);
				}

				$this->result->setHandler($handlers);
				$this->result->setStatus(200);
				$this->result->setParams($this->params);
			}
		}

		if ($name) {
			$this->urlGenerator->add($name, $this->prefix . $path);
		}

		return $this;
	}
726884
private function loadHelper(string $name): void
    {
        $class = static::class;

        // Somebody forgot to call `addHelperPath`
        if (!isset(static::$helpersPath[$class])) {
            throw new CommonException("Helper path not found for class `$class`");
        }

        // Try to find helper file
        foreach (static::$helpersPath[$class] as $path) {
            if ($helperPath = realpath($path . '/' . ucfirst($name) . '.php')) {
                $this->addHelper($name, $helperPath);
                return;
            }
        }

        throw new CommonException("Helper `$name` not found for class `$class`");
    }
109598
public static function map( $name, $path = null ) 
	{
		if ( is_array( $name ) ) 
		{
			static::$namespaces = array_merge( static::$namespaces, $name ); return;
		}
		static::$namespaces[$name] = $path;
	}