Register service provider routes
336445
public function registerRoute()
    {
        if(!is_null($services = $this->services)) {
            foreach($services as $service) {

                $routes = $this->app->make($service)->registerRoute();

                $this->requiredRoute($routes);
            }
        }
    }
1067366
public static function registerRoutes()
    {
        parent::routes(function ($router) {
            /* @var \Illuminate\Routing\Router $router */
            $router->get('helpers/terminal/database', 'Encore\Admin\Helpers\Controllers\TerminalController@database');
            $router->post('helpers/terminal/database', 'Encore\Admin\Helpers\Controllers\TerminalController@runDatabase');
            $router->get('helpers/terminal/artisan', 'Encore\Admin\Helpers\Controllers\TerminalController@artisan');
            $router->post('helpers/terminal/artisan', 'Encore\Admin\Helpers\Controllers\TerminalController@runArtisan');
            $router->get('helpers/scaffold', 'Encore\Admin\Helpers\Controllers\ScaffoldController@index');
            $router->post('helpers/scaffold', 'Encore\Admin\Helpers\Controllers\ScaffoldController@store');
            $router->get('helpers/routes', 'Encore\Admin\Helpers\Controllers\RouteController@index');
        });
    }
513523
public function bindRoutes()
    {
        $loader = new RouteLoader();

        $loader->registerProviders(RouteLoader::$defaultProviders);

        $loader->bindRoutes($this);
        $this->bindPluginRoutes('plugin.controller_providers.root');
    }
871320
protected function registerRoutes()
    {
        $http = Arr::get($this->triggers, 'http');
        if (is_null($http)) {
            return;
        }

        // Validar
        try {
            Validator::validate($http, ['route' => 'required', 'methods' => 'required', 'function' => 'required']);
        } catch (ExceptionAttrs $e) {
            throw new \Exception($e->toMessageStr());
        }

        // Validar função
        $function = $http['function'];
        if (! array_key_exists($function, $this->functions)) {
            throw new \Exception(sprintf('Function %s not found', $function));
        }

        $class = $this->functions[$function];
        $methods = explode(',', Arr::get($http, 'methods', 'get'));

        foreach ($methods as $method) {
            // Validar metodo
            if (! in_array($method, ['get', 'post', 'delete', 'put'])) {
                throw new \Exception(sprintf('Method %s invalid', $method));
            }

            $args = [];
            $args['prefix'] = $this->getName();
            $args['uses'] = sprintf('%s@execute', $class);
            $args['middleware'] = 'api';
            call_user_func_array([router(), $method], [$http['route'], $args]);
        }
    }
607174
protected function registerServiceProviders()
    {
        foreach ($this->serviceProviders[$this->flare->compatibility()] as $class) {
            $this->app->register($class);
        }
    }
1035876
public function registerConfiguredProviders()
	{
		$manifestPath = $this->getCachedServicesPath();

		(new ProviderRepository($this, new Filesystem, $manifestPath))
					->load($this->config['app.providers']);
	}
156767
public function registerAll()
    {
        // Public routes
        Route::group([
            'prefix' => $this->dir,
            'middleware' => 'decoy.public',
        ], function () {
            $this->registerLogin();
            $this->registerResetPassword();
        });

        // Routes that don't require auth or CSRF
        Route::group([
            'prefix' => $this->dir,
            'middleware' => 'decoy.endpoint',
        ], function () {
            $this->registerExternalEndpoints();
        });

        // Protected, admin routes
        Route::group([
            'prefix' => $this->dir,
            'middleware' => 'decoy.protected',
        ], function () {
            $this->registerAdmins();
            $this->registerCommands();
            $this->registerElements();
            $this->registerEncode();
            $this->registerRedactor();
            $this->registerWorkers();
            $this->registerWildcard(); // Must be last
        });
    }
1339924
private function registerRoutes()
    {
        $path = config('wink.path');
        $middlewareGroup = config('wink.middleware_group');

        Route::namespace('Wink\Http\Controllers')
            ->middleware($middlewareGroup)
            ->as('wink.')
            ->prefix($path)
            ->group(function () {
                Route::get('/login', 'LoginController@showLoginForm')->name('auth.login');
                Route::post('/login', 'LoginController@login')->name('auth.attempt');

                Route::get('/password/forgot', 'ForgotPasswordController@showResetRequestForm')->name('password.forgot');
                Route::post('/password/forgot', 'ForgotPasswordController@sendResetLinkEmail')->name('password.email');
                Route::get('/password/reset/{token}', 'ForgotPasswordController@showNewPassword')->name('password.reset');
            });

        Route::namespace('Wink\Http\Controllers')
            ->middleware([$middlewareGroup, Authenticate::class])
            ->as('wink.')
            ->prefix($path)
            ->group(function () {
                $this->loadRoutesFrom(__DIR__.'/Http/routes.php');
            });
    }
