Add multiple verb to a pattern and stages.

@param array                              $verbs
@param callable|string|HttpPipeline|array $stages $stages

@throws \Moon\Moon\Exception\InvalidArgumentException
4236
public function map(string $pattern, array $verbs, $stages): void
    {
        $pipeline = new HttpPipeline($verbs, $this->prefix.$pattern, $this->routerStages);
        $pipeline->pipe($stages);
        $this->pipelineCollection->add($pipeline);
    }
734864
public function addStepWithEvents($event, $callable, $arguments = [])
    {
        $this->addStep('fireEvent', [$event.'.before']);
        $this->addStep($callable, $arguments);
        $this->addStep('fireEvent', [$event.'.after']);
    }
897397
public function addRoutes($routes)
	{
		foreach ($routes as $route) {
			foreach (explode('|', $route[0]) as $method) {
				$this->routes[$method][] = array(
					'pattern' => $route[1],
					'callable' => $route[2]
				);
			}
		}
	}
488124
def nest(self, verb):
        
        if not isinstance(verb, TwiML) and not isinstance(verb, str):
            raise TwiMLException('Only nesting of TwiML and strings are allowed')

        self.verbs.append(verb)
        return verb
211087
public function process(array $stages, $payload, $extra = [])
    {
        if (!is_array($extra)) {
            $extra = ['source' => $extra];
        }

        return $this->processStages($stages, $payload, $extra);
    }
1187815
private static function addCached(CacheableInterface $verb, ResultInterface $result): void
    {
        self::$cache[$verb->getCacheKey()] = $result;
    }
511605
public function acceptedVerb($verb)
    {

        if (isset($this->verbs[0]) && $this->verbs[0] == static::ANY_METHOD_WILDCARD) {

            return true;
        }

        return in_array(strtoupper($verb), $this->getVerbs(), true);
    }
140241
public function map(array $verbs, string $uri, $callback): Route
    {
        if ($this->isControllerString($callback)) {
            $callback = $this->normaliseCallbackString($callback);
        }

        return parent::map($verbs, $uri, $callback);
    }
829983
public function setRoutes(array $routes) {

	    foreach($routes as $route) {

	        if(!$route instanceof Route) {
	            throw new \InvalidArgumentException(sprintf("'%s' is not a Route instance.", $route));
            }

            $this->addRoute($route);

        }

    }
1352877
private function checkStage($stage)
    {
        if ($this->runtime->getStage() !== $stage) {
            throw new RuntimeException(sprintf('Invalid stage, got "%s" but expected "%"', $this->runtime->getStage(), $stage));
        }
    }
883536
private static function verbs(array $methods)
    {
        $list = array();
        $reMatch = '#^(any|get|post|patch|put|head|delete|options|trace|connect)([A-Z0-9]\w+)$#';

        foreach ($methods as $value) {
            $verb = array();

            if (preg_match($reMatch, $value, $verb)) {
                if (strcasecmp('index', $verb[2]) === 0) {
                    $verb[2] = '';
                } else {
                    $verb[2] = strtolower(preg_replace('#([a-z])([A-Z])#', '$1-$2', $verb[2]));
                }

                $list[] = array(strtoupper($verb[1]), $verb[2], $value);
            }
        }

        return $list;
    }
841744
public function addPrefix($prefix, $paths)
    {
        if (!$prefix) {
            foreach ((array) $paths as $path) {
                $this->fallbackDirs[] = $path;
            }

            return;
        }
        if (isset($this->prefixes[$prefix])) {
            $this->prefixes[$prefix] = array_merge(
                $this->prefixes[$prefix],
                (array) $paths
            );
        } else {
            $this->prefixes[$prefix] = (array) $paths;
        }
    }
1246092
public function post(string $pattern, $stages): void
    {
        $pipeline = new HttpPipeline(RequestMethodInterface::METHOD_POST, $this->prefix.$pattern, $this->routerStages);
        $pipeline->pipe($stages);
        $this->pipelineCollection->add($pipeline);
    }
1254277
public function setRoles(array $roles)
    {
        $this->roleIdentifiers = [];
        $this->roles = [];
        foreach ($roles as $role) {
            if (!$role instanceof Role) {
                throw new \InvalidArgumentException(sprintf('setRoles() only accepts an array of %s instances, given: "%s"', Role::class, gettype($role)), 1397125997);
            }
            $this->addRole($role);
        }
    }
786814
public function head(string $pattern, $stages): void
    {
        $pipeline = new HttpPipeline(RequestMethodInterface::METHOD_HEAD, $this->prefix.$pattern, $this->routerStages);
        $pipeline->pipe($stages);
        $this->pipelineCollection->add($pipeline);
    }
48602
public function map($methods, $pattern, $callable)
	{
		$methods = (array) $methods;
		if (!is_string($pattern)) {
			throw new InvalidArgumentException('Route pattern must be a string');
		}
		
		// Prepend parent group pattern(s)
		if ($this->routeGroups) {
			$pattern = $this->processGroups() . $pattern;
		}
		
		// According to RFC methods are defined in uppercase (See RFC 7231)
		$methods = array_map("strtoupper", $methods);
		
		// Add route
		$route = $this->createRoute($methods, $pattern, $callable);
		$this->routes[$route->getIdentifier()] = $route;
		$this->routeCounter++;
		
		return $route;
	}
383398
public function options(string $pattern, $stages): void
    {
        $pipeline = new HttpPipeline(RequestMethodInterface::METHOD_OPTIONS, $this->prefix.$pattern, $this->routerStages);
        $pipeline->pipe($stages);
        $this->pipelineCollection->add($pipeline);
    }