How to use

LenientConfiguration

in

org.gradle.api.artifacts

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));
}

@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()));
}

      .getResolvedConfiguration()
      .getLenientConfiguration()
      .getUnresolvedModuleDependencies();
  allArtifacts = configurationCopy.getResolvedConfiguration()
      .getLenientConfiguration()
      .getArtifacts(Specs.satisfyAll());
} else {
  allArtifacts = configurationCopy.getResolvedConfiguration()

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 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;
}

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);
    }
  }
}

/**
 * Create Eclipse annotations tasks
 *
 * @param tasks Task container
 * @param configurations Container to access configurations
 * @param buildDir Build directory
 */
@Mutate
public void createEclipseAnnotationsTasks(ModelMap<Task> tasks, ConfigurationContainer configurations,
    @Path("buildDir") File buildDir) {
  tasks.create("eclipseAnnotations", EclipseAnnotationsTask.class, t -> {
    t.setDescription("Generates external nullability annotations for dependencies.");
    t.setGroup("IDE");
    ConventionMapping parameters = t.getConventionMapping();
    parameters.map("jars", () -> {
      Set<File> jars = configurations.stream()
          .filter(c -> c.isCanBeResolved()
              && !c.getName().equals(JavaConfigPlugin.ANNOTATIONS_CONFIGURATION))
          .map(c -> c.getResolvedConfiguration().getLenientConfiguration())
          .flatMap(c -> c.getArtifacts().stream()
              .filter(a -> !(a.getId()
                  .getComponentIdentifier() instanceof ProjectComponentIdentifier)
                  && a.getType().equals("jar"))
              .map(a -> a.getFile()))
          .collect(Collectors.toSet());
      return jars;
    });
  });
}

/**
 * Create Eclipse annotations tasks
 *
 * @param tasks Task container
 * @param configurations Container to access configurations
 * @param buildDir Build directory
 */
@Mutate
public void createEclipseAnnotationsTasks(ModelMap<Task> tasks, ConfigurationContainer configurations,
    @Path("buildDir") File buildDir) {
  tasks.create("eclipseAnnotations", EclipseAnnotationsTask.class, t -> {
    t.setDescription("Generates external nullability annotations for dependencies.");
    t.setGroup("IDE");
    ConventionMapping parameters = t.getConventionMapping();
    parameters.map("jars", () -> {
      Set<File> jars = configurations.stream()
          .filter(c -> c.isCanBeResolved()
              && !c.getName().equals(JavaConfigPlugin.ANNOTATIONS_CONFIGURATION))
          .map(c -> c.getResolvedConfiguration().getLenientConfiguration())
          .flatMap(c -> c.getArtifacts().stream()
              .filter(a -> !(a.getId()
                  .getComponentIdentifier() instanceof ProjectComponentIdentifier)
                  && a.getType().equals("jar"))
              .map(a -> a.getFile()))
          .collect(Collectors.toSet());
      return jars;
    });
  });
}

private void executeCheckDependencyVersions(DependencyMap dependencyMap, Configuration cdvConfiguration,
    CheckDependencyVersionsReport report) {
  Set<ArtifactId> dependencyArtifactIds = dependencyMap.keySet().stream().map(DependencyKey::getArtifactId)
      .collect(Collectors.toSet());
  for (ArtifactId dependencyArtifactId : dependencyArtifactIds) {
    String dependencyArtifactIdString = dependencyArtifactId.toString();
    getProject().getLogger().info("Checking latest version for dependency {}...", dependencyArtifactIdString);
    String artifactDependencyString = dependencyArtifactIdString + ":+";
    Dependency artifactDependency = getProject().getDependencies().create(artifactDependencyString);
    cdvConfiguration.getDependencies().add(artifactDependency);
  }
  cdvConfiguration.resolutionStrategy(resolutionStrategy -> resolutionStrategy
      .componentSelection(componentSelectionRules -> componentSelectionRules
          .all(componentSelection -> filterComponentenSelection(dependencyMap, componentSelection))));
  LenientConfiguration resolvedCdvConfiguration = cdvConfiguration.getResolvedConfiguration()
      .getLenientConfiguration();
  Map<ArtifactId, ResolvedArtifact> resolvedArtifactsMap = buildResolvedArtifactsMap(
      resolvedCdvConfiguration.getArtifacts());
  evalDependencyVersions(dependencyMap, resolvedArtifactsMap, report);
}