Register a group of directives as being loaded.
480741
function registerDirectives(Vue, directives) {
        for (var directive in directives) {
            registerDirective(Vue, directive, directives[directive]);
        }
    }
916147
protected function registerAssets()
    {
        $view = $this->getView();
        ChosenSelectAsset::register($view);
        $js = '$("#' . $this->options['id'] . '").chosen(' . $this->getPluginOptions() . ');';
        $view->registerJs($js, $view::POS_END);
    }
1290693
private function registerProviders(): void
    {
        $this->providers = array_merge($this->providers, $this->getConfigProviders());

        foreach ($this->providers as $provider) {
            $provider = $this->container->get($provider);
            $provider->boot();
        }
    }
396591
def register():
    """"""
    if not plim:
        logger.warning('`slim` failed to load dependency `plim`. '
                       '`slim` plugin not loaded.')
        return
    if not mako:
        logger.warning('`slim` failed to load dependency `mako`. '
                       '`slim` plugin not loaded.')
        return
    if not bs:
        logger.warning('`slim` failed to load dependency `BeautifulSoup4`. '
                       '`slim` plugin not loaded.')
        return
    if not minify:
        logger.warning('`slim` failed to load dependency `htmlmin`. '
                       '`slim` plugin not loaded.')
        return

    signals.get_writer.connect(get_writer)
740602
public static function requireView() : void
  {
    $medusa = new Medusa(self::$viewsEngine);

    $medusa->setCacheDirectory(self::$viewsCache);
    $medusa->setViewsDirectory(self::$viewsDirectory);
    $medusa->setViewsExtension(self::$viewsExtension);

    $medusa->register(Partial::class);
    $medusa->register(Using::class);
    $medusa->register(Csrf::class);
    $medusa->register(ConfigToJsonString::class);

    if (class_exists(DirectivesResolver::class)) {
      (new DirectivesResolver)->start([
        'view' => $medusa
      ]);
    }

    self::$viewComponent = $medusa;
  }
1374475
private function registerEvents()
    {
        foreach ($this->getSetting('events', []) as $event => $listeners) {
            foreach ($listeners as $listener) {
                Event::bind($event, $listener);
            }
        }
    }
90290
def register_commands(self):
        
        for command in self._entry_points[self.COMMANDS_ENTRY_POINT].values():
            command.load()
595365
function register() {
    ko.extenders['searchArray'] = searchArrayExtension;
    ko.components.register('grid', {
        template: template,
        viewModel: viewModel
    });
}
1329954
public function loadRegistries()
    {
        $registries = $this->registryFactory->getDefaultRegistries();

        foreach ($registries as $registry) {
            $this->addRegistry($registry);
        }
    }
1102720
public function registerConsoleCommands()
    {
        $this->commands([
            \Plank\Mediable\Commands\ImportMediaCommand::class,
            \Plank\Mediable\Commands\PruneMediaCommand::class,
            \Plank\Mediable\Commands\SyncMediaCommand::class,
        ]);
    }
629937
protected function registerBindings()
    {
        foreach ($this->bindings as $concrete => $abstracts) {
            if (!is_array($abstracts)) {
                $this->app->bind($abstracts, $concrete);
                continue;
            }

            $first = array_shift($abstracts);

            $this->app->bind($first, $concrete);

            foreach ($abstracts as $abstract) {
                $this->app->alias($first, $abstract);
            }
        }
    }
292924
protected function registerLoaders()
    {
        // The array used in the ArrayLoader
        $this->app->bindIf('twig.templates', function () {
            return [];
        });

        $this->app->bindIf('twig.loader.array', function ($app) {
            return new ArrayLoader($app['twig.templates']);
        });

        $this->app->bindIf('twig.loader.viewfinder', function () {
            return new Twig\Loader(
                $this->app['files'],
                $this->app['view']->getFinder(),
                $this->app['twig.extension']
            );
        });

        $this->app->bindIf(
            'twig.loader',
            function () {
                return new ChainLoader([
                    $this->app['twig.loader.array'],
                    $this->app['twig.loader.viewfinder'],
                ]);
            },
            true
        );
    }
261570
protected function register_packs() {
		if ( empty( $this->packs ) ) {
			return;
		}

		$icon_picker = Icon_Picker::instance();
		require_once "{$icon_picker->dir}/includes/types/fontello.php";

		foreach ( $this->packs as $pack_data ) {
			$icon_picker->registry->add( new Icon_Picker_Type_Fontello( $pack_data ) );
		}
	}
898228
protected function registerCommands()
    {
        collect($this->commandList)->each(function ($commandClass, $key) {
            $this->registerCommand($key, $commandClass);
        });
    }
35567
protected function registerViews()
    {
        $path      = $this->getBasePath() . '/' . $this->convention->viewsFolder();
        $namespace = $this->config('views.namespace', $this->shortName());

        if (is_dir($path)) {
            $this->loadViewsFrom($path, $namespace);
        }
    }
475962
protected function registerSingletons()
    {
        foreach ($this->singletons as $concrete => $abstracts) {
            if (!is_array($abstracts)) {
                $this->app->singleton($abstracts, $concrete);
                continue;
            }

            $first = array_shift($abstracts);

            $this->app->singleton($first, $concrete);

            foreach ($abstracts as $abstract) {
                $this->app->alias($first, $abstract);
            }
        }
    }
934392
protected function registerProviders(): void
    {
        foreach ($this->providers as $provider) {
            $this->app->register($provider);
        }
    }