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(); } }
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)); }
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 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(); }
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); }
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); }
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(); }
private Set<GradleLibrary> getLibraries(String configurationName, LibraryScope scope) { Configuration configuration = (configurationName == null ? null : this.project.getConfigurations().findByName(configurationName)); if (configuration == null) { return null; } Set<GradleLibrary> libraries = new LinkedHashSet<GradleLibrary>(); for (ResolvedArtifact artifact : configuration.getResolvedConfiguration().getResolvedArtifacts()) { libraries.add(new ResolvedArtifactLibrary(artifact, scope)); } libraries.addAll(getLibrariesForFileDependencies(configuration, scope)); return libraries; }
@Override public List<Pom> resolvePoms(List<PomReference> pomReferences, PropertySource properties) { return createPoms(createConfiguration(pomReferences).getResolvedConfiguration().getResolvedArtifacts(), pomReferences, properties); }
/** * Calls {@link CqPackageHelper#validateAllBundles(Collection, SlingSupport)} for * each server in {@link SlingServersConfiguration} and all the bundles in the configuration * * @param configuration the Gradle Configuration such as "compile" to retrieve the list of bundles from * @return HTTP_INTERNAL_ERROR if there are inactive bundles, otherwise the "aggregate" HTTP response: if all * the calls are in the >= 200 and <400 range, or a 408 (timeout, server not running) the returns an empty HTTP_OK; * otherwise returns the first error response it came across */ public HttpResponse validateBundles(Configuration configuration) { ResolvedConfiguration resolvedConfiguration = configuration.getResolvedConfiguration(); final List<String> symbolicNamesList = symbolicNames(resolvedConfiguration); return doAcrossServers(false, slingSupport -> validateAllBundles(symbolicNamesList, slingSupport)); }
@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())); }
@Override public InputStream getInputStream() throws Exception { // create a temporary configuration to resolve the file Configuration conf = project.getConfigurations().detachedConfiguration( project.getDependencies().create(dependencyNotation)); ResolvedArtifact artifactId = conf.getResolvedConfiguration().getResolvedArtifacts().iterator().next(); logger.info("Selected recommendation source " + artifactId.getId() + ", you requested " + dependencyNotation); return new FileInputStream(artifactId.getFile()); } };
private void addConfigurationArtifacts(String[] configurations, Set<URL> urls) throws IOException { for (String configuration : configurations) { getLogger().debug("Adding configuration to classpath: " + configuration); ResolvedConfiguration resolvedConfiguration = getProject().getConfigurations().getByName(configuration).getResolvedConfiguration(); for (ResolvedArtifact artifact : resolvedConfiguration.getResolvedArtifacts()) { URL artifactUrl = artifact.getFile().toURI().toURL(); getLogger().debug("Adding artifact to classpath: " + artifactUrl); urls.add(artifactUrl); } } }
@Test public void testGetResolvedArtifacts_returnArtifact() { Set<ResolvedArtifact> artifactSet = (Set<ResolvedArtifact>) mock(Set.class); ResolvedConfiguration resolvedConfiguration = mock(ResolvedConfiguration.class); when(resolvedConfiguration.getResolvedArtifacts()).thenReturn(artifactSet); Configuration configuration = mock(Configuration.class); when(configuration.getName()).thenReturn("compile"); when(configuration.isCanBeResolved()).thenReturn(true); when(configuration.getResolvedConfiguration()).thenReturn(resolvedConfiguration); assertThat(dependencyTask.getResolvedArtifacts(configuration), is(artifactSet)); }
@Test public void testAddArtifacts() { ResolvedConfiguration resolvedConfiguration = spy(ResolvedConfiguration.class); Set<ResolvedArtifact> artifacts = preppareArtifactSet(3); when(resolvedConfiguration.getResolvedArtifacts()).thenReturn(artifacts); Configuration configuration = mock(Configuration.class); when(configuration.isCanBeResolved()).thenReturn(true); when(configuration.getName()).thenReturn("compile"); when(configuration.getResolvedConfiguration()).thenReturn(resolvedConfiguration); dependencyTask.addArtifacts(artifacts); assertThat(dependencyTask.artifactInfos.size(), is(3)); }
@Test public void testGetResolvedArtifacts_ResolveException() { ResolvedConfiguration resolvedConfiguration = mock(ResolvedConfiguration.class); when(resolvedConfiguration.getResolvedArtifacts()).thenThrow(ResolveException.class); Configuration configuration = mock(Configuration.class); when(configuration.getName()).thenReturn("compile"); when(configuration.isCanBeResolved()).thenReturn(true); when(configuration.getResolvedConfiguration()).thenReturn(resolvedConfiguration); assertThat(dependencyTask.getResolvedArtifacts(configuration), is(nullValue())); }
@InputFiles @SuppressWarnings("unused") // lets Gradle know when to not skip the task public FileCollection getDependencyFiles() { return getProject().files(getConfiguration().getResolvedConfiguration().getFiles()); }
@Test public void testAddArtifacts_willNotAddDuplicate() { ResolvedConfiguration resolvedConfiguration = spy(ResolvedConfiguration.class); Set<ResolvedArtifact> artifacts = preppareArtifactSet(2); when(resolvedConfiguration.getResolvedArtifacts()).thenReturn(artifacts); Configuration configuration = mock(Configuration.class); when(configuration.isCanBeResolved()).thenReturn(true); when(configuration.getName()).thenReturn("compile"); when(configuration.getResolvedConfiguration()).thenReturn(resolvedConfiguration); String[] keySets = new String[] {"location1", "location2"}; dependencyTask.artifactSet = new HashSet<>(Arrays.asList(keySets)); dependencyTask.addArtifacts(artifacts); assertThat(dependencyTask.artifactInfos.size(), is(1)); }
private void addConfigurationArtifacts(String[] configurations, Set<URL> urls) throws IOException { getLogger().debug("running: addConfigurationArtifacts()"); for (String configuration : configurations) { getLogger().debug("Adding configuration to classpath: " + configuration); ResolvedConfiguration resolvedConfiguration = getProject().getConfigurations().getByName(configuration).getResolvedConfiguration(); for (ResolvedArtifact artifact : resolvedConfiguration.getResolvedArtifacts()) { URL artifactUrl = artifact.getFile().toURI().toURL(); getLogger().debug("Adding artifact to classpath: " + artifactUrl); urls.add(artifactUrl); } } }
private void addGosuRuntimeDependencies() { Set<ResolvedArtifact> buildScriptDeps = _project.getBuildscript().getConfigurations().getByName("classpath").getResolvedConfiguration().getResolvedArtifacts(); ResolvedArtifact gosuCore = GosuPlugin.getArtifactWithName("gosu-core", buildScriptDeps); ResolvedArtifact gosuCoreApi = GosuPlugin.getArtifactWithName("gosu-core-api", buildScriptDeps); //inject Gosu jar dependencies into the classpath of the project implementing this plugin _project.getDependencies().add("runtime", gosuCore.getModuleVersion().getId().toString()); _project.getDependencies().add("compile", gosuCoreApi.getModuleVersion().getId().toString()); }