Examples with ProjectDependency org.gradle.api.artifacts.ProjectDependency used on opensource projects

Example 11 with ProjectDependency

use of org.gradle.api.artifacts.ProjectDependency in project gradle-eta by typelead.

the class EtaInjectDependencies method dependsOnProjects.

public void dependsOnProjects() {
    dependsOn(new Callable<List<Buildable>>() {

        @Override
        public List<Buildable> call() {
            return getProject().getConfigurations().getByName(getTargetConfiguration()).getAllDependencies().stream().filter(dependency -> dependency instanceof ProjectDependency).flatMap(dependency -> {
                final ProjectDependency projectDependency = (ProjectDependency) dependency;
                final Project project = projectDependency.getDependencyProject();
                final String configurationName = projectDependency.getTargetConfiguration();
                return ConfigurationUtils.getConfiguration(project, configurationName).getAllArtifacts().stream();
            }).collect(Collectors.toList());
        }
    });
}

Example 12 with ProjectDependency

use of org.gradle.api.artifacts.ProjectDependency in project gradle by gradle.

the class ModuleMetadataFileGenerator method writeDependency.

private void writeDependency(Dependency dependency, JsonWriter jsonWriter) throws IOException {
    jsonWriter.beginObject();
    if (dependency instanceof ProjectDependency) {
        ProjectDependency projectDependency = (ProjectDependency) dependency;
        ModuleVersionIdentifier identifier = projectDependencyResolver.resolve(ModuleVersionIdentifier.class, projectDependency);
        jsonWriter.name("group");
        jsonWriter.value(identifier.getGroup());
        jsonWriter.name("module");
        jsonWriter.value(identifier.getName());
        writeVersionConstraint(DefaultImmutableVersionConstraint.of(identifier.getVersion()), jsonWriter);
    } else {
        jsonWriter.name("group");
        jsonWriter.value(dependency.getGroup());
        jsonWriter.name("module");
        jsonWriter.value(dependency.getName());
        VersionConstraint vc;
        if (dependency instanceof ModuleVersionSelector) {
            vc = ((ExternalDependency) dependency).getVersionConstraint();
        } else {
            vc = DefaultImmutableVersionConstraint.of(Strings.nullToEmpty(dependency.getVersion()));
        }
        writeVersionConstraint(vc, jsonWriter);
    }
    if (dependency instanceof ModuleDependency) {
        writeExcludes((ModuleDependency) dependency, jsonWriter);
    }
    String reason = dependency.getReason();
    if (StringUtils.isNotEmpty(reason)) {
        jsonWriter.name("reason");
        jsonWriter.value(reason);
    }
    jsonWriter.endObject();
}

Example 13 with ProjectDependency

use of org.gradle.api.artifacts.ProjectDependency in project gradle by gradle.

the class DefaultMavenPublication method from.

public void from(SoftwareComponent component) {
    if (this.component != null) {
        throw new InvalidUserDataException(String.format("Maven publication '%s' cannot include multiple components", name));
    }
    this.component = (SoftwareComponentInternal) component;
    Set<ArtifactKey> seenArtifacts = Sets.newHashSet();
    Set<ModuleDependency> seenDependencies = Sets.newHashSet();
    Set<DependencyConstraint> seenConstraints = Sets.newHashSet();
    for (UsageContext usageContext : getSortedUsageContexts()) {
        // TODO Need a smarter way to map usage to artifact classifier
        for (PublishArtifact publishArtifact : usageContext.getArtifacts()) {
            ArtifactKey key = new ArtifactKey(publishArtifact.getFile(), publishArtifact.getClassifier(), publishArtifact.getExtension());
            if (seenArtifacts.add(key)) {
                artifact(publishArtifact);
            }
        }
        Set<MavenDependencyInternal> dependencies = dependenciesFor(usageContext.getUsage());
        for (ModuleDependency dependency : usageContext.getDependencies()) {
            if (seenDependencies.add(dependency)) {
                if (dependency instanceof ProjectDependency) {
                    addProjectDependency((ProjectDependency) dependency, dependencies);
                } else {
                    addModuleDependency(dependency, dependencies);
                }
            }
        }
        Set<MavenDependency> dependencyConstraints = dependencyConstraintsFor(usageContext.getUsage());
        for (DependencyConstraint dependency : usageContext.getDependencyConstraints()) {
            if (seenConstraints.add(dependency) && !dependency.getVersionConstraint().getPreferredVersion().isEmpty()) {
                addDependencyConstraint(dependency, dependencyConstraints);
            }
        }
    }
}

Example 14 with ProjectDependency

use of org.gradle.api.artifacts.ProjectDependency in project gradle by gradle.

the class DefaultMavenPublication method addDependencyConstraint.

private void addDependencyConstraint(DefaultProjectDependencyConstraint dependency, Set<MavenDependency> dependencies) {
    ProjectDependency projectDependency = dependency.getProjectDependency();
    ModuleVersionIdentifier identifier = projectDependencyResolver.resolve(ModuleVersionIdentifier.class, projectDependency);
    DefaultMavenDependency moduleDependency = new DefaultMavenDependency(identifier.getGroup(), identifier.getName(), identifier.getVersion());
    dependencies.add(new DefaultMavenProjectDependency(moduleDependency, projectDependency.getDependencyProject().getPath()));
}

Example 15 with ProjectDependency

use of org.gradle.api.artifacts.ProjectDependency in project gradle by gradle.

the class DefaultMavenPublication method populateFromComponent.

private void populateFromComponent() {
    if (populated) {
        return;
    }
    populated = true;
    if (component == null) {
        return;
    }
    MavenPublicationErrorChecker.checkForUnpublishableAttributes(component, documentationRegistry);
    PublicationWarningsCollector publicationWarningsCollector = new PublicationWarningsCollector(LOG, UNSUPPORTED_FEATURE, INCOMPATIBLE_FEATURE, PUBLICATION_WARNING_FOOTER, "suppressPomMetadataWarningsFor");
    Set<ArtifactKey> seenArtifacts = Sets.newHashSet();
    Set<PublishedDependency> seenDependencies = Sets.newHashSet();
    Set<DependencyConstraint> seenConstraints = Sets.newHashSet();
    for (UsageContext usageContext : getSortedUsageContexts()) {
        // TODO Need a smarter way to map usage to artifact classifier
        for (PublishArtifact publishArtifact : usageContext.getArtifacts()) {
            ArtifactKey key = new ArtifactKey(publishArtifact.getFile(), publishArtifact.getClassifier(), publishArtifact.getExtension());
            if (!artifactsOverridden && seenArtifacts.add(key)) {
                artifact(publishArtifact);
            }
        }
        Set<ExcludeRule> globalExcludes = usageContext.getGlobalExcludes();
        publicationWarningsCollector.newContext(usageContext.getName());
        Set<MavenDependencyInternal> dependencies = dependenciesFor(usageContext);
        for (ModuleDependency dependency : usageContext.getDependencies()) {
            if (seenDependencies.add(PublishedDependency.of(dependency))) {
                if (isDependencyWithDefaultArtifact(dependency) && dependencyMatchesProject(dependency)) {
                    // We skip all self referencing dependency declarations, unless they have custom artifact information
                    continue;
                }
                if (platformSupport.isTargetingPlatform(dependency)) {
                    if (dependency instanceof ProjectDependency) {
                        addImportDependencyConstraint((ProjectDependency) dependency);
                    } else {
                        if (!versionMappingInUse && isVersionMavenIncompatible(dependency.getVersion())) {
                            publicationWarningsCollector.addIncompatible(String.format("%s:%s:%s declared with a Maven incompatible version notation", dependency.getGroup(), dependency.getName(), dependency.getVersion()));
                        }
                        addImportDependencyConstraint(dependency);
                    }
                } else {
                    if (!dependency.getAttributes().isEmpty()) {
                        publicationWarningsCollector.addUnsupported(String.format("%s:%s:%s declared with Gradle attributes", dependency.getGroup(), dependency.getName(), dependency.getVersion()));
                    }
                    if (dependency instanceof ProjectDependency) {
                        addProjectDependency((ProjectDependency) dependency, globalExcludes, dependencies);
                    } else {
                        if (!versionMappingInUse && isVersionMavenIncompatible(dependency.getVersion())) {
                            publicationWarningsCollector.addIncompatible(String.format("%s:%s:%s declared with a Maven incompatible version notation", dependency.getGroup(), dependency.getName(), dependency.getVersion()));
                        }
                        addModuleDependency(dependency, globalExcludes, dependencies);
                    }
                }
            }
        }
        Set<MavenDependency> dependencyConstraints = dependencyConstraintsFor(usageContext);
        for (DependencyConstraint dependency : usageContext.getDependencyConstraints()) {
            if (seenConstraints.add(dependency)) {
                if (dependency instanceof DefaultProjectDependencyConstraint) {
                    addDependencyConstraint((DefaultProjectDependencyConstraint) dependency, dependencyConstraints);
                } else if (dependency.getVersion() != null) {
                    if (!versionMappingInUse && isVersionMavenIncompatible(dependency.getVersion())) {
                        publicationWarningsCollector.addIncompatible(String.format("constraint %s:%s:%s declared with a Maven incompatible version notation", dependency.getGroup(), dependency.getName(), dependency.getVersion()));
                    }
                    addDependencyConstraint(dependency, dependencyConstraints);
                }
            }
        }
        if (!usageContext.getCapabilities().isEmpty()) {
            for (Capability capability : usageContext.getCapabilities()) {
                if (isNotDefaultCapability(capability)) {
                    publicationWarningsCollector.addVariantUnsupported(String.format("Declares capability %s:%s:%s which cannot be mapped to Maven", capability.getGroup(), capability.getName(), capability.getVersion()));
                }
            }
        }
    }
    if (!silenceAllPublicationWarnings) {
        publicationWarningsCollector.complete(getDisplayName() + " pom metadata", silencedVariants);
    }
}