Get a list of logical paths in the order that the assets will be processed in
964291
function () {
    var bundle = this.bundle;
    var order = bundle.getProcessingOrder();
    return order.map(function (file ) {
      return bundle.getAsset(file).logicalPath;
    });
  }
997113
def path_to_list(pathstr):
    """"""
    return [elem for elem in pathstr.split(os.path.pathsep) if elem]
44282
function _processPathsAndPackages(paths, packages, options) {
    var result = {
        paths: {},
        packages: []
    };
    _.each(paths, function (path, pathName) {
        result.paths[pathName] = _.contains(options.notMerge, pathName) ? 'empty:' : path;
    });
    _.each(packages, function (pkg, i) {
        if (_.contains(options.notMerge, pkg.name)) {
            result.paths[pkg.name] = 'empty:';
        } else {
            result.packages.push(pkg);
        }
    });
    return result;
}
1012380
function absolutizePaths(
  config /*: stylelint$config*/,
  configDir /*: string*/
) /*: stylelint$config*/ {
  if (config.ignoreFiles) {
    config.ignoreFiles = [].concat(config.ignoreFiles).map(glob => {
      if (path.isAbsolute(glob.replace(/^!/, ""))) return glob;

      return globjoin(configDir, glob);
    });
  }

  if (config.plugins) {
    config.plugins = [].concat(config.plugins).map(lookup => {
      return getModulePath(configDir, lookup);
    });
  }

  if (config.processors) {
    config.processors = absolutizeProcessors(config.processors, configDir);
  }

  return config;
}
120696
def get_external_paths(self):
        """"""
        return [to_text_string(self.itemText(i))
                for i in range(EXTERNAL_PATHS, self.count())]
1236172
def get_checks_paths(checks_paths=None):
    
    p = os.path.join(__file__, os.pardir, os.pardir, os.pardir, "checks")
    p = os.path.abspath(p)
    # let's utilize the default upstream checks always
    if checks_paths:
        p += [os.path.abspath(x) for x in checks_paths]
    return [p]
876121
def paths_from_buildroot_iter(self):
    """"""
    for f in self:
      yield os.path.join(self.rel_root, f)
155795
def find_all(*logical_paths, &block)
      return to_enum(__method__, *logical_paths) unless block_given?

      options = extract_options!(logical_paths)
      base_path = (options[:base_path] || root).to_s

      logical_paths.each do |logical_path|
        logical_path = logical_path.sub(/^\//, '')

        if relative?(logical_path)
          find_in_base_path(logical_path, base_path, &block)
        else
          find_in_paths(logical_path, &block)
        end
      end

      nil
    end
152099
def print_paths(self):
        """"""
        # Uses a list to get the order right
        ret = []
        for i in self._get_paths():
            if i not in ret:
                ret.append(i)
        return os.pathsep.join(ret)
833008
def includes(self):
        """"""

        incs = self.combined_properties('includes')

        processed_incs = []
        for prop in incs:
            if isinstance(prop, str):
                processed_incs.append(prop)
            else:
                processed_incs.append(os.path.join(*prop))

        # All include paths are relative to base directory of the
        fullpaths = [os.path.normpath(os.path.join('.', x)) for x in processed_incs]
        fullpaths.append(os.path.normpath(os.path.abspath(self.build_dirs()['build'])))

        return fullpaths
1267759
function getPathStack() {
	return (module.parent || module).paths.map(function(path) {
		return lop(path)
	}).filter(function(path) {
		return (path !== '');
	});
}
283311
def _get_paths():
    """"""
    import os
    base_path = os.path.dirname(os.path.abspath(__file__))
    test_data_dir = os.path.join(base_path, 'tests', 'data', 'Plate01')
    test_data_file = os.path.join(test_data_dir, 'RFP_Well_A3.fcs')
    return test_data_dir, test_data_file
1197760
def list_paths(self):
        """"""
        paths = []
        for cookie in iter(self):
            if cookie.path not in paths:
                paths.append(cookie.path)
        return paths
1310132
def translate_paths (properties, path):
    
    assert is_iterable_typed(properties, Property)
    result = []

    for p in properties:

        if p.feature.path:
            values = __re_two_ampersands.split(p.value)

            new_value = "&&".join(os.path.normpath(os.path.join(path, v)) for v in values)

            if new_value != p.value:
                result.append(Property(p.feature, new_value, p.condition))
            else:
                result.append(p)

        else:
            result.append (p)

    return result
1132383
def _get_result_paths(self, data):
        

        result = {}

        result['Output'] = ResultPath(
            Path=self.Parameters['--output'].Value,
            IsWritten=self.Parameters['--output'].isOn())

        result['ClusterFile'] = ResultPath(
            Path=self.Parameters['--uc'].Value,
            IsWritten=self.Parameters['--uc'].isOn())

        result['PairwiseAlignments'] = ResultPath(
            Path=self.Parameters['--fastapairs'].Value,
            IsWritten=self.Parameters['--fastapairs'].isOn())

        return result
637550
function () {
            var resolvedPath = '',
                resolvedPathStr,
                i,
                args = (arguments),
                path,
                absolute = 0;

            for (i = args.length - 1; i >= 0 && !absolute; i--) {
                path = args[i];
                if (typeof path != 'string' || !path) {
                    continue;
                }
                resolvedPath = path + '/' + resolvedPath;
                absolute = path.charAt(0) == '/';
            }

            resolvedPathStr = normalizeArray(S.filter(resolvedPath.split('/'), function (p) {
                return !!p;
            }), !absolute).join('/');

            return ((absolute ? '/' : '') + resolvedPathStr) || '.';
        }
145752
function paths(dir) {
	var paths = [];

	try {
		fs.statSync(dir);
	}
	catch (e) {
		return e;
	}

	(function traverse(dir, stack) {
		stack.push(dir);
		fs.readdirSync(stack.join('/')).forEach(function(file) {
			var path = stack.concat([file]).join('/'),
				stat = fs.statSync(path);

			if (file[0] == '.' || file === 'vendor') {
				return;
			} else if (stat.isFile() && /\.js$/.test(file)) {
				paths.push(path);
			} else if (stat.isDirectory()) {
				paths.push(path);
				traverse(file, stack);
			}
		});
		stack.pop();
	})(dir || '.', []);

	return paths;
}