All of the artifact paths for this resolve point to existing files.
964916
def all_linked_artifacts_exist(self):
    """"""
    if not self.has_resolved_artifacts:
      return False
    for path in self.resolved_artifact_paths:
      if not os.path.isfile(path):
        return False
    else:
      return True
707293
def absolute_info_plist_paths
      info_plist_paths.map do |path|
        absolute_project_file_path(path)
      end.select do |path|
        if path.to_s.include?('$')
          warn "Couldn't resolve all placeholders in INFOPLIST_FILE %s.", path.to_s
          false
        else
          true
        end
      end
    end
589075
function resolve(files, opts) {
  var fn = opts.filter || function(fp) {
    return true;
  };

  if (opts.realpath === true) {
    return files.filter(fn);
  }

  var len = files.length;
  var idx = -1;
  var res = [];

  while (++idx < len) {
    var fp = path.resolve(opts.cwd, files[idx]);
    if (!fn(fp) || ~res.indexOf(fp)) continue;
    res.push(fp);
  }
  return res;
}
359294
function resolveImportPaths(filePath, importPaths){
  var dir = path.dirname(filePath);
  return importPaths.map(function(relativePath){
    if(!path.extname(relativePath)){
      relativePath += '.less';
    }
    return path.resolve(dir, relativePath);
  });
}
232452
def update_files paths, matcher, currentVersion, nextVersion
      paths.each do |path|
        update_file path, matcher, currentVersion, nextVersion
      end
    end
614435
public Optional<List<Path>> retrieveArtifactPaths() {
        if (artifactPaths.isEmpty()) {
            return Optional.absent();
        } else {
            return Optional.of(artifactPaths);
        }
    }
955227
public void flattenPackagesSourcesAndArtifacts(Map<String,Module> m) {
        modules = m;
        // Extract all the found packages.
        for (Module i : modules.values()) {
            for (Map.Entry<String,Package> j : i.packages().entrySet()) {
                Package p = packages.get(j.getKey());
                // Check that no two different packages are stored under same name.
                assert(p == null || p == j.getValue());
                if (p == null) {
                    p = j.getValue();
                    packages.put(j.getKey(),j.getValue());
                }
                for (Map.Entry<String,Source> k : p.sources().entrySet()) {
                    Source s = sources.get(k.getKey());
                    // Check that no two different sources are stored under same name.
                    assert(s == null || s == k.getValue());
                    if (s == null) {
                        s = k.getValue();
                        sources.put(k.getKey(), k.getValue());
                    }
                }
                for (Map.Entry<String,File> g : p.artifacts().entrySet()) {
                    File f = artifacts.get(g.getKey());
                    // Check that no two artifacts are stored under the same file.
                    assert(f == null || f == g.getValue());
                    if (f == null) {
                        f = g.getValue();
                        artifacts.put(g.getKey(), g.getValue());
                    }
                }
            }
        }
    }
316661
protected function taskArtifactCreatePackages()
    {
        $rootDir      = getcwd();
        $tarBin       = $this->config(Config::KEY_ENV . '/' . Config::KEY_TAR_BIN);
        $gitDir       = $this->config(Config::KEY_DEPLOY . '/' . Config::KEY_GIT_DIR);
        $artifactsDir = $this->config(Config::KEY_DEPLOY . '/' . Config::KEY_ARTIFACTS_DIR);

        /** @var array $artifacts */
        $artifacts = $this->config(Config::KEY_DEPLOY . '/' . Config::KEY_ARTIFACTS);

        /** @var RoboFile|CollectionBuilder $collection */
        $collection = $this->collectionBuilder();
        $collection->progressMessage('cleanup old packages');

        // Ensure artifacts-dir is present
        $collection->taskFilesystemStack()->mkdir($artifactsDir);

        // Cleanup old tars
        foreach ($artifacts as $artifactName => $artifactConfig) {
            $file = "$artifactsDir/$artifactName";

            $task = $collection->taskFilesystemStack();
            $task->remove($file);
        }

        // Create Tars
        $collection->progressMessage('creating packages');
        foreach ($artifacts as $artifactName => $artifactConfig) {
            $dir = $artifactConfig['dir'];

            $artifactPath = "$rootDir/$artifactsDir/$artifactName";

            $tarOptions = '';
            if (array_key_exists('options', $artifactConfig)) {
                $options    = $artifactConfig['options'];
                $tarOptions = implode(' ', $options);
            }

            $tarCmd = "$tarBin $tarOptions -czf $artifactPath $dir";
            $task   = $collection->taskExec($tarCmd);
            $task->dir($gitDir);
        }

        return $collection;
    }
