Starts a named group of routes

@param string $groupName
@param \Closure $callback
@return $this
162006
public function group(string $groupName, \Closure $callback) {
        $this->currentGroupName = $groupName;

        $this->isGroupe = TRUE;
        $this->isGroupeMiddlewares = FALSE;
        $callback($this);
        $this->isGroupeMiddlewares = TRUE;
        $this->currentGroupName = NULL;

        return $this;
    }
660278
public function each($callback)
    {
        array_walk($this->array, function($value, $key) use ($callback) {
            $callback($key, $value);
        });

        return $this;
    }
629598
public function each( \Closure $callback )
	{
		foreach( $this->items as $name => $properties )
		{
			if( $callback($properties, $name) === false )
			{
				break;
			}
		}

		return $this;
	}
194171
public function department($name, Closure $callback)
    {
        $department = $this->createDepartment($name);

        call_user_func($callback, $department);

        if (is_null(static::$departments)) {
            static::$departments = Collection::make([]);
        }

        static::$departments->push($department);

        return $this;
    }
364717
public function group($name, $default, $attributes = [], Closure $callback = null)
    {
        $route = $this->route($name, $default);


        $attributes = array_merge($attributes, [
            'prefix' => $route->prefix(),
            'domain' => $route->domain(),
        ]);

        if (!is_null($callback)) {
            $this->app->make('router')->group($attributes, $callback);
        }

        return $attributes;
    }
1082402
public function nest(Closure $callback, $condition)
    {
        $topic = new static();

        $callback($topic);
        if (count($topic->conditions)) {
            $open_parenthesis = '(';
            $topic = $topic->conditions;
            $close_parenthesis = ')';

            $this->conditions[] = compact('condition', 'open_parenthesis', 'topic', 'close_parenthesis');
        }

        return $this;
    }
760274
public function group(array $options, \Closure $closure)
	{
		$group = new static(null, $options);

		$closure->bindTo($group)->__invoke($group);

		$this->getCollection()->addAll($group->getCollection());

		return $this;

	}
63732
public static function withLanguage(\Closure $callback, $config = [])
    {
        if (\App::runningUnitTests()) {
            $locale = \App::getLocale();
        } else {
            $locale = request()->segment(1);
        }

        if (strlen($locale) <= 2) {
            Route::group(['prefix' => $locale, 'middleware' => 'lang'], function () use ($callback) {
                $callback();
            });
        }
    }
309092
public function group($name, $action, Closure $callback)
    {
        static::$groups[$name] = [
            'action' => $action,
            'callback' => $callback
        ];

        return $this;
    }
1015574
public function Js ($groupName = self::GROUP_NAME_DEFAULT) {
		$this->actualGroupName = $groupName;
		$this->_getScriptsGroupContainer($groupName);
		return $this;
	}
300175
public function indexBy($callback)
    {
        $group = new Map();
        foreach ($this as $value) {
            $key = $callback($value);
            $group->set($key, $value);
        }

        return $group;
    }
756513
public function getRouteGroup(string $groupName): \Nofuzz\Route\Group
  {
    foreach ($this->routeGroups as $routeGroup)
    {
      if ( strcasecmp($routeGroup->getName(),$groupName)==0 ) {
        return $routeGroup;
      }
    }

    return null;
  }
922709
public function jumpAfterEval(\Closure $callback)
    {
        $this->action = self::NODE_ACTION_JUMP_TO;
        $this->data['nodeEval'] = $callback;
        return $this;
    }
1208936
public function onSuccess(Closure $callback)
    {
        return $this->then(function (Container $container) use ($callback) {
            if (0 === $this->exitCode) {
                $container->call($callback);
            }
        });
    }
120053
public function start(Closure $callback)
    {
        $this->output = $callback;

        $this->cooldown();

        $this->process->start($callback);

        return $this;
    }
485588
public function map(Closure $callback)
    {
        return new self(array_map($callback, $this->items, array_keys($this->items)));
    }
792991
public function mapToGroups(callable $callback)
    {
        $groups = $this->map($callback)->reduce(function ($groups, $pair) {
            $groups[key($pair)][] = reset($pair);

            return $groups;
        }, []);

        return (new static($groups))->map([$this, 'make']);
    }