105393
private function registerProviders ()
    {
        $this->register(new TwigServiceProvider());
        $this->register(new UrlGeneratorServiceProvider());
        $this->register(new ServiceControllerServiceProvider());
    }
1189162
public function registerServiceProvider()
    {
        $this->registerConfig();
        $this->registerClassAliases();
        $this->registerHttpServiceProvider();
        $this->registerRoutingServiceProvider();
        $this->registerExceptionHandler();
        $this->registerDispatcher();
        $this->registerAuth();
        $this->registerTransformer();
        $this->registerDocsCommand();

        if (class_exists(\Illuminate\Foundation\Application::class, false)) {
            $this->commands([
                NodesConsoleCommandCache::class,
                NodesConsoleCommandRoutes::class,
            ]);
        }
    }
255943
protected function registerCustomRoutes()
    {
        if (file_exists($file = $this->getBootstrapPath('routes.php'))) {
            $this->registerRoutes(function (Router $route) use ($file) {
                require $file;
            });
        }
    }
687356
protected function registerProviders()
    {
        $providers = $this->def('provider');

        if ($providers)
        {
            if (is_array($providers))
            {
                foreach ($providers as $provider)
                {
                    $this->app->register($instance = new $provider($this->app));
                }
            }
            else
            {
                $this->app->register($instence = new $providers($this->app));
            }
        }
    }
207827
public function registerRoutes()
    {
        if ($this->app->routesAreCached()) {
            return;
        }

        Route::domain((string) config('platform.domain'))
            ->prefix(Dashboard::prefix('/press'))
            ->as('platform.')
            ->middleware(config('platform.middleware.private'))
            ->group(realpath(PLATFORM_PATH.'/routes/press.php'));
    }
1297441
public function registerAuthRoutes()
    {
        $attributes = [
            'prefix'     => config('merchant.route.prefix'),
            'namespace'  => 'ShaoZeMing\Merchant\Controllers',
            'middleware' => config('merchant.route.middleware'),
        ];

        Route::group($attributes, function ($router) {
            /* @var \Illuminate\Routing\Router $router */
            $router->group([], function ($router) {

                /* @var \Illuminate\Routing\Router $router */
                $router->resource('auth/users', 'UserController');
                $router->resource('auth/roles', 'RoleController');
                $router->resource('auth/permissions', 'PermissionController');
                $router->resource('auth/menu', 'MenuController', ['except' => ['create']]);
                $router->resource('auth/logs', 'LogController', ['only' => ['index', 'destroy']]);
            });

            $router->get('auth/forget', 'AuthController@getForget');
            $router->get('auth/register', 'AuthController@getRegister');
            $router->post('auth/register', 'AuthController@postRegister');
            $router->post('auth/forget', 'AuthController@postForget');
            $router->get('auth/login', 'AuthController@getLogin');
            $router->post('auth/login', 'AuthController@postLogin');
            $router->get('auth/logout', 'AuthController@getLogout');
            $router->get('auth/setting', 'AuthController@getSetting');
            $router->put('auth/setting', 'AuthController@putSetting');
        });


        $attributes = [
            'prefix'     => config('merchant.route.prefix'),
            'namespace'  => 'ShaoZeMing\Merchant\Controllers',
            'middleware' => ['web'],
        ];
        Route::group($attributes, function ($router) {
            $router->get('auth/forget', 'AuthController@getForget');
            $router->get('auth/register', 'AuthController@getRegister');
            $router->post('auth/register', 'AuthController@postRegister');
            $router->post('auth/forget', 'AuthController@postForget');
        });
    }
269203
private function registerRoutes()
    {
        collect(($routes = $this->getRoutes()))->each(function ($route) {
            $this->registerRoute($route);
        });

        $this->registerResourcesRoutes();
    }
324761
protected function registerProviders()
    {
        // register rollbar service provider
        if (class_exists(HCRollbarServiceProvider::class))
            $this->app->register(HCRollbarServiceProvider::class);

        // register LogViewer service provider
        if (class_exists(LaravelLogViewerServiceProvider::class))
            $this->app->register(LaravelLogViewerServiceProvider::class);
    }
1097835
protected function registerServices()
    {
        foreach ($this->serviceBindings as $key => $value) {
            is_numeric($key)
                    ? $this->app->singleton($value)
                    : $this->app->singleton($key, $value);
        }
    }