private void unregisterUnresolvedDependenciesAnalyzer(Project project) { UnresolvedDependenciesAnalyzer unresolvedDependenciesAnalyzer = new UnresolvedDependenciesAnalyzer(); project.getConfigurations().all((configuration) -> { ResolvableDependencies incoming = configuration.getIncoming(); incoming.afterResolve((resolvableDependencies) -> { if (incoming.equals(resolvableDependencies)) { unresolvedDependenciesAnalyzer.analyze(configuration .getResolvedConfiguration().getLenientConfiguration() .getUnresolvedModuleDependencies()); } }); }); project.getGradle().buildFinished( (buildResult) -> unresolvedDependenciesAnalyzer.buildFinished(project)); }
public void setupBuckBinary() { OkBuckExtension okbuckExt = ProjectUtil.getOkBuckExtension(rootProject); // Create dependency cache for buck binary if needed if (okbuckExt.buckBinary != null) { Configuration buckConfig = rootProject.getConfigurations().maybeCreate(BUCK_BINARY_CONFIGURATION); rootProject .getRepositories() .maven(mavenArtifactRepository -> mavenArtifactRepository.setUrl(JITPACK_URL)); rootProject.getDependencies().add(BUCK_BINARY_CONFIGURATION, okbuckExt.buckBinary); Set<File> resolvedFiles = buckConfig.getResolvedConfiguration().getFiles(); Preconditions.checkArgument(resolvedFiles.size() == 1); realBuckBinaryPath = resolvedFiles.iterator().next().toPath(); } }
protected Properties getThinProperties(Configuration configuration) { Properties properties = new Properties(); // TODO: add computed flag to task and offer option not to compute transitives properties.setProperty("computed", "true"); if (configuration != null) { for (ResolvedArtifact artifact : configuration.getResolvedConfiguration() .getResolvedArtifacts()) { properties.setProperty("dependencies." + key(artifact, properties), coordinates(artifact, true)); } } return properties; }
private void collectArtifacts( Configuration configuration, Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts) { Set<ResolvedArtifact> allArtifacts; if (extraModelInfo.getMode() != STANDARD) { allArtifacts = configuration.getResolvedConfiguration().getLenientConfiguration().getArtifacts( Specs.satisfyAll()); } else { allArtifacts = configuration.getResolvedConfiguration().getResolvedArtifacts(); } for (ResolvedArtifact artifact : allArtifacts) { ModuleVersionIdentifier id = artifact.getModuleVersion().getId(); List<ResolvedArtifact> moduleArtifacts = artifacts.get(id); if (moduleArtifacts == null) { moduleArtifacts = Lists.newArrayList(); artifacts.put(id, moduleArtifacts); } if (!moduleArtifacts.contains(artifact)) { moduleArtifacts.add(artifact); } } }
private List<JApiCmpWorkerAction.Archive> inferArchives(FileCollection fc) { if (fc instanceof Configuration) { final List<JApiCmpWorkerAction.Archive> archives = new ArrayList<>(); Set<ResolvedDependency> firstLevelModuleDependencies = ((Configuration) fc).getResolvedConfiguration().getFirstLevelModuleDependencies(); for (ResolvedDependency moduleDependency : firstLevelModuleDependencies) { collectArchives(archives, moduleDependency); } return archives; } return toArchives(fc); }
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(); }
@NonNull public Set<File> resolveAndGetJackPluginClassPath( @NonNull ErrorReporter errorReporter) { if (getJackPluginConfiguration().getAllDependencies().isEmpty()) { return Collections.emptySet(); } ResolvedConfiguration resolvedConfiguration = getJackPluginConfiguration().getResolvedConfiguration(); if (resolvedConfiguration.hasError()) { try { resolvedConfiguration.rethrowFailure(); } catch (Exception e) { errorReporter.handleSyncError( "jackPlugin", SyncIssue.TYPE_UNRESOLVED_DEPENDENCY, "Unable to find Jack plugin. " + e.getMessage()); return Collections.emptySet(); } } return getJackPluginConfiguration().getFiles(); }
compileClasspath.getResolvedConfiguration().hasError()) { for (String dependency : currentUnresolvedDependencies) { extraModelInfo.handleSyncError(
/** * For the given "resolved configuration" (all of the artifacts in a Gradle Configuration, such as "compile"), * return all of the bundle symbolic names in the bundles. */ private List<String> symbolicNames(ResolvedConfiguration resolvedConfiguration) { return symbolicNames(project.files(resolvedConfiguration.getResolvedArtifacts())); }
configuration .getResolvedConfiguration() .getLenientConfiguration() .getUnresolvedModuleDependencies(); allArtifacts = configuration.getResolvedConfiguration().getResolvedArtifacts(); } else { if (!repositoriesUpdated && sdkLibData.useSdkDownload()) { .getLenientConfiguration() .getArtifacts(Specs.satisfyAll()); } else { allArtifacts = configurationCopy.getResolvedConfiguration() .getResolvedArtifacts();
@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); }
private Configuration createTemporaryConfiguration(Dependency dependency, String artifactLabel) { Configuration config = configurations.detachedConfiguration( dependency ); //parentConfiguration.ifPresent( c -> config.setExtendsFrom( Collections.singletonList( c ) ) ); config.setTransitive( false ); config.setVisible( false ); config.setDescription( "Generated configuration to resolve '" + artifactLabel + "' on behalf of the WildFly Provisioning plugin" ); //This next line actually resolves it (Attempts to download dependencies): final ResolvedConfiguration resolvedConfiguration = config.getResolvedConfiguration(); if ( resolvedConfiguration.hasError() ) { //In case of error, user is likely not having the JBoss Nexus repository enabled. //Attempt configuration correction: if ( autoAddRepositories && repositoriesAutomaticallyAdded == false ) { repositoriesAutomaticallyAdded = true; addDefaultRepositories( artifactLabel ); //And retry: return createTemporaryConfiguration( dependency, artifactLabel ); } else { resolvedConfiguration.rethrowFailure(); } } return config; }
compileClasspath.getResolvedConfiguration().hasError()) { for (String dependency : currentUnresolvedDependencies) { extraModelInfo.handleSyncError(
private static Collection<ResolvedArtifact> mainClassPath(Project p, String confName, boolean fail) { Configuration conf = p.getConfigurations().getByName(confName); if (conf == null) { if (fail) { throw new GradleException("Cannot find " + confName + " configuration for project " + p); } return Collections.emptyList(); } return conf.getResolvedConfiguration().getResolvedArtifacts(); }
@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 List<Pom> resolvePomsLeniently(List<PomReference> pomReferences) { return createPoms(createConfiguration(pomReferences).getResolvedConfiguration().getLenientConfiguration() .getArtifacts(Specs.SATISFIES_ALL), pomReferences, new MapPropertySource(Collections.<String, Object>emptyMap())); }
if (resolvedConfiguration.hasError()) { try { resolvedConfiguration.rethrowFailure(); } catch (Exception e) { errorReporter.handleSyncError(
protected Optional<String> getPayaraMicroPath(String version) { DependencyHandler dependencyHandler = project.getDependencies(); Dependency dependency = dependencyHandler.create(MICRO_GROUPID + ":" + MICRO_ARTIFACTID + ":" + version); return project.getConfigurations() .detachedConfiguration(dependency) .getResolvedConfiguration() .getFiles() .stream() .findAny() .map(File::getAbsolutePath); }
/** * Resolve all buildscript dependencies of this project and it's subprojects. * * @return All resolved buildscript dependencies. */ protected List<DependencyIdentifier> resolveBuildDependencies() { return getProject().getAllprojects().stream() // .map(project -> project.getBuildscript().getConfigurations().getByName(ScriptHandler.CLASSPATH_CONFIGURATION).getResolvedConfiguration()) // .flatMap(confguration -> confguration.getResolvedArtifacts().stream()) // .map(resolvedArtifact -> resolvedArtifact.getModuleVersion().getId()) // .map(DependencyIdentifier::new) // .distinct() // .filter(this::filterIgnoredDependencies) // .sorted(new DependencyIdentifierComparator()) // .collect(Collectors.toList()); }
.getByName("compile") .getResolvedConfiguration() .getFirstLevelModuleDependencies() .forEach(d -> walk(true, d));