add a patch rule in route

@param string $name
@param string $path
@param string $controller
@return $this
510076
public function patch($name, $path, $controller = null)
    {
        $this->add('PATCH', $name, $path, $controller);
        return $this;
    }
779661
public function addRoute(string $path, string $controller, string $action = 'index', string $method = Request::METHOD_GET) : self
    {
        $endPoint = new RouteEndpoint($this->namespace, $controller, $action, $method);
        $this->routes[] = new Route($path, $endPoint);
        
        return $this;
    }
614363
public function updateRoutesFile($name)
    {
        $name = strtolower(Pluralizer::plural($name));

        $this->file->append(
            app_path() . '/routes.php',
            "\n\nRoute::resource('" . $name . "', '" . ucwords($name) . "Controller');"
        );
    }
946822
public function updateRoutesFile($name)
    {
        $name = strtolower(Pluralizer::plural($name));

        $routesPath = app_path() . '/routes.php';
        $routesContent = $this->file->get($routesPath);

        $resourceRoute = "Route::resource('" . $name . "', '" . ucwords($name) . "Controller');";

        if ( ! strpos($routesContent, $resourceRoute))
        {
            return $this->file->append($routesPath, "\n\n".$resourceRoute);
        }

        return false;
    }
523685
public function get($name, $path, $controller = null)
    {
        $this->add('GET', $name, $path, $controller);
        return $this;
    }
458848
public static function any($path, $name, $namespaceOrController) {
        $item = new ConfigurationItem($path, $name, ['GET', 'POST', 'PUT', 'DELETE', 'HEAD'], $namespaceOrController);
        self::$configuration[] = $item;
        return $item;
    }
961436
public function controller( $uri, $controller, $names = [] )
	{
		$prepended = $controller;

		// First, we will check to see if a controller prefix has been registered in
		// the route group. If it has, we will need to prefix it before trying to
		// reflect into the class instance and pull out the method for routing.
		if ( !empty( $this->groupStack ) )
			$prepended = $this->prependGroupUses( $controller );

		$routable = ( new ControllerInspector )->getRoutable( $prepended, $uri );

		// When a controller is routed using this method, we use Reflection to parse
		// out all of the routable methods for the controller, then register each
		// route explicitly for the developers, so reverse routing is possible.
		foreach ( $routable as $method => $routes )
			foreach ( $routes as $route )
				$this->registerInspected( $route, $controller, $method, $names );

		$this->addFallthroughRoute( $controller, $uri );
	}
490677
protected function makeDirectory($controller, $path)
	{
		$directory = $this->getDirectory($controller);

		if ( ! $this->files->isDirectory($full = $path.'/'.$directory))
		{
			$this->files->makeDirectory($full, 0777, true);
		}
	}
5410
public function patch($url, $callable, $name = null, $templatePath = null)
    {
        $this->multiple([\Parable\Http\Request::METHOD_PATCH], $url, $callable, $name, $templatePath);
        return $this;
    }
684673
public function patch(
        string $definition,
        RequestHandlerInterface $handler,
        ?string $name = null,
        $data = null
    ): Route {
        return $this->route(Method::PATCH, $definition, $handler, $name, $data);
    }
112167
public function connect($url, $name, $controller=null)
	{
		$this->_router->connect($url, $name, $controller);

		// register the controller if one is provided
		if(!is_null($controller))
		{
			$this->_controllers[$name] = $controller;
		}

		return $this;
	}
665974
public static function registerHandler($path, $handler, $name = null)
    {
        $routeInfo             = [
            $path,
            $handler
        ];
        static::$routes[$path] = $routeInfo;
        if (!empty($name)) {
            self::$namedRoutes[$name] = $routeInfo;
        }
    }
890808
protected function addPatchResourceUpdate($name, $base, $controller)
    {
        $uri = $this->getResourceUri($name) .'/{' .$base .'}';

        $this->router->patch($uri, $controller.'@update');
    }
729854
public function patch($path, $action = null)
    {
        return $this->match($path, Rule\HttpMethodRule::HTTP_METHOD_PATCH, $action);
    }
804476
public function controller($uri, $controller, $names = array())
	{
		$prepended = $controller;

		// First, we will check to see if a controller prefix has been registered in
		// the route group. If it has, we will need to prefix it before trying to
		// reflect into the class instance and pull out the method for routing.
		if (count($this->groupStack) > 0)
		{
			$prepended = $this->prependGroupUses($controller);
		}

		$routable = $this->getInspector()->getRoutable($prepended, $uri);

		// When a controller is routed using this method, we use Reflection to parse
		// out all of the routable methods for the controller, then register each
		// route explicitly for the developers, so reverse routing is possible.
		foreach ($routable as $method => $routes)
		{
			foreach ($routes as $route)
			{
				$this->registerInspected($route, $controller, $method, $names);
			}
		}

		$this->addFallthroughRoute($controller, $uri);
	}
1328917
public function Render($Path, $Controller) {
      $Smarty = $this->Smarty();
      $this->Init($Path, $Controller);
      $CompileID = $Smarty->compile_id;
      if (defined('CLIENT_NAME'))
         $CompileID = CLIENT_NAME;
      
      $Smarty->template_dir = dirname($Path);
      $Smarty->display($Path, NULL, $CompileID);
   }
792425
protected function makeFromPath($name, $path)
    {
        if (!$this->get($name)) {

            $params = [
                'name' => $name,
                'path' => rtrim($path, '/') . '/' . $name
            ];

            $module = IOC::resolve('Module', $params);
            $this->add($module->getName(), $module->create());

            return $module;
        }

        return null;
    }