org.apache.ivy.plugins.parser.ParserSettings Java Examples

ModuleDescriptor getFromCache(File ivyFile, ParserSettings ivySettings, boolean validated) {
    if (maxSize <= 0) {
        // cache is disabled
        return null;
    }
    synchronized (valueMap) {
        CacheEntry entry = valueMap.get(ivyFile);
        if (entry != null) {
            if (entry.isStale(ivyFile, validated, ivySettings)) {
                Message.debug("Entry is found in the ModuleDescriptorCache but entry should be "
                        + "reevaluated : " + ivyFile);
                valueMap.remove(ivyFile);
                return null;
            } else {
                // Move the entry at the end of the list
                valueMap.remove(ivyFile);
                valueMap.put(ivyFile, entry);
                Message.debug("Entry is found in the ModuleDescriptorCache : " + ivyFile);
                return entry.md;
            }
        } else {
            Message.debug("No entry is found in the ModuleDescriptorCache : " + ivyFile);
            return null;
        }
    }
}
 

public ModuleDescriptor getResolvedModuleDescriptor(ModuleRevisionId mrid)
        throws ParseException, IOException {
    File ivyFile = getResolvedIvyFileInCache(mrid);
    if (!ivyFile.exists()) {
        throw new IllegalStateException("Ivy file not found in cache for " + mrid + "!");
    }

    Properties paths = new Properties();

    File parentsFile = getResolvedIvyPropertiesInCache(ModuleRevisionId.newInstance(mrid,
        mrid.getRevision() + "-parents"));
    if (parentsFile.exists()) {
        FileInputStream in = new FileInputStream(parentsFile);
        paths.load(in);
        in.close();
    }

    ParserSettings pSettings = new CacheParserSettings(settings, paths);

    URL ivyFileURL = ivyFile.toURI().toURL();
    return getModuleDescriptorParser(ivyFile).parseDescriptor(pSettings, ivyFileURL, false);
}
 

public ModuleDescriptor get(File ivyFile, ParserSettings ivySettings, boolean validated,
        ModuleDescriptorProvider mdProvider) throws ParseException, IOException {

    ModuleDescriptor descriptor = getFromCache(ivyFile, ivySettings, validated);
    if (descriptor == null) {
        descriptor = getStale(ivyFile, ivySettings, validated, mdProvider);
    }
    return descriptor;
}
 

public PomModuleDescriptorBuilder(ModuleDescriptorParser parser, Resource res,
        ParserSettings ivySettings) {
    ivyModuleDescriptor = new PomModuleDescriptor(parser, res);
    ivyModuleDescriptor.setResolvedPublicationDate(new Date(res.getLastModified()));
    for (Configuration m2conf : MAVEN2_CONFIGURATIONS) {
        ivyModuleDescriptor.addConfiguration(m2conf);
    }
    ivyModuleDescriptor.setMappingOverride(true);
    ivyModuleDescriptor.addExtraAttributeNamespace("m", IVY_XML_MAVEN_NAMESPACE_URI);
    parserSettings = ivySettings;
}
 

/**
 * Check if the newSettings is compatible with the original settings that has been monitored.
 * Only the info that was actually used is compared.
 */
public boolean hasChanged(ParserSettings newSettings) {
    for (Map.Entry<String, String> entry : substitutes.entrySet()) {
        String key = entry.getKey();
        if (!entry.getValue().equals(newSettings.substitute(key))) {
            Message.debug("settings variable has changed for : " + key);
            return true;
        }
    }
    return false;
}
 

private void addTo(PomModuleDescriptorBuilder mdBuilder, PomDependencyMgt dep,
        ParserSettings ivySettings) throws ParseException, IOException {
    if ("import".equals(dep.getScope())) {
        // In Maven, "import" scope semantics are equivalent to getting (only) the
        // dependency management section of the imported module, into the current
        // module, so that those "managed dependency versions" are usable/applicable
        // in the current module's dependencies
        ModuleRevisionId importModRevID = ModuleRevisionId.newInstance(dep.getGroupId(),
                dep.getArtifactId(), dep.getVersion());
        ResolvedModuleRevision importModule = parseOtherPom(ivySettings, importModRevID, false);
        if (importModule == null) {
            throw new IOException("Impossible to import module for "
                    + mdBuilder.getModuleDescriptor().getResource().getName() + ". Import="
                    + importModRevID);
        }
        ModuleDescriptor importDescr = importModule.getDescriptor();

        // add dependency management info from imported module
        for (PomDependencyMgt importedDepMgt : getDependencyManagements(importDescr)) {
            mdBuilder.addDependencyMgt(new DefaultPomDependencyMgt(importedDepMgt.getGroupId(),
                    importedDepMgt.getArtifactId(), importedDepMgt.getVersion(),
                    importedDepMgt.getScope(), importedDepMgt.getExcludedModules()));
        }
    } else {
        mdBuilder.addDependencyMgt(dep);
    }

}
 

protected ModuleDescriptor parseModuleDescriptor(DependencyResolver resolver, Artifact moduleArtifact, CacheMetadataOptions options, File artifactFile, Resource resource) throws ParseException {
    ModuleRevisionId moduleRevisionId = moduleArtifact.getId().getModuleRevisionId();
    try {
        IvySettings ivySettings = IvyContextualiser.getIvyContext().getSettings();
        ParserSettings parserSettings = new LegacyResolverParserSettings(ivySettings, resolver, moduleRevisionId);
        ModuleDescriptorParser parser = ModuleDescriptorParserRegistry.getInstance().getParser(resource);
        return parser.parseDescriptor(parserSettings, new URL(artifactFile.toURI().toASCIIString()), resource, options.isValidate());
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

private ModuleDescriptor getStaledMd(ModuleDescriptorParser mdParser,
        CacheMetadataOptions options, File ivyFile, ParserSettings parserSettings)
        throws ParseException, IOException {
    ModuleDescriptorMemoryCache cache = getMemoryCache();
    ModuleDescriptorProvider mdProvider = new MyModuleDescriptorProvider(mdParser,
            parserSettings);
    return cache.getStale(ivyFile, settings, options.isValidate(), mdProvider);
}
 

/** Used for test purpose */
ModuleDescriptor parseDescriptor(ParserSettings ivySettings, InputStream descriptor,
        Resource res, boolean validate) throws ParseException {
    Parser parser = newParser(ivySettings);
    parser.setValidate(validate);
    parser.setResource(res);
    parser.setInput(descriptor);
    parser.parse();
    return parser.getModuleDescriptor();
}
 

/**
 * Get the module descriptor from the mdProvider and store it into the cache.
 */
public ModuleDescriptor getStale(File ivyFile, ParserSettings ivySettings, boolean validated,
        ModuleDescriptorProvider mdProvider) throws ParseException, IOException {
    ParserSettingsMonitor settingsMonitor = new ParserSettingsMonitor(ivySettings);
    ModuleDescriptor descriptor = mdProvider.provideModule(
        settingsMonitor.getMonitoredSettings(), ivyFile, validated);
    putInCache(ivyFile, settingsMonitor, validated, descriptor);
    return descriptor;
}
 

public static void fillExtraAttributes(ParserSettings settings, DefaultExtendableItem item,
        Attributes attributes, List<String> ignoredAttNames) {
    Map<String, String> att = getExtraAttributes(settings, attributes, ignoredAttNames);
    for (Map.Entry<String, String> entry : att.entrySet()) {
        item.setExtraAttribute(entry.getKey(), entry.getValue());
    }
}
 

/**
 * Extract from the XML attribute the extra Ivy ones
 *
 * @param settings ParserSettings
 * @param attributes Attributes
 * @param ignoredAttNames
 *            the XML attributes names which are not extra but Ivy core ones
 * @return Map<String,String>
 */
public static Map<String, String> getExtraAttributes(ParserSettings settings,
        Attributes attributes, List<String> ignoredAttNames) {
    Map<String, String> ret = new HashMap<>();
    for (int i = 0; i < attributes.getLength(); i++) {
        if (!ignoredAttNames.contains(attributes.getQName(i))) {
            ret.put(attributes.getQName(i), settings.substitute(attributes.getValue(i)));
        }
    }
    return ret;
}
 

protected ModuleDescriptor parseModuleDescriptor(DependencyResolver resolver, Artifact moduleArtifact, CacheMetadataOptions options, File artifactFile, Resource resource) throws ParseException {
    ModuleRevisionId moduleRevisionId = moduleArtifact.getId().getModuleRevisionId();
    try {
        IvySettings ivySettings = IvyContextualiser.getIvyContext().getSettings();
        ParserSettings parserSettings = new LegacyResolverParserSettings(ivySettings, resolver, moduleRevisionId);
        ModuleDescriptorParser parser = ModuleDescriptorParserRegistry.getInstance().getParser(resource);
        return parser.parseDescriptor(parserSettings, new URL(artifactFile.toURI().toASCIIString()), resource, options.isValidate());
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

public ModuleDescriptor provideModule(ParserSettings ivySettings, File descriptorFile,
        boolean validate) {
    if (ivySettings != null) {
        ivySettings.substitute("${val}");
    }
    called = true;
    return result;
}
 

protected ParserSettings getSettings() {
    return settings;
}
 

ModuleDescriptor provideModule(ParserSettings ivySettings, File descriptorFile,
boolean validate) throws ParseException, IOException;
 

public ParserSettings getSettings() {
    return settings;
}
 

public Parser(ModuleDescriptorParser parser, ParserSettings ivySettings) {
    super(parser);
    settings = ivySettings;
}
 

private void addSourcesAndJavadocArtifactsIfPresent(PomModuleDescriptorBuilder mdBuilder,
        ParserSettings ivySettings) {
    if (mdBuilder.getMainArtifact() == null) {
        // no main artifact in pom, we don't need to search for meta artifacts
        return;
    }

    boolean sourcesLookup = !"false"
            .equals(ivySettings.getVariable("ivy.maven.lookup.sources"));
    boolean javadocLookup = !"false"
            .equals(ivySettings.getVariable("ivy.maven.lookup.javadoc"));
    if (!sourcesLookup && !javadocLookup) {
        Message.debug("Sources and javadocs lookup disabled");
        return;
    }

    ModuleDescriptor md = mdBuilder.getModuleDescriptor();
    ModuleRevisionId mrid = md.getModuleRevisionId();
    DependencyResolver resolver = ivySettings.getResolver(mrid);

    if (resolver == null) {
        Message.debug(
            "no resolver found for " + mrid + ": no source or javadoc artifact lookup");
    } else {
        ArtifactOrigin mainArtifact = resolver.locate(mdBuilder.getMainArtifact());

        if (!ArtifactOrigin.isUnknown(mainArtifact)) {
            String mainArtifactLocation = mainArtifact.getLocation();

            if (sourcesLookup) {
                ArtifactOrigin sourceArtifact = resolver.locate(mdBuilder.getSourceArtifact());
                if (!ArtifactOrigin.isUnknown(sourceArtifact)
                        && !sourceArtifact.getLocation().equals(mainArtifactLocation)) {
                    Message.debug("source artifact found for " + mrid);
                    mdBuilder.addSourceArtifact();
                } else {
                    // it seems that sometimes the 'src' classifier is used instead of 'sources'
                    // Cfr. IVY-1138
                    ArtifactOrigin srcArtifact = resolver.locate(mdBuilder.getSrcArtifact());
                    if (!ArtifactOrigin.isUnknown(srcArtifact)
                            && !srcArtifact.getLocation().equals(mainArtifactLocation)) {
                        Message.debug("source artifact found for " + mrid);
                        mdBuilder.addSrcArtifact();
                    } else {
                        Message.debug("no source artifact found for " + mrid);
                    }
                }
            } else {
                Message.debug("sources lookup disabled");
            }

            if (javadocLookup) {
                ArtifactOrigin javadocArtifact = resolver
                        .locate(mdBuilder.getJavadocArtifact());
                if (!ArtifactOrigin.isUnknown(javadocArtifact)
                        && !javadocArtifact.getLocation().equals(mainArtifactLocation)) {
                    Message.debug("javadoc artifact found for " + mrid);
                    mdBuilder.addJavadocArtifact();
                } else {
                    Message.debug("no javadoc artifact found for " + mrid);
                }
            } else {
                Message.debug("javadocs lookup disabled");
            }
        }
    }
}
 

public UpdateOptions setSettings(ParserSettings settings) {
    this.settings = settings;
    return this;
}
 

private String substitute(ParserSettings ivy, String value) {
    String result = (ivy == null) ? value : ivy.substitute(value);
    return XMLHelper.escape(result);
}
 

public ParserSettings getParserSettings() {
    return new ResolverParserSettings();
}
 

public ModuleDescriptor parseDescriptor(ParserSettings ivySettings, URL descriptorURL,
        boolean validate) throws ParseException, IOException {
    URLResource resource = new URLResource(descriptorURL);
    return parseDescriptor(ivySettings, descriptorURL, resource, validate);
}
 

public ParserSettingsMonitor(ParserSettings settings) {
    this.delegatedSettings = settings;
    this.substitutes = new HashMap<>();
}
 

public ModuleDescriptor provideModule(ParserSettings ivySettings, File descriptorURL,
        boolean validate) throws ParseException, IOException {
    return mdParser.parseDescriptor(settings, descriptorURL.toURI().toURL(), validate);
}
 

public MyModuleDescriptorProvider(ModuleDescriptorParser mdParser, ParserSettings settings) {
    this.mdParser = mdParser;
    this.settings = settings;
}
 

boolean isStale(File ivyFile, boolean validated, ParserSettings newParserSettings) {
    return (validated && !this.validated)
            || md.getLastModified() != ivyFile.lastModified()
            || parserSettingsMonitor.hasChanged(newParserSettings);
}
 

public CacheParserSettings(ParserSettings delegate, Map<Object, Object> parentPaths) {
    this.delegate = delegate;
    this.parentPaths = parentPaths;
}
 

@Deprecated
public static void fillExtraAttributes(ParserSettings settings, DefaultExtendableItem item,
                                       Attributes attributes, String[] ignoredAttNames) {
    fillExtraAttributes(settings, item, attributes, Arrays.asList(ignoredAttNames));
}
 

@Deprecated
public static Map<String, String> getExtraAttributes(ParserSettings settings,
                                                     Attributes attributes, String[] ignoredAttNames) {
    return getExtraAttributes(settings, attributes, Arrays.asList(ignoredAttNames));
}