Returns currently used static files.
        Assumes that manifest staticfiles.json is up-to-date.
769127
def get_needful_files(self):
        
        manifest = self.storage.load_manifest()
        if self.keep_unhashed_files:
            if PY3:
                needful_files = set(manifest.keys() | manifest.values())
            else:
                needful_files = set(manifest.keys() + manifest.values())
            needful_files = {self.storage.clean_name(file) for file in needful_files}
        else:
            needful_files = set(manifest.values())
        return {self.process_file(file) for file in needful_files}
194164
def applicationlinks(self, cached=True):
        
        # if cached, return the last result
        if cached and hasattr(self, '_applicationlinks'):
            return self._applicationlinks

        # url = self._options['server'] + '/rest/applinks/latest/applicationlink'
        url = self._options['server'] + \
            '/rest/applinks/latest/listApplicationlinks'

        r = self._session.get(url)

        o = json_loads(r)
        if 'list' in o:
            self._applicationlinks = o['list']
        else:
            self._applicationlinks = []
        return self._applicationlinks
825154
def load_manifest(check_name):
    
    manifest_path = os.path.join(get_root(), check_name, 'manifest.json')
    if file_exists(manifest_path):
        return json.loads(read_file(manifest_path))
    return {}
323673
def static_data(fn):
    
    file_path = os.path.normpath(fn)
    full_path = os.path.join(STATIC_PATH, file_path)

    if not os.path.exists(full_path):
        abort(404, "Soubor '%s' neexistuje!" % fn)

    return static_file(
        file_path,
        STATIC_PATH
    )
1137569
protected function getManifest(): array
    {
        if (!is_null($this->manifest)) {
            return $this->manifest;
        }

        return $this->manifest = file_exists($this->manifestPath) ? require $this->manifestPath : [];
    }
559749
protected function obtainLoadInfos()
    {
        $currentClass = get_called_class(); //Allow extends
        
        $this->loadInfos = $currentClass::readJsonFile(
            MODULES_DIR.$this->name
            .'/module.json'
        );
    }
1039490
def get_static_directory():
    
    directory = templates_dir = os.path.join(os.path.dirname(__file__), 'static')
    return directory
1335002
def get_unused_paths(self):
        
        return [path for path in self.filter.paths if path not in self.seen_paths]
88229
def collect(path, no_input):
    ''''''
    if exists(path):
        msg = '"%s" directory already exists and will be erased'
        log.warning(msg, path)
        if not no_input:
            click.confirm('Are you sure?', abort=True)

        log.info('Deleting static directory "%s"', path)
        shutil.rmtree(path)

    prefix = current_app.static_url_path or current_app.static_folder
    if prefix.startswith('/'):
        prefix = prefix[1:]
    destination = join(path, prefix)
    log.info('Copying application assets into "%s"', destination)
    shutil.copytree(current_app.static_folder, destination)

    for blueprint in current_app.blueprints.values():
        if blueprint.has_static_folder:
            prefix = current_app.static_prefixes.get(blueprint.name)
            prefix = prefix or blueprint.url_prefix or ''
            prefix += blueprint.static_url_path or ''
            if prefix.startswith('/'):
                prefix = prefix[1:]

            log.info('Copying %s assets to %s', blueprint.name, prefix)
            destination = join(path, prefix)
            copy_recursive(blueprint.static_folder, destination)

    for prefix, source in current_app.config['STATIC_DIRS']:
        log.info('Copying %s to %s', source, prefix)
        destination = join(path, prefix)
        copy_recursive(source, destination)

    log.info('Done')
1230923
protected static function getAllPaths()
    {
        $paths = Cache::read('paths', 'static_pages');

        if (empty($paths)) {
            //Adds all plugins to paths
            $paths = collection(Plugin::all())
                ->map(function ($plugin) {
                    return self::getPluginPath($plugin);
                })
                ->filter(function ($path) {
                    return file_exists($path);
                })
                ->toList();

            //Adds APP to paths
            array_unshift($paths, self::getAppPath());

            Cache::write('paths', $paths, 'static_pages');
        }

        return $paths;
    }
138215
public function getRevManifest(): array {
        if (is_null(self::$_revManifest)) {
            $manifestPath = APPLICATION_PATH . '/../rev-manifest-' . APPLICATION_ENV . '.json';
            self::$_revManifest = file_exists($manifestPath)
                ? json_decode(file_get_contents($manifestPath), true)
                : [];
        }
        return self::$_revManifest;
    }
804961
def clean!
      files_to_keep = cache.keys.concat(cache.values)

      if (sprockets_manifest = Dir.entries("#{base_dir}").detect { |entry| entry =~ SPROCKETS_MANIFEST_REGEX })
        files_to_keep.concat(JSON.parse(File.read("#{base_dir}/#{sprockets_manifest}")).fetch("files", {}).keys)
      end

      Dir["#{base_dir}/**/*"].each do |path|
        next if File.directory?(path) || files_to_keep.include?(Pathname(path).relative_path_from(base_dir).to_s)

        FileUtils.rm(path)
      end
    end
997437
public function getJsonContents()
	{
		$default = [];

		$path = $this->getJsonPath();

		if ($this->files->exists($path)) {
			$contents = $this->files->get($path);

			return json_decode($contents, true);
		} else {
			throw new UnknownFileException("The theme must have a valid theme.json manifest file.");
		}
	}
199417
def collect_static() -> bool:
    
    from django.core.management import execute_from_command_line
    # from django.conf import settings
    # if not os.listdir(settings.STATIC_ROOT):
    wf('Collecting static files... ', False)
    execute_from_command_line(['./manage.py', 'collectstatic', '-c', '--noinput', '-v0'])
    wf('[+]\n')
    return True
1363955
protected static function getFiles()
    {
        $files = [];
        //
        foreach (glob(Application::$root.'plugins/*') as  $value) {
            $files[] = $value;
        }
        //
        return $files;
    }
824364
private function get_current_plugins() {
		$updates_avail = get_site_transient( 'update_plugins' );

		$msg = '';
		foreach ( wp_get_active_and_valid_plugins() as $plugin ) {
			$plugin_data = get_plugin_data( $plugin );

			$plugin_file = str_replace( trailingslashit( WP_PLUGIN_DIR ), '', $plugin );

			if ( isset( $updates_avail->response[ $plugin_file ] ) ) {
				$msg .= '<i class="icon-close1"></i> ';
			}
			$msg .= '<a href="' . $plugin_data['PluginURI'] . '">' . $plugin_data['Name'] . '</a> v' . $plugin_data['Version'] . '<br/>';
		}

		return $msg;
	}
333443
def get_project_filenames(self):
        """"""
        recent_files = []
        if self.current_active_project:
            recent_files = self.current_active_project.get_recent_files()
        elif self.latest_project:
            recent_files = self.latest_project.get_recent_files()
        return recent_files