Register the Sidebar Package.
976855
private function registerSidebarPackage()
    {
        $this->registerProvider(SidebarServiceProvider::class);

        $this->alias('Sidebar', \Arcanesoft\Sidebar\Facades\Sidebar::class);
    }
715531
def register():
    """"""
    signals.initialized.connect(initialized)
    try:
        signals.content_object_init.connect(detect_content)
        signals.all_generators_finalized.connect(detect_images_and_galleries)
        signals.article_writer_finalized.connect(resize_photos)
    except Exception as e:
        logger.exception('Plugin failed to execute: {}'.format(pprint.pformat(e)))
551411
public function registerStudioPackages()
    {
        $repoManager = $this->composer->getRepositoryManager();
        $composerConfig = $this->composer->getConfig();

        foreach ($this->getManagedPaths() as $path) {
            $this->io->writeError("[Studio] Loading path $path");

            $repoManager->prependRepository(new PathRepository(
                ['url' => $path],
                $this->io,
                $composerConfig
            ));
        }
    }
595365
function register() {
    ko.extenders['searchArray'] = searchArrayExtension;
    ko.components.register('grid', {
        template: template,
        viewModel: viewModel
    });
}
1260541
protected function publishSidebarItems()
    {
        $this->publishes([
            $this->getSidebarFolder() => config_path($this->vendor.DS.'sidebar'.DS.$this->package)
        ], 'sidebar');
    }
563390
protected function registerSubscribeService(){

        $this->app->bind('designpond\newsletter\Newsletter\Repo\NewsletterSubscriptionInterface', function()
        {
            return new \designpond\newsletter\Newsletter\Repo\NewsletterSubscriptionEloquent(
                new \designpond\newsletter\Newsletter\Entities\Newsletter_subscriptions
            );
        });
    }
13620
public function register()
    {
        //register commands
        $this->commands([
            Commands\HelperMakeCommand::class,
        ]);

        //include the active package helpers
        foreach (config('helpers.package_helpers', []) as $activeHelper) {

            $file = __DIR__ . '/Helpers/' . $activeHelper . '.php';

            if (file_exists($file)) {
                require_once($file);
            }
        }

        //load custom helpers with a mapper
        if (count(config('helpers.custom_helpers', []))) {

            foreach (config('helpers.custom_helpers', []) as $customHelper) {

                $file = app_path() . '/' . $this->getHelpersDirectory() . '/' . $customHelper . '.php';

                if(file_exists($file)) {
                    require_once($file);
                }
            }
        }

        //load custom helpers automatically
        else {

            //include the custom helpers
            foreach (glob(app_path() . '/' . $this->getHelpersDirectory() . '/*.php') as $file) {
                require_once($file);
            }
        }
    }
70131
protected function registerSidebars()
    {
        do_action("before_theme_register_sidebars");

        foreach ($this->getConfig("sidebars") as $id => $sidebar):
            add_action("widgets_init", function () use ($id, $sidebar) {
                register_sidebar(array(
                    'name' => __($sidebar["name"], 'sections'),
                    'id' => $id,
                    'description' => __($sidebar["description"], 'sections'),
                    'before_widget' => $sidebar["before_widget"],
                    'after_widget' => $sidebar["after_widget"],
                    'before_title' => $sidebar["before_title"],
                    'after_title' => $sidebar["after_title"]
                ));
            });
        endforeach;

        do_action("after_theme_register_sidebars");
    }
1093844
public function register()
    {
        $this->loadViewsFrom(__DIR__.'/resources/views/', $this->_packageTag);
        $this->mergeConfigFrom(__DIR__.'/config/exceptions.php', $this->_packageTag);
        $this->publishFiles();
    }
32516
protected function registerPackages()
    {
        $packages = (array) $this->config->get('packages');

        /** @var PackageResolver $resolver */
        $resolver = $this->container->get('package.resolver');

        $resolver->registerPackages($packages);

        return $this;
    }
41232
function register(pack) {
                    // cancel timeout
                    if (timer) {
                        clearTimeout(timer);
                        timer = null;
                    }

                    if (pack === false) {
                        return;
                    }

                    if (typeof name === "string") {
                        packages.set(name, pack);
                        events.emit("load:" + name, packages.get(name));
                    }

                    return succeed(pack);
                }
744165
protected function registerConfigPublisher()
	{
		$this->registerConfigPublishCommand();

		$this->app->bindShared('config.publisher', function($app)
		{
			$path = $app['path'].'/config';

			// Once we have created the configuration publisher, we will set the default
			// package path on the object so that it knows where to find the packages
			// that are installed for the application and can move them to the app.
			$publisher = new ConfigPublisher($app['files'], $path);

			$publisher->setPackagePath($app['path.base'].'/vendor');

			return $publisher;
		});
	}
374158
public function register()
    {
        parent::register();

        $this->registerConfig();
        $this->registerProviders([
            Providers\PackagesServiceProvider::class,
            Providers\EventServiceProvider::class,
        ]);
        $this->registerConsoleServiceProvider(Providers\CommandServiceProvider::class);

        $this->registerDetectors();
        $this->registerParsers();
        $this->registerTrackers();
        $this->registerMainTracker();
        $this->registerExceptionHandler();
    }
1034196
public function registerPackageRoot() {
    if (!isset($GLOBALS['env']) || !array_key_exists('root', $GLOBALS['env'])) {
      return $GLOBALS['env']['root'] = class_exists('Webforge\Common\System\Dir') ? new \Webforge\Common\System\Dir($this->dir) : $this->dir;
    }
  }
737622
def register_pkg(name, formula_def, conn=None):
    '''
    
    '''
    close = False
    if conn is None:
        close = True
        conn = init()

    conn.execute('INSERT INTO packages VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', (
        name,
        formula_def['version'],
        formula_def['release'],
        datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
        formula_def.get('os', None),
        formula_def.get('os_family', None),
        formula_def.get('dependencies', None),
        formula_def.get('os_dependencies', None),
        formula_def.get('os_family_dependencies', None),
        formula_def['summary'],
        formula_def['description'],
    ))
    if close:
        conn.close()
73987
public function registerEditorPage()
    {
        $this->register(
            $pageTitle = __('Modularity editor'),
            $menuTitle = __('Editor'),
            $capability = 'edit_posts',
            $menuSlug = 'modularity-editor',
            $iconUrl = null,
            $position = 1,
            $parent = 'options.php'
        );
    }
1335279
public function register()
    {
        $this->mergeConfigFrom(self::PACKAGE_DIR . 'config/voyager-frontend.php', 'voyager-frontend');

        // Merge our Scout config over
        $this->mergeConfigFrom(self::PACKAGE_DIR . 'config/scout.php', 'scout');

        $this->app->alias(VoyagerFrontend::class, 'voyager-frontend');
    }