Register the mandrill service provider.

@return void
507144
public function register()
    {

        $this->app->bind('mandrill_mail', function($app){
            return new Mail($app['config']['services']['mandrill']['secret']);
        });

        $this->app->bind('Weblee\Mandrill\Mail', function($app){
            return new Mail($app['config']['services']['mandrill']['secret']);
        });

    }
1268927
public function register()
    {
        $this->registerLangFileManager();
        $this->setupRoutes($this->app->router);

        $this->app->singleton('langfile', function ($app) {
            return new LangFiles($app['config']['app']['locale']);
        });

        // use this if your package has a config file
        // config([
        //         'config/langfilemanager.php',
        // ]);
    }
434615
public function register()
    {
        // Register facade
        $this->app->singleton('settings', function () {
            return $this->app->make('Klaravel\Settings\SettingHelper');
        });

        // Register commands
        $this->commands($this->commands);
    }
544972
public function register()
    {
        $this->app->singleton(ServiceCaller::class, function ($app) {
            return new ServiceCaller($app);
        });

        $this->app->alias(
            ServiceCaller::class,
            AbstractServiceCaller::class
        );
    }
176440
public function register()
	{
		$this->app->instance('path.censors', $this->censorsPath());

		$this->app->singleton('ruler.loader', function ($app) {
			return new FileLoader($app['files'], $app['path.censors']);
		});

		$this->app->singleton('ruler', function ($app) {
			$loader = $app['ruler.loader'];

			// When registering the translator component, we'll need to set the default
			// locale as well as the fallback locale. So, we'll grab the application
			// configuration so we can easily get both of these values from there.
			$locale = $app['config']['app.locale'];

			$ruler = new Ruler($loader, $locale);

			$ruler->setFallback($app['config']['app.fallback_locale']);

			return $ruler;
		});

		$this->app->singleton('censor', function ($app) {
			return new Factory($app['ruler']);
		});

		$this->app->alias('ruler', Ruler::class);
		$this->app->alias('censor', Factory::class);

	}
149391
public function register()
    {
        $this->app->singleton('shield', function (Container $app) {
            $config = $app['config']['shield.users'];

            return new Shield($config);
        });

        $this->app->alias('shield', Shield::class);
    }
1101086
public function register()
    {
        // The system resource manager is used to resolve various system resource types.
        // It also implements the resolver interface which may be used by other components adding system resource types.
        $this->app->singleton('df.system.resource', function ($app) {
            return new SystemResourceManager($app);
        });

        $this->app->resolving('df.service', function (ServiceManager $df) {
            // Add the system service
            $df->addType(new ServiceType([
                    'name'              => 'system',
                    'label'             => 'System Management',
                    'description'       => 'Service supporting management of the system.',
                    'group'             => ServiceTypeGroups::SYSTEM,
                    'singleton'         => true,
                    'config_handler'    => Config::class,
                    'factory'           => function ($config) {
                        return new System($config);
                    },
                    'access_exceptions' => [
                        [
                            'verb_mask' => 31, //Allow all verbs
                            'resource'  => 'admin/session',
                        ],
                        [
                            'verb_mask' => 2, //Allow POST only
                            'resource'  => 'admin/password',
                        ],
                        [
                            'verb_mask' => 1,
                            'resource'  => 'environment',
                        ]
                    ],
                ]
            ));
        });
    }
1018996
public function register() {

		// Version specific registering
		if ($this->version() == 5) $this->registerLaravel5();

		// Determine the cache dir
		$cache_dir = storage_path($this->version() == 5 ? '/framework/views' : '/views');

		// Bind the package-configred MtHaml instance
		$this->app->singleton('laravel-haml.mthaml', function($app) {
			$config = $this->getConfig();
			return new MtHaml\Environment($config['mthaml']['environment'], 
				$config['mthaml']['options'], 
				$config['mthaml']['filters']);
		});

		// Bind the Haml compiler
		$this->app->singleton('Bkwld\LaravelHaml\HamlCompiler', function($app) use ($cache_dir) {
			return new HamlCompiler($app['laravel-haml.mthaml'], $app['files'], $cache_dir);
		});

		// Bind the Haml Blade compiler
		$this->app->singleton('Bkwld\LaravelHaml\HamlBladeCompiler', function($app) use ($cache_dir) {
			return new HamlBladeCompiler($app['laravel-haml.mthaml'], $app['files'], $cache_dir);
		});

	}
