Get the plugin names from the makefile.

@param string $makefile /path/to/Makefile

@return array plugin names.
497330
protected function getPluginNames($makefile)
    {
        $mkdata = file_get_contents($makefile);

        preg_match(
            '/bootstrap(\:|\/js\/\*\.js: js\/\*\.js)\s?\n(\n|.)*?((cat\s)(?P<files>.*?))\s>/i',
            $mkdata, $matches
        );

        return array_map(function ($value) {
            return preg_replace('/(js\/bootstrap-([\w_-]+)\.js)/', '\2', $value);
        }, preg_split('/\s+/', $matches['files']));
    }
1118713
def get_plugins(directory):
    
    # not just plugin_*.py
    plugins = []
    files = glob.glob(directory + "/*.py")
    for p in files:
        p = p.replace(directory + "/", "").replace(".py", "")
        if not p.startswith('_'):
            plugins.append(p)
    # log.info("Loading Plugins from {0}".format(dir))
    # log.info("   {0}".format(str(plugins)))
    return plugins
398217
public function generatePluginFileList($files, $plugin)
	{
		if (!count($files))
		{
			return "";
		}

		$text = array();

		foreach ($files as $f)
		{
			foreach ($f as $type => $value)
			{
				$p = "";

				if ($value == $plugin . ".php")
				{
					$p = ' plugin="' . $plugin . '"';

				}

				$text[] = "<" . $type . $p . ">" . $value . "</" . $type . ">";
			}
		}

		return implode("\n", $text);
	}
701292
public static function &getNameFromInstance($instance)
	{
		static $namnes;
		if (!isset($namnes)) {
			$namnes = array();
		}
		//only create a new plugin instance if it has not been created before
		if (!isset($namnes[$instance])) {
			$db = static::getDbo();

			$query = $db->getQuery(true)
				->select('original_name')
				->from('#__jfusion')
				->where('name = ' . $db->quote($instance));

			$db->setQuery($query);
			$name = $db->loadResult();

			if (!$name) {
				$name = $instance;
			}
			$namnes[$instance] = $name;
		}
		return $namnes[$instance];
	}
1215221
def GetNames(cls):
    
    names = []
    for plugin_class in cls._plugins.values():
      name = getattr(plugin_class, 'ARTIFACT_DEFINITION_NAME', None)
      if name:
        names.append(name)

    return names
683064
public static function getPluginNameFromBacktrace($backtrace)
    {
        foreach ($backtrace as $tracepoint) {
            // try and discern the plugin name
            if (isset($tracepoint['class'])) {
                $className = self::getPluginNameFromNamespace($tracepoint['class']);
                if ($className) {
                    return $className;
                }
            }
        }
        return false;
    }
534338
protected function get_enabled_plugins() {
        $plugins = \core\plugininfo\fileconverter::get_enabled_plugins();

        $pluginclasses = [];
        foreach ($plugins as $plugin) {
            $pluginclasses[$plugin] = \core\plugininfo\fileconverter::get_classname($plugin);
        }

        return $pluginclasses;
    }
881097
def get_makefile_filename():
    """"""
    if _PYTHON_BUILD:
        return os.path.join(_PROJECT_BASE, "Makefile")
    if hasattr(sys, 'abiflags'):
        config_dir_name = 'config-%s%s' % (_PY_VERSION_SHORT, sys.abiflags)
    else:
        config_dir_name = 'config'
    return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile')
1048527
function listPluginNamesOptions($discovery_type = NULL) {
    $data = $this->listPluginData($discovery_type);

    $return = array();
    foreach ($data as $plugin_type_name => $plugin_type_info) {
      $return[$plugin_type_name] = $plugin_type_info['type_label'];
    }

    return $return;
  }
1300579
protected static function pluginsWithTemplates(): array
    {
        $plugins = Plugin::loaded();

        array_walk($plugins, function ($plugin, $index) use (&$plugins) {
            $paths = App::path('Template', $plugin);

            array_walk($paths, function ($path, $index) use (&$paths) {
                if (!is_dir($path)) {
                    unset($paths[$index]);
                }
            });
        });

        return $plugins;
    }
464228
protected function get_plugin_name() {
		$path = $this->get_path();
		$array = explode('/', $path);
		unset($array[count($array) - 1]);
		unset($array[count($array) - 1]);
		return end($array) . '/' . DIRECTORY_APP_NAME;
	}
840496
protected static function getPluginArchivers()
    {
        if (empty(static::$archivers)) {
            $pluginNames = \Piwik\Plugin\Manager::getInstance()->getActivatedPlugins();
            $archivers = array();
            foreach ($pluginNames as $pluginName) {
                $archivers[$pluginName] = self::getPluginArchiverClass($pluginName);
            }
            static::$archivers = array_filter($archivers);
        }
        return static::$archivers;
    }
504360
public function getRequirements($plugin)
    {
        $bundle = $this->getBundle($plugin);

        return [
            'extensions' => $bundle->getRequiredExtensions(),
            'plugins' => $bundle->getRequiredPlugins(),
            'extras' => array_map(function ($require) {
                return $require['failure_msg'];
            }, $bundle->getExtraRequirements()),
        ];
    }
251279
protected function getMenuMethods($plugin)
    {
        //Gets all methods from `$PLUGIN\View\Helper\MenuHelper`
        $methods = get_child_methods(sprintf('\%s\View\Helper\MenuHelper', $plugin));

        //Filters invalid name methods and returns
        return $methods ? array_values(preg_grep('/^(?!_).+$/', $methods)) : [];
    }
523984
def get_plugin_modules(plugins):
    
    if not plugins:
        raise MissingPluginNames("input plugin names are required")

    modules = []

    for plugin in plugins:
        short_name = PLUGIN_MAPPING.get(plugin.lower(), plugin.lower())
        full_path = '%s%s' % (module_prefix, short_name)
        modules.append(importlib.import_module(full_path))

    return tuple(modules)
739249
public function getPluginNamespaces()
    {
        $classNames = [];

        foreach ($this->getVendorAndPluginNames() as $vendorName => $vendorList) {
            foreach ($vendorList as $pluginName => $pluginPath) {
                $namespace = '\\'.$vendorName.'\\'.$pluginName;
                $namespace = Str::normalizeClassName($namespace);
                $classNames[$namespace] = $pluginPath;
            }
        }

        return $classNames;
    }
379623
protected function get_module_names() {
        if ($this->_modnames !== null) {
            return $this->_modnames;
        }
        $this->_modnames = [];
        foreach ($this->cms as $cm) {
            $this->_modnames[$cm->modname] = $cm->modfullname;
        }
        return $this->_modnames;
    }