770420
def qualified_files(self, absolute=True):
        """"""
        prefix = self.get_directory() if absolute else "."
        for rel_dir_name, file_name in self.files():
            yield os.path.join(prefix, rel_dir_name, file_name)
410325
def download_artifacts( notations )
      if( notations.is_a? String )
        notations = [notations]
      end

      files = nil
      if Naether.platform == 'java'
        files = @resolver.downloadArtifacts( notations )
      else
        list = Naether::Java.convert_to_java_list( notations )
        files = @resolver._invoke('downloadArtifacts', 'Ljava.util.List;', list)
      end

      paths = []
      Naether::Java.convert_to_ruby_array(files).each do |file|
        paths << file.getAbsolutePath();
      end

      paths
    end
609328
def all_exist(filepaths):
  """"""
  for fname in filepaths:
    if not tf.gfile.Exists(fname):
      return False
  return True
1244532
private void collectPaths(ArtifactContainer c, Set<String> s) {
        if (!"/".equals(c.getPath())) {
            s.add(c.getPath());
        }
        for (ArtifactEntry e : c) {
            s.add(e.getPath());
            ArtifactContainer n = e.convertToContainer();
            if (n != null && !n.isRoot()) {
                collectPaths(n, s);
            }
        }
    }
838666
function resolve() {
    var resolvedPath = '';
    var resolvedAbsolute = false;
    var hasDomain = false;

    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i -= 1) {
      var p = (i >= 0) ? arguments[i] : !hasDomain ? cwd() : '';

      if (!hasDomain) {
        hasDomain = isDomain(p);
      }

      if (!isString(p)) {
        throw new TypeError('Arguments to path.resolve must be strings');
      } else if (!p) {
        continue;
      }

      resolvedPath = p + '/' + resolvedPath;
      resolvedAbsolute = p[0] === '/';
    }

    resolvedPath = normalizeArray(resolvedPath.split('/'), !resolvedAbsolute).join('/');
    return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
  }
202149
function resolveNewPath(newBase) {
    return mapSync(file => {
      file.cwd += newBase;
      file.base = file.cwd;
      return file;
    });
  }
342378
function buildDependencyPaths(self, context) {
  var dependencies = {};

  context.__dependencyPaths__.forEach(function (p) {
    var dep = new DependencyFile(p, self.environment.stat(p).mtime,
                                 self.environment.getFileDigest(p));
    dependencies[JSON.stringify(dep)] = dep;
  });

  _.forEach(context.__dependencyAssets__, function (p) {
    var dep, asset;

    if (p === self.pathname) {
      dep = new DependencyFile(p, self.environment.stat(p).mtime,
                               self.environment.getFileDigest(p));
      dependencies[JSON.stringify(dep)] = dep;
      return;
    }

    asset = self.environment.findAsset(p, { bundle: false });

    if (asset) {
      asset.dependencyPaths.forEach(function (dep) {
        dependencies[JSON.stringify(dep)] = dep;
      });
    }
  });

  prop(self, '__dependencyPaths__', _.values(dependencies));
}
1209468
def get_source_files(target, build_context) -> list:
    """"""
    all_sources = list(target.props.sources)
    for proto_dep_name in target.props.protos:
        proto_dep = build_context.targets[proto_dep_name]
        all_sources.extend(proto_dep.artifacts.get(AT.gen_cc).keys())
    return all_sources
524582
function resolve(path, root, resolver) {
  try {
    // Add a default value to each path part lacking a prefix.
    let nspath = path.replace(/\/(?!\.)([^\/:\(]+)(?=\/|$)/g, '/_default_:$1')
    return platformResolve(nspath, root, resolver)
  } catch (err) {
    return fallbackResolve(path, root)
  }
}