Load plugins as per configuration file. Note: all plugins embedded in this gem are automatically
 loaded. This is just for user-specified plugins.

 plugins - An Array of file names to load
969833
def load_plugins(plugins)
      unless plugins.is_a?(Array)
        raise ArgumentError, "load_plugins expects an array, got #{plugins.inspect}"
      end

      plugins.each do |plugin|
        plugin_file = plugin.start_with?("/") ? plugin : File.expand_path("../../#{plugin}", File.dirname(__FILE__))
        unless File.file?(plugin_file)
          raise Errno::ENOENT, "Failed to find plugin #{plugin.inspect} at #{plugin_file}"
        end
        require plugin_file
      end
    end
1360511
def load(self):
        

        self._setup_directories()
        self._load_plugins()
        self._setup_task(load=True)
        self._loaded = True
300621
def autoload
    logger.info("Autoloading registered plugins at #{Time.now}")

    @@environments[@actor_id].autoload do |namespace, plugin_type, provider, plugin|
      logger.debug("Autoloading provider #{provider} at #{plugin[:directory]}")

      # Make sure extensions are listening from the time they are loaded
      if plugin[:namespace] == :nucleon && plugin_type == :extension
        logger.debug("Creating #{plugin_type} #{provider}")

        # Create a persistent instance
        load(plugin[:namespace], :extension, provider, { :name => provider })
      end
    end
  end
859906
def load_sub_plugins_from_str(cls, plugins_str):
        
        plugin_classes = {}
        if plugins_str:
            for plugin_name in plugins_str.split(":"):
                pc = load_plugin(plugin_name, MONITOR_DEFAULT_PLUGIN_MODULE)
                plugin_classes[plugin_name] = pc
        return plugin_classes
595655
def load_plugins(self):
        """"""
        from dyndnsc.plugins.builtin import PLUGINS
        for plugin in PLUGINS:
            self.add_plugin(plugin())
        super(BuiltinPluginManager, self).load_plugins()
64535
def load_plugins
      UI.verbose("Checking if there are any plugins that should be loaded...")

      loaded_plugins = false
      available_plugins.each do |gem_name|
        UI.verbose("Loading '#{gem_name}' plugin")
        begin
          # BEFORE requiring the gem, we get a list of loaded actions
          # This way we can check inside `store_plugin_reference` if
          # any actions were overwritten
          self.loaded_fastlane_actions.concat(Fastlane::Actions.constants)

          FastlaneRequire.install_gem_if_needed(gem_name: gem_name, require_gem: true)

          store_plugin_reference(gem_name)
          loaded_plugins = true
        rescue StandardError, ScriptError => ex # some errors, like ScriptError are not caught unless explicitly
          UI.error("Error loading plugin '#{gem_name}': #{ex}")

          # We'll still add it to the table, to make the error
          # much more visible and obvious
          self.plugin_references[gem_name] = {
            version_number: Fastlane::ActionCollector.determine_version(gem_name),
            actions: []
          }
        end
      end

      if !loaded_plugins && self.pluginfile_content.to_s.include?(PluginManager.plugin_prefix)
        UI.error("It seems like you wanted to load some plugins, however they couldn't be loaded")
        UI.error("Please follow the troubleshooting guide: #{TROUBLESHOOTING_URL}")
      end

      skip_print_plugin_info = self.plugin_references.empty? || CLIToolsDistributor.running_version_command? || FastlaneCore::Env.truthy?("FASTLANE_ENV_PRINTER")

      # We want to avoid printing output other than the version number if we are running `fastlane -v`
      print_plugin_information(self.plugin_references) unless skip_print_plugin_info
    end
652316
def load_yaml
      yaml_config_files = @filenames[:yaml]
      yaml_config_file = nil

      yaml_config_files.each do |file|
        yaml_config_file = Utils.lookup_file file
        unless yaml_config_file.nil?
          config = Utils.load_yaml(yaml_config_file)
          return config.empty? ? @default_config : @default_config.merge(config)
        end
      end

      @default_config # Return default config when can't load config file
    end
867744
function loadPlugins(deps) {
  let pluginsList = deps;
  if (!Array.isArray(pluginsList)) {
    if (typeof pluginsList !== 'object') {
      return;
    }
    pluginsList = Object.keys(pluginsList);
  }
  pluginsList.filter(moduleName => /@gilt-tech\/swig-(?!util)/.test(moduleName))
    .forEach(load);
}
1259615
def load_plugins(builtin=True, others=True):
    
    for entry_point in pkg_resources.iter_entry_points('yolk.plugins'):
        #LOG.debug("load plugin %s" % entry_point)
        try:
            plugin = entry_point.load()
        except KeyboardInterrupt:
            raise
        except Exception as err_msg:
            # never want a plugin load to exit yolk
            # but we can't log here because the logger is not yet
            # configured
            warn("Unable to load plugin %s: %s" % \
                    (entry_point, err_msg), RuntimeWarning)
            continue
        if plugin.__module__.startswith('yolk.plugins'):
            if builtin:
                yield plugin
        elif others:
            yield plugin
1081372
def load_plugins_dir(path, category=None, overwrite=False):
    
    # get potential plugin python files
    if hasattr(path, 'glob'):
        pypaths = path.glob('*.py')
    else:
        pypaths = glob.glob(os.path.join(path, '*.py'))

    load_errors = []
    for pypath in pypaths:
        # use uuid to ensure no conflicts in name space
        mod_name = str(uuid.uuid4())
        try:
            if hasattr(pypath, 'resolve'):
                # Make the path absolute, resolving any symlinks
                pypath = pypath.resolve()

            with warnings.catch_warnings(record=True):
                warnings.filterwarnings("ignore", category=ImportWarning)

                # for MockPaths
                if hasattr(pypath, 'maketemp'):
                    with pypath.maketemp() as f:
                        module = load_source(mod_name, f.name)
                else:
                    module = load_source(mod_name, str(pypath))

        except Exception as err:
            load_errors.append((str(pypath), 'Load Error: {}'.format(err)))
            continue

        # only get classes that are local to the module
        class_members = inspect.getmembers(module, inspect.isclass)
        classes = [klass for klass_name, klass in class_members if
                   klass.__module__ == mod_name]
        load_errors += load_plugin_classes(classes, category, overwrite)

    return load_errors
835998
def load_plugins(group='metrics.plugin.10'):
    
    # on using entrypoints:
    # http://stackoverflow.com/questions/774824/explain-python-entry-points
    file_processors = []
    build_processors = []
    for ep in pkg_resources.iter_entry_points(group, name=None):
        log.debug('loading \'%s\'', ep)
        plugin = ep.load()  # load the plugin
        if hasattr(plugin, 'get_file_processors'):
            file_processors.extend(plugin.get_file_processors())
        if hasattr(plugin, 'get_build_processors'):
            build_processors.extend(plugin.get_build_processors())
    return file_processors, build_processors
1235648
function loadModulePlugins(modulePlugins) {
        var serverModules = {};
        var me = this;

        // add modules from each plugin to the serverModules map
        _.each(modulePlugins, function (modulePlugin) {
            _.extend(serverModules, me.loadModules(modulePlugin.rootDir, modulePlugin.serverModuleDirs));
        });

        return serverModules;
    }
249924
public function loadPlugins()
    {
        $this->checkCache();
        $this->validatePlugins();
        $this->countPlugins();

        array_map(static function () {
            include_once WPMU_PLUGIN_DIR . '/' . func_get_args()[0];
        }, array_keys(self::$cache['plugins']));

        $this->pluginHooks();
    }
770089
def load_manifests(self):
        
        for path in self.plugin_paths:
            for item in os.listdir(path):
                item_path = os.path.join(path, item)
                if os.path.isdir(item_path):
                    self.load_manifest(item_path)
764485
def load_plugins(self, ):
        
        for p in self.__plugins.values():
            try:
                self.load_plugin(p)
            except errors.PluginInitError:
                log.exception('Initializing the plugin: %s failed.' % p)
708498
def load_plugins(self, plugin_class_name):
        
        # imp.findmodule('atomic_reactor') doesn't work
        plugins_dir = os.path.join(os.path.dirname(__file__), 'plugins')
        logger.debug("loading plugins from dir '%s'", plugins_dir)
        files = [os.path.join(plugins_dir, f)
                 for f in os.listdir(plugins_dir)
                 if f.endswith(".py")]
        if self.plugin_files:
            logger.debug("loading additional plugins from files '%s'", self.plugin_files)
            files += self.plugin_files
        plugin_class = globals()[plugin_class_name]
        plugin_classes = {}
        for f in files:
            module_name = os.path.basename(f).rsplit('.', 1)[0]
            # Do not reload plugins
            if module_name in sys.modules:
                f_module = sys.modules[module_name]
            else:
                try:
                    logger.debug("load file '%s'", f)
                    f_module = imp.load_source(module_name, f)
                except (IOError, OSError, ImportError, SyntaxError) as ex:
                    logger.warning("can't load module '%s': %r", f, ex)
                    continue
            for name in dir(f_module):
                binding = getattr(f_module, name, None)
                try:
                    # if you try to compare binding and PostBuildPlugin, python won't match them
                    # if you call this script directly b/c:
                    # ! <class 'plugins.plugin_rpmqa.PostBuildRPMqaPlugin'> <= <class
                    # '__main__.PostBuildPlugin'>
                    # but
                    # <class 'plugins.plugin_rpmqa.PostBuildRPMqaPlugin'> <= <class
                    # 'atomic_reactor.plugin.PostBuildPlugin'>
                    is_sub = issubclass(binding, plugin_class)
                except TypeError:
                    is_sub = False
                if binding and is_sub and plugin_class.__name__ != binding.__name__:
                    plugin_classes[binding.key] = binding
        return plugin_classes
797207
public function loadPlugins($plugins)
	{
		foreach($plugins as $plugin) {
			$pluginClass = str_replace(':','\\',$plugin);

			$this->plugins[] = new $pluginClass($this->core);
		}
	}