org.kloeckner.maven.plugin.util.VersionRangeUtils Maven / Gradle / Ivy
The newest version!
package org.kloeckner.maven.plugin.util;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.model.Model;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.interpolation.InterpolationException;
import org.codehaus.plexus.interpolation.MapBasedValueSource;
import org.codehaus.plexus.interpolation.ObjectBasedValueSource;
import org.codehaus.plexus.interpolation.PrefixAwareRecursionInterceptor;
import org.codehaus.plexus.interpolation.PrefixedObjectValueSource;
import org.codehaus.plexus.interpolation.StringSearchInterpolator;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.WriterFactory;
import org.jdom.CDATA;
import org.jdom.Comment;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Namespace;
import org.jdom.Text;
import org.jdom.filter.ContentFilter;
import org.jdom.filter.ElementFilter;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
/**
*/
public class VersionRangeUtils {
public static final String POMv4 = "pom.xml";
// private static final String FS = File.separator;
private static String ls = VersionRangeUtils.LS;
/**
* The line separator to use.
*/
public static final String LS = System.getProperty("line.separator");
private VersionRangeUtils() {
// private
}
public static MavenProject getRootProject(List reactorProjects) {
MavenProject project = reactorProjects.get(0);
for (MavenProject currentProject : reactorProjects) {
if (currentProject.isExecutionRoot()) {
project = currentProject;
break;
}
}
return project;
}
public static String interpolate(String value, Model model) throws MojoExecutionException {
if (value != null && value.contains("${")) {
StringSearchInterpolator interpolator = new StringSearchInterpolator();
List pomPrefixes = Arrays.asList("pom.", "project.");
interpolator.addValueSource(new PrefixedObjectValueSource(pomPrefixes, model, false));
interpolator.addValueSource(new MapBasedValueSource(model.getProperties()));
interpolator.addValueSource(new ObjectBasedValueSource(model));
try {
value = interpolator.interpolate(value, new PrefixAwareRecursionInterceptor(pomPrefixes));
} catch (InterpolationException e) {
throw new MojoExecutionException("Failed to interpolate " + value + " for project " + model.getId(), e);
}
}
return value;
}
public static String rewriteParent(MavenProject project, Element rootElement, Namespace namespace, Map mappedVersions, Map originalVersions) throws MojoExecutionException {
String parentVersion = null;
if (project.hasParent()) {
Element parentElement = rootElement.getChild("parent", namespace);
Element versionElement = parentElement.getChild("version", namespace);
MavenProject parent = project.getParent();
String key = ArtifactUtils.versionlessKey(parent.getGroupId(), parent.getArtifactId());
parentVersion = mappedVersions.get(key);
// if (parentVersion == null) {
// //MRELEASE-317
// parentVersion = getResolvedSnapshotVersion(key, resolvedSnapshotDependencies);
// }
if (parentVersion == null) {
if (parent.getVersion().equals(originalVersions.get(key))) {
throw new MojoExecutionException("Version for parent '" + parent.getName() + "' was not mapped");
}
} else {
rewriteValue(versionElement, parentVersion);
}
}
return parentVersion;
}
public static void rewriteValue(Element element, String value) {
Text text = null;
if (element.getContent() != null) {
for (Iterator it = element.getContent().iterator(); it.hasNext();) {
Object content = it.next();
if ((content instanceof Text) && ((Text) content).getTextTrim().length() > 0) {
text = (Text) content;
while (it.hasNext()) {
content = it.next();
if (content instanceof Text) {
text.append((Text) content);
it.remove();
} else {
break;
}
}
break;
}
}
}
if (text == null) {
element.addContent(value);
} else {
String chars = text.getText();
String trimmed = text.getTextTrim();
int idx = chars.indexOf(trimmed);
String leadingWhitespace = chars.substring(0, idx);
String trailingWhitespace = chars.substring(idx + trimmed.length());
text.setText(leadingWhitespace + value + trailingWhitespace);
}
}
public static void rewriteVersion(Element rootElement, Namespace namespace, Map mappedVersions, String projectId, MavenProject project, String parentVersion) throws MojoExecutionException {
Element versionElement = rootElement.getChild("version", namespace);
String version = mappedVersions.get(projectId);
if (version == null) {
throw new MojoExecutionException("Version for '" + project.getName() + "' was not mapped");
}
if (versionElement == null) {
if (!version.equals(parentVersion)) {
// we will add this after artifactId, since it was missing but different from the inherited version
Element artifactIdElement = rootElement.getChild("artifactId", namespace);
int index = rootElement.indexOf(artifactIdElement);
versionElement = new Element("version", namespace);
versionElement.setText(version);
rootElement.addContent(index + 1, new Text("\n "));
rootElement.addContent(index + 2, versionElement);
}
} else {
rewriteValue(versionElement, version);
}
}
public static File getStandardPom(MavenProject project) {
if (project == null) {
return null;
}
File pom = project.getFile();
if (pom == null) {
return null;
}
return pom;
}
public static List getChildren(Element root, String... names) {
Element parent = root;
for (int i = 0; i < names.length - 1 && parent != null; i++) {
parent = parent.getChild(names[i], parent.getNamespace());
}
if (parent == null) {
return Collections.emptyList();
}
return parent.getChildren(names[names.length - 1], parent.getNamespace());
}
/**
* Gets the string contents of the specified XML file. Note: In contrast to an XML processor, the line separators in
* the returned string will be normalized to use the platform's native line separator. This is basically to save
* another normalization step when writing the string contents back to an XML file.
*
* @param file The path to the XML file to read in, must not be null.
* @return The string contents of the XML file.
* @throws IOException If the file could not be opened/read.
*/
public static String readXmlFile(File file) throws IOException {
return readXmlFile(file, LS);
}
public static String readXmlFile(File file, String ls) throws IOException {
Reader reader = null;
try {
reader = ReaderFactory.newXmlReader(file);
return normalizeLineEndings(IOUtil.toString(reader), ls);
} finally {
IOUtil.close(reader);
}
}
/**
* Normalizes the line separators in the specified string.
*
* @param text The string to normalize, may be null.
* @param separator The line separator to use for normalization, typically "\n" or "\r\n", must not be
* null.
* @return The input string with normalized line separators or null if the string was null
* .
*/
public static String normalizeLineEndings(String text, String separator) {
String norm = text;
if (text != null) {
norm = text.replaceAll("(\r\n)|(\n)|(\r)", separator);
}
return norm;
}
public static void writePom(File pomFile, Document document, String modelVersion, String intro, String outtro) throws MojoExecutionException {
Element rootElement = document.getRootElement();
Namespace pomNamespace = Namespace.getNamespace("", "http://maven.apache.org/POM/" + modelVersion);
rootElement.setNamespace(pomNamespace);
Namespace xsiNamespace = Namespace.getNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
rootElement.addNamespaceDeclaration(xsiNamespace);
if (rootElement.getAttribute("schemaLocation", xsiNamespace) == null) {
rootElement.setAttribute("schemaLocation", "http://maven.apache.org/POM/" + modelVersion + " http://maven.apache.org/maven-v" + modelVersion.replace('.', '_') + ".xsd", xsiNamespace);
}
// the empty namespace is considered equal to the POM namespace, so match them up to avoid extra xmlns=""
ElementFilter elementFilter = new ElementFilter(Namespace.getNamespace(""));
for (Iterator i = rootElement.getDescendants(elementFilter); i.hasNext();) {
Element e = (Element) i.next();
e.setNamespace(pomNamespace);
}
Writer writer = null;
try {
writer = WriterFactory.newXmlWriter(pomFile);
if (intro != null) {
writer.write(intro);
}
Format format = Format.getRawFormat();
format.setLineSeparator(ls);
XMLOutputter out = new XMLOutputter(format);
out.output(document.getRootElement(), writer);
if (outtro != null) {
writer.write(outtro);
}
} catch (IOException e) {
throw new MojoExecutionException("Error writing POM: " + e.getMessage(), e);
} finally {
IOUtil.close(writer);
}
}
public static void normaliseLineEndings(Document document) {
for (Iterator i = document.getDescendants(new ContentFilter(ContentFilter.COMMENT)); i.hasNext();) {
Comment c = (Comment) i.next();
c.setText(VersionRangeUtils.normalizeLineEndings(c.getText(), ls));
}
for (Iterator i = document.getDescendants(new ContentFilter(ContentFilter.CDATA)); i.hasNext();) {
CDATA c = (CDATA) i.next();
c.setText(VersionRangeUtils.normalizeLineEndings(c.getText(), ls));
}
}
public static List loadEagerDependencies(String path, String filename) throws MojoExecutionException {
if (path == null) {
path = Paths.get("").toAbsolutePath().toString();
}
if (filename == null) {
filename = "version-range-maven-plugin.properties";
}
Properties p = new Properties();
try {
p.load(new FileInputStream(new File(path, filename)));
} catch (FileNotFoundException e) {
throw new MojoExecutionException("unable to find '" + filename + "'; path='" + path + "'", e);
} catch (IOException e) {
throw new MojoExecutionException("IOException while searching '" + filename + "'; path='" + path + "'", e);
}
// naja ...
List list = new ArrayList();
for (Object object : p.keySet()) {
list.add(object.toString());
}
return list;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy