Examples with IvyArtifactName org.gradle.internal.component.model.IvyArtifactName used on opensource projects

Example 31 with IvyArtifactName

use of org.gradle.internal.component.model.IvyArtifactName in project gradle by gradle.

the class DefaultArtifactMetadataSource method listModuleVersions.

@Override
public void listModuleVersions(ModuleDependencyMetadata dependency, ModuleIdentifier module, List<ResourcePattern> ivyPatterns, List<ResourcePattern> artifactPatterns, VersionLister versionLister, BuildableModuleVersionListingResolveResult result) {
    // List modules with missing metadata files
    IvyArtifactName dependencyArtifact = getPrimaryDependencyArtifact(dependency);
    versionLister.listVersions(module, dependencyArtifact, artifactPatterns, result);
}

Example 32 with IvyArtifactName

use of org.gradle.internal.component.model.IvyArtifactName in project gradle by gradle.

the class DefaultArtifactSet method toResolvedVariant.

public static ResolvedVariant toResolvedVariant(VariantResolveMetadata variant, ModuleVersionIdentifier ownerId, ModuleSources moduleSources, ExcludeSpec exclusions, ArtifactResolver artifactResolver, Map<ComponentArtifactIdentifier, ResolvableArtifact> allResolvedArtifacts, ImmutableAttributes variantAttributes, CalculatedValueContainerFactory calculatedValueContainerFactory) {
    List<? extends ComponentArtifactMetadata> artifacts = variant.getArtifacts();
    ImmutableSet.Builder<ResolvableArtifact> resolvedArtifacts = ImmutableSet.builder();
    boolean hasExcludedArtifact = false;
    for (ComponentArtifactMetadata artifact : artifacts) {
        IvyArtifactName artifactName = artifact.getName();
        if (exclusions.excludesArtifact(ownerId.getModule(), artifactName)) {
            hasExcludedArtifact = true;
            continue;
        }
        ResolvableArtifact resolvedArtifact = allResolvedArtifacts.get(artifact.getId());
        if (resolvedArtifact == null) {
            if (artifact.isOptionalArtifact()) {
                DefaultBuildableArtifactResolveResult result = new DefaultBuildableArtifactResolveResult();
                artifactResolver.resolveArtifact(artifact, moduleSources, result);
                if (!result.isSuccessful()) {
                    // Optional artifact is not available
                    continue;
                }
            }
            ValueCalculator<File> artifactCalculator;
            if (artifactResolver instanceof ProjectArtifactResolver) {
                artifactCalculator = ((ProjectArtifactResolver) artifactResolver).resolveArtifactLater(artifact);
            } else {
                // TODO - push this up to all ArtifactResolver implementations
                artifactCalculator = new LazyArtifactSupplier(artifact, moduleSources, artifactResolver);
            }
            CalculatedValue<File> artifactSource = calculatedValueContainerFactory.create(Describables.of(artifact.getId()), artifactCalculator);
            resolvedArtifact = new DefaultResolvableArtifact(ownerId, artifactName, artifact.getId(), context -> context.add(artifact.getBuildDependencies()), artifactSource, calculatedValueContainerFactory);
            allResolvedArtifacts.put(artifact.getId(), resolvedArtifact);
        }
        resolvedArtifacts.add(resolvedArtifact);
    }
    VariantResolveMetadata.Identifier identifier = variant.getIdentifier();
    if (hasExcludedArtifact) {
        // An ad hoc variant, has no identifier
        identifier = null;
    }
    return ArtifactBackedResolvedVariant.create(identifier, variant.asDescribable(), variantAttributes, withImplicitCapability(variant, ownerId), resolvedArtifacts.build());
}

Example 33 with IvyArtifactName

use of org.gradle.internal.component.model.IvyArtifactName in project gradle by gradle.

the class ModuleExclusions method forExclude.

private ExcludeSpec forExclude(ExcludeMetadata r) {
    return metadataToExcludeCache.computeIfAbsent(r, rule -> {
        // For custom ivy pattern matchers, don't inspect the rule any more deeply: this prevents us from doing smart merging later
        if (!PatternMatchers.isExactMatcher(rule.getMatcher())) {
            return factory.ivyPatternExclude(rule.getModuleId(), rule.getArtifact(), rule.getMatcher());
        }
        ModuleIdentifier moduleId = rule.getModuleId();
        IvyArtifactName artifact = rule.getArtifact();
        boolean anyOrganisation = isWildcard(moduleId.getGroup());
        boolean anyModule = isWildcard(moduleId.getName());
        // Build a strongly typed (mergeable) exclude spec for each supplied rule
        if (artifact == null) {
            if (!anyOrganisation && !anyModule) {
                return factory.moduleId(moduleId);
            } else if (!anyModule) {
                return factory.module(moduleId.getName());
            } else if (!anyOrganisation) {
                return factory.group(moduleId.getGroup());
            } else {
                return factory.everything();
            }
        } else {
            return factory.ivyPatternExclude(moduleId, artifact, rule.getMatcher());
        }
    });
}

Example 34 with IvyArtifactName

use of org.gradle.internal.component.model.IvyArtifactName in project gradle by gradle.

the class IvyBackedArtifactPublisher method publish.

