Get available modules (WP filter)
@return array
326640
public function getRegistered($getBundled = true)
    {
        if ($getBundled) {
            $bundeled = $this->getBundeled();
            self::$registered = array_merge(self::$registered, $bundeled);
        }

        return apply_filters('Modularity/Modules', self::$registered);
    }
1311506
public function getModules()
    {
        $modules = array();

        $dir = $this->rootDir.'/../src/Terrific/Module/';

        $finder = new Finder();
        $finder->directories()->in($dir)->depth('== 0');

        foreach ($finder as $file) {
            $module = $file->getFilename();
            $modules[$module] = $this->getModuleByName($module, 'small');
        }

        sort($modules);

        return $modules;
    }
1136733
public function getFilters()
    {
        return [
            /**
             * Formatting filters.
             */
            new \Twig_Filter('wpantispam', function ($email, $encoding = 0) {
                return antispambot($email, $encoding);
            }),
            new \Twig_Filter('wpautop', function ($text, $br = true) {
                return wpautop($text, $br);
            }),
            new \Twig_Filter('wpnofollow', function ($text) {
                return wp_rel_nofollow($text);
            }),
            new \Twig_Filter('wptrimexcerpt', function ($text) {
                return wp_trim_excerpt($text);
            }),
            new \Twig_Filter('wptrimwords', function ($text, $num_words = 55, $more = null) {
                return wp_trim_words($text, $num_words, $more);
            }),
            new \Twig_Filter('zeroise', function ($number, $treshold = 4) {
                return zeroise($number, $treshold);
            })
        ];
    }
739675
public function getIgnores()
    {
        $configFile = $this->directory.'/.moodle-plugin-ci.yml';

        if (!is_file($configFile)) {
            return [];
        }

        $config = Yaml::parse(file_get_contents($configFile));

        // Search for context (AKA command) specific filter first.
        if (!empty($this->context) && array_key_exists('filter-'.$this->context, $config)) {
            return $config['filter-'.$this->context];
        }

        return array_key_exists('filter', $config) ? $config['filter'] : [];
    }
411988
public function getList()
    {
        $modules = &gplcart_static('module.list');

        if (isset($modules)) {
            return $modules;
        }

        $installed = $this->getInstalled();

        $modules = array();

        foreach ($this->scan() as $module_id => $info) {
            $modules[$module_id] = $this->prepareInfo($module_id, $info, $installed);
        }

        gplcart_array_sort($modules);

        return $modules;
    }
539067
public function getFrontendModules()
    {
        $modules = [];

        foreach ($this->getModules() as $id => $obj) {
            if ($obj instanceof Module && !$obj instanceof AdminModuleInterface && !$obj instanceof CoreModuleInterface) {
                $modules[$id] = $obj;
            }
        }

        return $modules;
    }
452781
public function getFilters()
    {
        $filters = [];

        $filters[] = new \Twig_Filter('date_format', [$this, 'filterDateFormat']);
        $filters[] = new \Twig_Filter('truncate', 'b_truncate');
        $filters[] = new \Twig_Filter('nl2p', 'b_nl2p', ['is_safe' => ['html']]);
        $filters[] = new \Twig_Filter('human_file_size', 'b_human_file_size');
        $filters[] = new \Twig_Filter('json_decode', 'json_decode');

        return $filters;
    }
1220997
protected function getPluggables()
    {
        $pluggables = $this->pluggable->all();
        $results = [];

        foreach ($pluggables as $pluggable) {
            $results[] = $this->getPluggableInformation($pluggable);
        }

        return array_filter($results);
    }
501409
private function adminModules()
    {
        $return = [];

        foreach ($this->app[ 'config' ]->get('modules.all') as $module) {
            $controller = '\\app\\'.$module.'\\Controller';

            if (!class_exists($controller)) {
                continue;
            }

            if (property_exists($controller, 'scaffoldAdmin') ||
                property_exists($controller, 'hasAdminView')) {
                $moduleInfo = [
                    'name' => $module,
                    'title' => Inflector::get()->titleize($module), ];

                if (property_exists($controller, 'properties')) {
                    $moduleInfo = array_replace($moduleInfo, $controller::$properties);
                }

                $return[] = $moduleInfo;
            }
        }

        return $return;
    }
74275
protected function getFilterArray()
    {
        return array_merge(parent::getFilterArray(), [
      self::ARGUMENT_FILTER_OFFSET => $this->arguments[self::ARGUMENT_FILTER_OFFSET],
      self::ARGUMENT_FILTER_LIMIT => $this->arguments[self::ARGUMENT_FILTER_LIMIT],
      self::ARGUMENT_FILTER_TYPES => $this->arguments[self::ARGUMENT_FILTER_TYPES],
      self::ARGUMENT_FILTER_NAME => $this->arguments[self::ARGUMENT_FILTER_NAME],
      self::ARGUMENT_FILTER_CATEGORYID => $this->arguments[self::ARGUMENT_FILTER_CATEGORYID],
      self::ARGUMENT_FILTER_REPERTOIREID => $this->arguments[self::ARGUMENT_FILTER_REPERTOIREID],
      self::ARGUMENT_FILTER_LOCATION => $this->arguments[self::ARGUMENT_FILTER_LOCATION]
    ]);
    }