531783
public function register()
    {
        // Register the Artisan command binding
        $this->app->bind('stolz.assets.command.flush', function ($app) {
            return new FlushPipelineCommand();
        });
        // Merge user's configuration with the default package config file
        //$this->mergeConfigFrom(__DIR__ . '/config.php', 'assets');
        $config = $this->app['config']->get('assets.groups', []);
        // Register the library instances bindings ...
        // No groups defined. Assume the config is for the default group.
        if (! isset($config['default'])) {
            return $this->registerAssetsManagerInstance('default', $config);
        }
        // Multiple groups
        foreach ($config as $groupName => $groupConfig) {
            $this->registerAssetsManagerInstance($groupName, (array) $groupConfig);
        }
    }
939733
public function register()
	{
		$this->app['chee-module'] = $this->app->share(function($app)
		{
			return new CheeModule($app, $app['config'], $app['files']);
		});
	}
295252
public function register()
    {
        // Register the Generator service provider
        if ($this->app->environment() == 'local') {
            $this->app->register('Laracasts\Generators\GeneratorsServiceProvider');
        }

        // Register our commands
        $this->app->singleton('command.josh.generate', function ($app) {
            return $app['JoshTaylor\MigrationsGenerator\GenerateCommand'];
        });

        $this->commands('command.josh.generate');
    }
954835
public function register()
    {
        $this->app->singleton('Congraph\Core\Bus\CommandDispatcher', function ($app) {
            return new CommandDispatcher($app, function () use ($app) {
                return $app['Illuminate\Contracts\Queue\Queue'];
            });
        });

        $this->app->alias(
            'Congraph\Core\Bus\CommandDispatcher', 'Illuminate\Contracts\Bus\Dispatcher'
        );

        $this->app->alias(
            'Congraph\Core\Bus\CommandDispatcher', 'Illuminate\Contracts\Bus\QueueingDispatcher'
        );
    }
779406
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../config/services.php', 'services');

        $this->registerProviders();

        $this->app->bind('hclog', function () {
            return new HCLog;
        });

        // register artisan commands
        $this->commands($this->commands);

        $this->registerHelpers();
    }
1002573
public function register()
	{
		$this->app['laravel-head'] = $this->app->share(function($app)
		{
			return new LaravelHead;
		});

		$this->app->booting(function()
		{
			$loader = \Illuminate\Foundation\AliasLoader::getInstance();
			$loader->alias('Head', 'Gwnobots\LaravelHead\LaravelHeadFacade');
		});
	}
794708
public function register()
    {
        $this->app['localization.js-generator'] = $this->app->share(function ($app) {
            $files = $app['files'];

            return new Generators\LangJsGenerator($files);
        });
        $this->app['localization.js'] = $this->app->share(function ($app) {
            return new Commands\LangJsCommand($app['localization.js-generator']);
        });
        $this->commands('localization.js');
    }
188097
public function register()
    {
        $this->setConfigPath();
        $this->assertConfigDir();

        $mikado = new Mikado();

        foreach (new DirectoryIterator($this->configPath) as $fileInfo) {
            if ($fileInfo->isDot()) {
                continue;
            }
            $this->addManager($fileInfo, $mikado);
        }

        $this->app->singleton('kriskbx\mikado\Mikado', function ($app) use ($mikado) {
            return $mikado;
        });
    }
1121749
public function register() {
		$this->mergeConfigFrom(
			__DIR__ . '/../config/parsedownextra.php', 'parsedownextra'
		);

		$this->app->singleton(ParsedownExtraLaravel::class, function($app) {
			return new ParsedownExtraLaravel;
		});

		$this->app->singleton(HTMLPurifierLaravel::class, function($app) {
			return new HTMLPurifierLaravel;
		});
	}