Load Charyf generators and invoke the registered hooks.
 Check <tt>Charyf::Extension.generators</tt> for more info.
509086
def load_generators(app = self)
      require_relative 'generators'
      Charyf::Generators.configure!(app.config.generators)

      require_relative 'generators/app/app_generator'
      require_relative 'generators/skill/skill_generator'
      require_relative 'generators/skill/hooks_generator'
      require_relative 'generators/installers/installers_generator'

      run_generators_blocks(app)
      self
    end
651155
def load_functions(self, tree):
        """"""
        for child in tree.children:
            if isinstance(child, FunctionDeclaration):
                function_name = child.identifier.name
                self.memory[function_name] = Function(function_name, child)
1122785
def _load_lexers(module_name):
    """"""
    mod = __import__(module_name, None, None, ['__all__'])
    for lexer_name in mod.__all__:
        cls = getattr(mod, lexer_name)
        _lexer_cache[cls.name] = cls
875479
def load_all(stream):
    
    loader = YAMLDictLoader(stream)
    try:
        while loader.check_data():
            yield loader.get_data()
    finally:
        loader.dispose()
927104
def imports():
    
    from .core.import_hooks import ExtensionImporter
    importer = ExtensionImporter()
    sys.meta_path.append(importer)
    yield
    sys.meta_path.remove(importer)
371542
def prepare_hooks(self, hooks):
        """"""
        # hooks can be passed as None to the prepare method and to this
        # method. To prevent iterating over None, simply use an empty list
        # if hooks is False-y
        hooks = hooks or []
        for event in hooks:
            self.register_hook(event, hooks[event])
828352
def load
      load_source_and_set_module
      module_callbacks if @module
      yield if block_given? # load dependencies
      detect_additions { load_commands } if load_commands?
      set_library_commands
      loaded_correctly? && (@loaded = true)
    end
4572
def _load_hooks(path):
    
    module = imp.load_source(os.path.splitext(os.path.basename(path))[0], path)
    if not check_hook_mechanism_is_intact(module):
        # no hooks - do nothing
        log.debug('No valid hook configuration: \'%s\'. Not using hooks!', path)
    else:
        if check_register_present(module):
            # register the template hooks so they listen to gcdt_signals
            module.register()
    return module
676568
public function loadTemplateEngines()
    {
        if (!$this->engines_loaded) {
            Events::fireEvent('layoutLoadEngineEvent');

            // Load the engines provided in this file
            $this->registerEngine(new PHPEngine(), 'PHP', array('php'));
            $this->registerEngine(new JsonEngine(), 'JSON', array('json'));
            $this->registerEngine(new SmartyEngine(), 'Smarty', array('tpl'));
            $this->registerEngine(new LatteEngine(), 'Latte', array('latte'));
            $this->engines_loaded = true;
        }
    }
131291
def run(self):
        
        self._runtime_initialize()

        if len(self._flattened_nodes) == 0:
            logger.warning("WARNING: Nothing to do. Try checking your model "
                           "configs and model specification args")
            return []
        else:
            logger.info("")

        selected_uids = frozenset(n.unique_id for n in self._flattened_nodes)
        result = self.execute_with_hooks(selected_uids)

        result.write(self.result_path())

        self.task_end_messages(result.results)
        return result.results
739056
private void loadEngines() {
        try {
            ClassLoader cl = ModelExtractors.class.getClassLoader();
            Enumeration<URL> resources = cl.getResources(PROPERTIES);
            while (resources.hasMoreElements()) {
                URL url = resources.nextElement();
                Properties props = new Properties();
                props.load(url.openStream());
                for (Map.Entry<Object, Object> entry : props.entrySet()) {
                    String className = (String) entry.getKey();
                    String[] extensions = ((String) entry.getValue()).split(",");
                    loadAndRegisterEngine(className, extensions);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
1104612
def hooks_factory(identifier, configuration, context):
    
    manager = HookManager(identifier, configuration)
    manager.load_hooks(context)

    return manager
990741
def run_hooks(hooks, halt_on_abort: true)
      hooks.each do |hook|
        run_hook(hook)
        break if aborted? && halt_on_abort
      end
    end
341730
def generate
      generators.each do |generator|
        start = Time.now
        generator.generate(self)
        Bunto.logger.debug "Generating:",
          "#{generator.class} finished in #{Time.now - start} seconds."
      end
    end
123099
private void loadSwaggerExtensions(ApiSource apiSource) throws GenerateException {
        if (apiSource.getSwaggerExtensions() != null) {
            List<SwaggerExtension> extensions = SwaggerExtensions.getExtensions();
            extensions.addAll(resolveSwaggerExtensions());
        }
    }
925865
protected function loadHooks() {
		$hooks = [];
		if(file_exists($this->getPath().'/Hook/')) {
			foreach(glob($this->getPath().'/Hook/*.php') as $filename) {
				$class = \Asgard\Common\Tools::loadClassFile($filename);
				if(is_subclass_of($class, 'Asgard\Hook\HookContainer'))
					$hooks = array_merge_recursive($hooks, $this->hooksAnnotationReader->fetchHooks($class));
			}
		}
		return $hooks;
	}
379124
public function load()
    {
        if (!$this->isLoaded()) {
            $dependencies = $this->getManifest()->getDependencies();
            foreach ($dependencies as $extId => $extVersion) {
                // triggers loading of extensions
                try {
                    $this->getExtensionManager()->getExtensionById($extId);
                } catch (common_ext_ManifestNotFoundException $e) {
                    throw new common_ext_MissingExtensionException($e->getExtensionId().' not found but required for '.$this->getId());
                }
            }
            
            $loader = new common_ext_ExtensionLoader($this);
            $loader->load();
            //load all dependent extensions
            $this->loaded = true;
        }
    }