public void publish(final Iterable<? extends PublicationAwareRepository> repositories, final Module module, final Configuration configuration, final File descriptor) throws PublishException {
    Set<ConfigurationInternal> allConfigurations = Cast.uncheckedCast(configuration.getAll());
    Set<ConfigurationInternal> configurationsToPublish = Cast.uncheckedCast(configuration.getHierarchy());
    if (descriptor != null) {
        // Convert once, in order to write the Ivy descriptor with _all_ configurations
        IvyModulePublishMetadata publishMetaData = toPublishMetaData(module, allConfigurations);
        validatePublishMetaData(publishMetaData);
        ivyModuleDescriptorWriter.write(publishMetaData, descriptor);
    }
    // Convert a second time with only the published configurations: this ensures that the correct artifacts are included
    BuildableIvyModulePublishMetadata publishMetaData = toPublishMetaData(module, configurationsToPublish);
    if (descriptor != null) {
        IvyArtifactName artifact = new DefaultIvyArtifactName("ivy", "ivy", "xml");
        publishMetaData.addArtifact(artifact, descriptor);
    }
    List<ModuleVersionPublisher> publishResolvers = new ArrayList<ModuleVersionPublisher>();
    for (PublicationAwareRepository repository : repositories) {
        ModuleVersionPublisher publisher = repository.createPublisher();
        publishResolvers.add(publisher);
    }
    dependencyPublisher.publish(publishResolvers, publishMetaData);
}

Example 35 with IvyArtifactName

use of org.gradle.internal.component.model.IvyArtifactName in project gradle by gradle.

the class ResourceVersionLister method newVisitor.

public VersionPatternVisitor newVisitor(final ModuleIdentifier module, final Collection<String> dest, final ResourceAwareResolveResult result) {
    return new VersionPatternVisitor() {

        final Set<ExternalResourceName> directories = new HashSet<ExternalResourceName>();

        public void visit(ResourcePattern pattern, IvyArtifactName artifact) throws ResourceException {
            ExternalResourceName versionListPattern = pattern.toVersionListPattern(module, artifact);
            LOGGER.debug("Listing all in {}", versionListPattern);
            try {
                List<String> versionStrings = listRevisionToken(versionListPattern);
                for (String versionString : versionStrings) {
                    dest.add(versionString);
                }
            } catch (Exception e) {
                throw ResourceExceptions.failure(versionListPattern.getUri(), String.format("Could not list versions using %s.", pattern), e);
            }
        }

        // lists all the values a revision token listed by a given url lister
        private List<String> listRevisionToken(ExternalResourceName versionListPattern) {
            String pattern = versionListPattern.getPath();
            if (!pattern.contains(REVISION_TOKEN)) {
                LOGGER.debug("revision token not defined in pattern {}.", pattern);
                return Collections.emptyList();
            }
            String prefix = pattern.substring(0, pattern.indexOf(REVISION_TOKEN));
            if (revisionMatchesDirectoryName(pattern)) {
                ExternalResourceName parent = versionListPattern.getRoot().resolve(prefix);
                return listAll(parent);
            } else {
                int parentFolderSlashIndex = prefix.lastIndexOf(fileSeparator);
                String revisionParentFolder = parentFolderSlashIndex == -1 ? "" : prefix.substring(0, parentFolderSlashIndex + 1);
                ExternalResourceName parent = versionListPattern.getRoot().resolve(revisionParentFolder);
                LOGGER.debug("using {} to list all in {} ", repository, revisionParentFolder);
                if (!directories.add(parent)) {
                    return Collections.emptyList();
                }
                result.attempted(parent);
                List<String> all = repository.list(parent.getUri());
                if (all == null) {
                    return Collections.emptyList();
                }
                LOGGER.debug("found {} urls", all.size());
                Pattern regexPattern = createRegexPattern(pattern, parentFolderSlashIndex);
                List<String> ret = filterMatchedValues(all, regexPattern);
                LOGGER.debug("{} matched {}", ret.size(), pattern);
                return ret;
            }
        }

        private List<String> filterMatchedValues(List<String> all, final Pattern p) {
            List<String> ret = new ArrayList<String>(all.size());
            for (String path : all) {
                Matcher m = p.matcher(path);
                if (m.matches()) {
                    String value = m.group(1);
                    ret.add(value);
                }
            }
            return ret;
        }

        private Pattern createRegexPattern(String pattern, int prefixLastSlashIndex) {
            int endNameIndex = pattern.indexOf(fileSeparator, prefixLastSlashIndex + 1);
            String namePattern;
            if (endNameIndex != -1) {
                namePattern = pattern.substring(prefixLastSlashIndex + 1, endNameIndex);
            } else {
                namePattern = pattern.substring(prefixLastSlashIndex + 1);
            }
            namePattern = namePattern.replaceAll("\\.", "\\\\.");
            String acceptNamePattern = namePattern.replaceAll("\\[revision\\]", "(.+)");
            return Pattern.compile(acceptNamePattern);
        }

        private boolean revisionMatchesDirectoryName(String pattern) {
            int startToken = pattern.indexOf(REVISION_TOKEN);
            if (startToken > 0 && !pattern.substring(startToken - 1, startToken).equals(fileSeparator)) {
                // previous character is not a separator
                return false;
            }
            int endToken = startToken + REV_TOKEN_LENGTH;
            if (endToken < pattern.length() && !pattern.substring(endToken, endToken + 1).equals(fileSeparator)) {
                // next character is not a separator
                return false;
            }
            return true;
        }

        private List<String> listAll(ExternalResourceName parent) {
            if (!directories.add(parent)) {
                return Collections.emptyList();
            }
            LOGGER.debug("using {} to list all in {}", repository, parent);
            result.attempted(parent.toString());
            List<String> paths = repository.list(parent.getUri());
            if (paths == null) {
                return Collections.emptyList();
            }
            LOGGER.debug("found {} resources", paths.size());
            return paths;
        }
    };
}