private void collectArchives(final List<JApiCmpWorkerAction.Archive> archives, ResolvedDependency resolvedDependency) { String version = resolvedDependency.getModule().getId().getVersion(); archives.add(new JApiCmpWorkerAction.Archive(resolvedDependency.getAllModuleArtifacts().iterator().next().getFile(), version)); for (ResolvedDependency dependency : resolvedDependency.getChildren()) { collectArchives(archives, dependency); } }
Dependency(final ResolvedDependency dep) { this.group = dep.getModuleGroup(); this.name = dep.getModuleName(); this.version = dep.getModuleVersion(); }
private void walk(final boolean top, ResolvedDependency dep) { Set<ResolvedArtifact> artifacts = dep.getModuleArtifacts(); for (ResolvedArtifact each : artifacts) { String[] parts = dep.getName().split(":"); String groupId = parts[0]; String artifactId = parts[1]; String version = parts[2]; this.tool.dependency("compile", groupId, artifactId, version, each.getExtension(), each.getClassifier(), each.getFile(), top); } dep.getChildren().forEach(d -> walk(false, d)); } }
@Override public Set<ArtifactSpec> resolveAll(final Set<ArtifactSpec> specs) throws Exception { if (specs.isEmpty()) { return specs; } final Set<ArtifactSpec> resolvedSpecs = new HashSet<>(); doResolve(specs).forEach(dep -> dep.getAllModuleArtifacts() .forEach(artifact -> resolvedSpecs .add(new ArtifactSpec(dep.getConfiguration(), dep.getModuleGroup(), artifact.getName(), dep.getModuleVersion(), artifact.getExtension(), artifact.getClassifier(), artifact.getFile())))); return resolvedSpecs.stream() .filter(a -> !"system".equals(a.scope)) .collect(Collectors.toSet()); }
@TaskAction public void writeOutPinnedFile() throws IOException { File pinnedFile = getPinnedFile(); if (pinnedFile.exists()) { pinnedFile.delete(); } pinnedFile.createNewFile(); // Only add "soft pins" for the *direct* dependencies, so that we don't // burn in assumptions about our transitive dependency tree to the output // source artifact. StringBuilder contents = new StringBuilder(); for (ResolvedDependency r : getPythonConfiguration().getResolvedConfiguration().getFirstLevelModuleDependencies()) { logger.info("Pinning {}=={}", r.getModuleName(), r.getModuleVersion()); contents.append(r.getModuleName()) .append("==") .append(r.getModuleVersion()) .append(System.getProperty("line.separator")); //moduleName==moduleVersion\n } FileUtils.write(pinnedFile, contents); }
@Override public ArtifactSpec resolve(final ArtifactSpec spec) { if (spec.file != null) { return spec; } final Iterator<ResolvedDependency> iterator = doResolve(new HashSet<>(Collections.singletonList(spec))).iterator(); if (iterator.hasNext()) { spec.file = iterator.next() .getModuleArtifacts() .iterator().next() .getFile(); return spec; } return null; }
private static Set<ResolvedDependency> gatherDependencies(Set<ResolvedDependency> deps) { Set<ResolvedDependency> result = Sets.newHashSet(deps); for (ResolvedDependency dep : deps) { result.addAll(gatherDependencies(dep.getChildren())); } return result; } }
public String getArtifactWithVersion(String groupId, String artifactId, String configurationName) { final ResolvedConfiguration resolvedConfiguration = configurations.getByName( configurationName ).getResolvedConfiguration(); resolvedConfiguration.rethrowFailure(); final LenientConfiguration lenientConfiguration = resolvedConfiguration.getLenientConfiguration(); final Optional<ResolvedDependency> dependency = lenientConfiguration. getFirstLevelModuleDependencies( d -> ( d.getGroup().equals( groupId ) && d.getName().equals( artifactId ) ) ) .stream() .findFirst(); return dependency.get().getModuleVersion(); }
@TaskAction public void writeOutPinnedFile() throws IOException { File pinnedFile = getPinnedFile(); if (pinnedFile.exists()) { pinnedFile.delete(); } pinnedFile.createNewFile(); // Only add "soft pins" for the *direct* dependencies, so that we don't // burn in assumptions about our transitive dependency tree to the output // source artifact. StringBuilder contents = new StringBuilder(); for (ResolvedDependency r : getPythonConfiguration().getResolvedConfiguration().getFirstLevelModuleDependencies()) { logger.info("Pinning {}=={}", r.getModuleName(), r.getModuleVersion()); contents.append(r.getModuleName()) .append("==") .append(r.getModuleVersion()) .append(System.getProperty("line.separator")); //moduleName==moduleVersion\n } FileUtils.write(pinnedFile, contents); }
static Set<PackageManifest> gatherManifests(Set<ResolvedDependency> deps) { Set<PackageManifest> manifests = Sets.newHashSet(); for (ResolvedDependency dep : deps) { File manifest = null; File unitypackage = null; for (ResolvedArtifact art : dep.getModuleArtifacts()) { if (art.getExtension().equals("manifest")) { manifest = art.getFile(); } else if (art.getExtension().equals("unitypackage")) { unitypackage = art.getFile(); } } if (null != manifest && null != unitypackage) { PackageManifest p = PackageManifest.load(manifest); p.setUnityPackage(unitypackage); manifests.add(p); } else { logger.error("Malformed package", manifest, unitypackage); } } return manifests; }
private static Set<ResolvedDependency> gatherDependencies(Set<ResolvedDependency> deps) { Set<ResolvedDependency> result = Sets.newHashSet(deps); for (ResolvedDependency dep : deps) { result.addAll(gatherDependencies(dep.getChildren())); } return result; } }
private static DependencyOverwrites collectDependenciesToOverwrite(final Configuration compileClasspath, final Configuration testCompile, final XRepoConfiguration config, final Project project) { final Configuration groupDeps = dependenciesWithinProjectGroup(testCompile, project); debug(project, "Found {} dependencies with group {}", groupDeps.getAllDependencies().size(), project.getGroup()); useSuffixedVersions(groupDeps, config, project); final DependencyOverwrites result = new DependencyOverwrites(); compileClasspath.getIncoming().beforeResolve((deps) -> { groupDeps.getResolvedConfiguration().getLenientConfiguration().getAllModuleDependencies().forEach(dep -> { if (isInSameGroup(dep.getModuleGroup(), project)) { debug(project, "Found overwritten dependency {}:{}:{}", dep.getModuleGroup(), dep.getModuleName(), dep.getModuleVersion()); result.add(dep); } }); }); return result; }
static Set<PackageManifest> gatherManifests(Set<ResolvedDependency> deps) { Set<PackageManifest> manifests = Sets.newHashSet(); for (ResolvedDependency dep : deps) { File manifest = null; File unitypackage = null; for (ResolvedArtifact art : dep.getModuleArtifacts()) { if (art.getExtension().equals("manifest")) { manifest = art.getFile(); } else if (art.getExtension().equals("unitypackage")) { unitypackage = art.getFile(); } } if (null != manifest && null != unitypackage) { PackageManifest p = PackageManifest.load(manifest); p.setUnityPackage(unitypackage); manifests.add(p); } else { logger.error("Malformed package", manifest, unitypackage); } } return manifests; }
private static Set<ResolvedDependency> gatherDependencies(Set<ResolvedDependency> deps) { Set<ResolvedDependency> result = Sets.newHashSet(deps); for (ResolvedDependency dep : deps) { result.addAll(gatherDependencies(dep.getChildren())); } return result; } }
static Set<PackageManifest> gatherManifests(Set<ResolvedDependency> deps) { Set<PackageManifest> manifests = Sets.newHashSet(); for (ResolvedDependency dep : deps) { File manifest = null; File unityZip = null; for (ResolvedArtifact art : dep.getModuleArtifacts()) { if (art.getExtension().equals("manifest")) { manifest = art.getFile(); } else if (art.getExtension().equals("zip")) { unityZip = art.getFile(); } } if (null != manifest && null != unityZip) { PackageManifest p = PackageManifest.load(manifest); p.setUnityPackage(unityZip); manifests.add(p); } else { logger.error("Malformed package", manifest, unityZip); } } return manifests; }