175286
public function getFiltering(): array
    {
        if ($this->filtering === null) {
            $this->filtering = $this->setFiltering();
        }

        return $this->filtering;
    }
1080950
private function getFilters()
    {
        $filters = [];

        $regions = [
            'fieldID' => 'region_id',
            'type' => 'dropDownList',
            'label' => trans('HCRegions::regions_countries.region'),
            'options' => HCContinents::all()->toArray(),
            'showNodes' => ['name'],
        ];

        $filters[] = addAllOptionToDropDownList($regions);

        return $filters;
    }
414014
protected function getAvailableFilters()
    {
        $filters = [];

        foreach ($this->config['allowed_filters'] as $key) {
            if (!isset($this->filterSets[$key])) {
                continue;
            }

            $set = $this->filterSets[$key];

            $explanation = [];
            foreach ($set['filters'] as $filter => $properties) {
                switch ($filter) {
                    case 'thumbnail':
                        $explanation[] = $properties['size'][0].' X '. $properties['size'][0];
                        break;
                    case 'relative_resize':
                        $heighten = (isset($properties['heighten'])) ? $properties['heighten'] : '~';
                        $widen = (isset($properties['widen'])) ? $properties['widen'] : '~';
                        $explanation[] = $widen.' X '.$heighten;
                        break;
                }
            }
            $filters[$key . ' ('.implode(', ', $explanation).')'] = $key;
        }

        return $filters;
    }
109650
private function availableUserBlocks(): Collection
    {
        return $this->module_service->findByInterface(ModuleBlockInterface::class, false, true)
            ->filter(static function (ModuleBlockInterface $block): bool {
                return $block->isUserBlock();
            })
            ->mapWithKeys(static function (ModuleInterface $block): array {
                return [$block->name() => $block];
            });
    }
466742
protected function filterSlickModules()
    {
        $iterator = new \ArrayIterator($this->psr4Data);
        $modules = [];
        foreach ($iterator as $nameSpace => $path) {
            if (preg_match('/^Slick\\\[a-z_]*\\\$/i', $nameSpace)) {
                $modules[$nameSpace] = reset($path);
            }
        }
        return $modules;
    }
329309
public function getRequiredModules()
    {
        if ($this->_aRequiredModules == null) {
            $aRequiredPHPExtensions = [
                'php_xml',
                'j_son',
                'i_conv',
                'tokenizer',
                'mysql_connect',
                'gd_info',
                'mb_string',
                'curl',
                'bc_math',
                'open_ssl',
                'soap',
            ];

            $aRequiredPHPConfigs = [
                'allow_url_fopen',
                'request_uri',
                'ini_set',
                'memory_limit',
                'unicode_support',
                'file_uploads',
                'session_autostart',
            ];

            $aRequiredServerConfigs = [
                'php_version',
                'mod_rewrite',
                'server_permissions'
            ];

            if ($this->isAdmin()) {
                $aRequiredServerConfigs[] = 'mysql_version';
            }
            $this->_aRequiredModules = array_fill_keys($aRequiredServerConfigs, 'server_config') +
                                       array_fill_keys($aRequiredPHPConfigs, 'php_config') +
                                       array_fill_keys($aRequiredPHPExtensions, 'php_extennsions')
                                       ;
        }

        return $this->_aRequiredModules;
    }
819646
protected function _getOxcomAdminSearchModules()
    {
        $aData = [];
        $oModules = oxNew(\OxidEsales\Eshop\Core\Module\ModuleList::class);
        $aModules = $oModules->getModulePaths();
        foreach ($aModules as $sKey => $sValue) {
            $oModule = oxNew(\OxidEsales\Eshop\Core\Module\Module::class);
            $oModule->load($sKey);
            $sTitle = strip_tags($oModule->getTitle());
            if (strstr(strtolower($sTitle), strtolower($this->_sQueryName))) {
                $aData[] = ['name' => $sTitle . ' (' . ($oModule->isActive() ? Registry::getLang()->translateString("OXCOM_ADMINSEARCH_MODULE_ACTIVE") : Registry::getLang()->translateString("OXCOM_ADMINSEARCH_MODULE_INACTIVE")) . ')', 'oxid' => $sKey, 'type' => 'module'];
            }
        }

        return $aData;
    }