maven-artifact/src/main/java/org/apache/maven/artifact/DefaultArtifact.java - maven - Git at Google

 /*
  * 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.
  */
 package org.apache.maven.artifact;

 import java.io.File;
 import java.util.*;

 import org.apache.maven.artifact.handler.ArtifactHandler;
 import org.apache.maven.artifact.metadata.ArtifactMetadata;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
 import org.apache.maven.artifact.versioning.ArtifactVersion;
 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
 import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
 import org.apache.maven.artifact.versioning.VersionRange;

 /**
  */
 public class DefaultArtifact implements Artifact {
     private String groupId;

     private String artifactId;

     private String baseVersion;

     private final String type;

     private final String classifier;

     private volatile String scope;

     private volatile File file;

     private ArtifactRepository repository;

     private String downloadUrl;

     private ArtifactFilter dependencyFilter;

     private ArtifactHandler artifactHandler;

     private List<String> dependencyTrail;

     private volatile String version;

     private VersionRange versionRange;

     private volatile boolean resolved;

     private boolean release;

     private List<ArtifactVersion> availableVersions;

     private Map<Object, ArtifactMetadata> metadataMap;

     private boolean optional;

     public DefaultArtifact(
             String groupId,
             String artifactId,
             String version,
             String scope,
             String type,
             String classifier,
             ArtifactHandler artifactHandler) {
         this(
                 groupId,
                 artifactId,
                 VersionRange.createFromVersion(version),
                 scope,
                 type,
                 classifier,
                 artifactHandler,
                 false);
     }

     public DefaultArtifact(
             String groupId,
             String artifactId,
             VersionRange versionRange,
             String scope,
             String type,
             String classifier,
             ArtifactHandler artifactHandler) {
         this(groupId, artifactId, versionRange, scope, type, classifier, artifactHandler, false);
     }

     @SuppressWarnings("checkstyle:parameternumber")
     public DefaultArtifact(
             String groupId,
             String artifactId,
             VersionRange versionRange,
             String scope,
             String type,
             String classifier,
             ArtifactHandler artifactHandler,
             boolean optional) {
         this.groupId = groupId;

         this.artifactId = artifactId;

         this.versionRange = versionRange;

         selectVersionFromNewRangeIfAvailable();

         this.artifactHandler = artifactHandler;

         this.scope = scope;

         this.type = type;

         if (classifier == null) {
             classifier = artifactHandler.getClassifier();
         }

         this.classifier = classifier;

         this.optional = optional;

         validateIdentity();
     }

     private void validateIdentity() {
         if (empty(groupId)) {
             throw new InvalidArtifactRTException(
                     groupId, artifactId, getVersion(), type, "The groupId cannot be empty.");
         }

         if (artifactId == null) {
             throw new InvalidArtifactRTException(
                     groupId, artifactId, getVersion(), type, "The artifactId cannot be empty.");
         }

         if (type == null) {
             throw new InvalidArtifactRTException(groupId, artifactId, getVersion(), type, "The type cannot be empty.");
         }

         if ((version == null) && (versionRange == null)) {
             throw new InvalidArtifactRTException(
                     groupId, artifactId, getVersion(), type, "The version cannot be empty.");
         }
     }

     private boolean empty(String value) {
         return (value == null) || (value.trim().length() < 1);
     }

     public String getClassifier() {
         return classifier;
     }

     public boolean hasClassifier() {
         return classifier != null && !classifier.isEmpty();
     }

     public String getScope() {
         return scope;
     }

     public String getGroupId() {
         return groupId;
     }

     public String getArtifactId() {
         return artifactId;
     }

     public String getVersion() {
         return version;
     }

     public void setVersion(String version) {
         this.version = version;
         setBaseVersionInternal(version);
         versionRange = null;
     }

     public String getType() {
         return type;
     }

     public void setFile(File file) {
         this.file = file;
     }

     public File getFile() {
         return file;
     }

     public ArtifactRepository getRepository() {
         return repository;
     }

     public void setRepository(ArtifactRepository repository) {
         this.repository = repository;
     }

     // ----------------------------------------------------------------------
     //
     // ----------------------------------------------------------------------

     public String getId() {
         return getDependencyConflictId() + ":" + getBaseVersion();
     }

     public String getDependencyConflictId() {
         StringBuilder sb = new StringBuilder(128);
         sb.append(getGroupId());
         sb.append(':');
         appendArtifactTypeClassifierString(sb);
         return sb.toString();
     }

     private void appendArtifactTypeClassifierString(StringBuilder sb) {
         sb.append(getArtifactId());
         sb.append(':');
         sb.append(getType());
         if (hasClassifier()) {
             sb.append(':');
             sb.append(getClassifier());
         }
     }

     public void addMetadata(ArtifactMetadata metadata) {
         if (metadataMap == null) {
             metadataMap = new HashMap<>();
         }

         ArtifactMetadata m = metadataMap.get(metadata.getKey());
         if (m != null) {
             m.merge(metadata);
         } else {
             metadataMap.put(metadata.getKey(), metadata);
         }
     }

     public Collection<ArtifactMetadata> getMetadataList() {
         if (metadataMap == null) {
             return Collections.emptyList();
         }

         return Collections.unmodifiableCollection(metadataMap.values());
     }

     // ----------------------------------------------------------------------
     // Object overrides
     // ----------------------------------------------------------------------

     public String toString() {
         StringBuilder sb = new StringBuilder();
         if (getGroupId() != null) {
             sb.append(getGroupId());
             sb.append(':');
         }
         appendArtifactTypeClassifierString(sb);
         sb.append(':');
         if (getBaseVersionInternal() != null) {
             sb.append(getBaseVersionInternal());
         } else {
             sb.append(versionRange.toString());
         }
         if (scope != null) {
             sb.append(':');
             sb.append(scope);
         }
         return sb.toString();
     }

     @Override
     public boolean equals(Object o) {
         if (this == o) {
             return true;
         }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
         DefaultArtifact that = (DefaultArtifact) o;
         return Objects.equals(groupId, that.groupId)
                 && Objects.equals(artifactId, that.artifactId)
                 && Objects.equals(type, that.type)
                 && Objects.equals(classifier, that.classifier)
                 && Objects.equals(version, that.version);
     }

     @Override
     public int hashCode() {
         return Objects.hash(groupId, artifactId, type, classifier, version);
     }

     public String getBaseVersion() {
         if (baseVersion == null && version != null) {
             setBaseVersionInternal(version);
         }

         return baseVersion;
     }

     protected String getBaseVersionInternal() {
         if ((baseVersion == null) && (version != null)) {
             setBaseVersionInternal(version);
         }

         return baseVersion;
     }

     public void setBaseVersion(String baseVersion) {
         setBaseVersionInternal(baseVersion);
     }

     protected void setBaseVersionInternal(String baseVersion) {
         this.baseVersion = ArtifactUtils.toSnapshotVersion(baseVersion);
     }

     public int compareTo(Artifact a) {
         int result = groupId.compareTo(a.getGroupId());
         if (result == 0) {
             result = artifactId.compareTo(a.getArtifactId());
             if (result == 0) {
                 result = type.compareTo(a.getType());
                 if (result == 0) {
                     if (classifier == null) {
                         if (a.getClassifier() != null) {
                             result = 1;
                         }
                     } else {
                         if (a.getClassifier() != null) {
                             result = classifier.compareTo(a.getClassifier());
                         } else {
                             result = -1;
                         }
                     }
                     if (result == 0) {
                         // We don't consider the version range in the comparison, just the resolved version
                         result = new DefaultArtifactVersion(version)
                                 .compareTo(new DefaultArtifactVersion(a.getVersion()));
                     }
                 }
             }
         }
         return result;
     }

     public void updateVersion(String version, ArtifactRepository localRepository) {
         setResolvedVersion(version);
         setFile(new File(localRepository.getBasedir(), localRepository.pathOf(this)));
     }

     public String getDownloadUrl() {
         return downloadUrl;
     }

     public void setDownloadUrl(String downloadUrl) {
         this.downloadUrl = downloadUrl;
     }

     public ArtifactFilter getDependencyFilter() {
         return dependencyFilter;
     }

     public void setDependencyFilter(ArtifactFilter artifactFilter) {
         dependencyFilter = artifactFilter;
     }

     public ArtifactHandler getArtifactHandler() {
         return artifactHandler;
     }

     public List<String> getDependencyTrail() {
         return dependencyTrail;
     }

     public void setDependencyTrail(List<String> dependencyTrail) {
         this.dependencyTrail = dependencyTrail;
     }

     public void setScope(String scope) {
         this.scope = scope;
     }

     public VersionRange getVersionRange() {
         return versionRange;
     }

     public void setVersionRange(VersionRange versionRange) {
         this.versionRange = versionRange;
         selectVersionFromNewRangeIfAvailable();
     }

     private void selectVersionFromNewRangeIfAvailable() {
         if ((versionRange != null) && (versionRange.getRecommendedVersion() != null)) {
             selectVersion(versionRange.getRecommendedVersion().toString());
         } else {
             version = null;
             baseVersion = null;
         }
     }

     public void selectVersion(String version) {
         this.version = version;
         setBaseVersionInternal(version);
     }

     public void setGroupId(String groupId) {
         this.groupId = groupId;
     }

     public void setArtifactId(String artifactId) {
         this.artifactId = artifactId;
     }

     public boolean isSnapshot() {
         return getBaseVersion() != null
                 && (getBaseVersion().endsWith(SNAPSHOT_VERSION)
                         || getBaseVersion().equals(LATEST_VERSION));
     }

     public void setResolved(boolean resolved) {
         this.resolved = resolved;
     }

     public boolean isResolved() {
         return resolved;
     }

     public void setResolvedVersion(String version) {
         this.version = version;
         // retain baseVersion
     }

     public void setArtifactHandler(ArtifactHandler artifactHandler) {
         this.artifactHandler = artifactHandler;
     }

     public void setRelease(boolean release) {
         this.release = release;
     }

     public boolean isRelease() {
         return release;
     }

     public List<ArtifactVersion> getAvailableVersions() {
         return availableVersions;
     }

     public void setAvailableVersions(List<ArtifactVersion> availableVersions) {
         this.availableVersions = availableVersions;
     }

     public boolean isOptional() {
         return optional;
     }

     public ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException {
         return versionRange.getSelectedVersion(this);
     }

     public boolean isSelectedVersionKnown() throws OverConstrainedVersionException {
         return versionRange.isSelectedVersionKnown(this);
     }

     public void setOptional(boolean optional) {
         this.optional = optional;
     }
 }
	/*
	* 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.
	*/
	package org.apache.maven.artifact;

	import java.io.File;
	import java.util.*;

	import org.apache.maven.artifact.handler.ArtifactHandler;
	import org.apache.maven.artifact.metadata.ArtifactMetadata;
	import org.apache.maven.artifact.repository.ArtifactRepository;
	import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
	import org.apache.maven.artifact.versioning.ArtifactVersion;
	import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
	import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
	import org.apache.maven.artifact.versioning.VersionRange;

	/**
	*/
	public class DefaultArtifact implements Artifact {
	private String groupId;

	private String artifactId;

	private String baseVersion;

	private final String type;

	private final String classifier;

	private volatile String scope;

	private volatile File file;

	private ArtifactRepository repository;

	private String downloadUrl;

	private ArtifactFilter dependencyFilter;

	private ArtifactHandler artifactHandler;

	private List<String> dependencyTrail;

	private volatile String version;

	private VersionRange versionRange;

	private volatile boolean resolved;

	private boolean release;

	private List<ArtifactVersion> availableVersions;

	private Map<Object, ArtifactMetadata> metadataMap;

	private boolean optional;

	public DefaultArtifact(
	String groupId,
	String artifactId,
	String version,
	String scope,
	String type,
	String classifier,
	ArtifactHandler artifactHandler) {
	this(
	groupId,
	artifactId,
	VersionRange.createFromVersion(version),
	scope,
	type,
	classifier,
	artifactHandler,
	false);
	}

	public DefaultArtifact(
	String groupId,
	String artifactId,
	VersionRange versionRange,
	String scope,
	String type,
	String classifier,
	ArtifactHandler artifactHandler) {
	this(groupId, artifactId, versionRange, scope, type, classifier, artifactHandler, false);
	}

	@SuppressWarnings("checkstyle:parameternumber")
	public DefaultArtifact(
	String groupId,
	String artifactId,
	VersionRange versionRange,
	String scope,
	String type,
	String classifier,
	ArtifactHandler artifactHandler,
	boolean optional) {
	this.groupId = groupId;

	this.artifactId = artifactId;

	this.versionRange = versionRange;

	selectVersionFromNewRangeIfAvailable();

	this.artifactHandler = artifactHandler;

	this.scope = scope;

	this.type = type;

	if (classifier == null) {
	classifier = artifactHandler.getClassifier();
	}

	this.classifier = classifier;

	this.optional = optional;

	validateIdentity();
	}

	private void validateIdentity() {
	if (empty(groupId)) {
	throw new InvalidArtifactRTException(
	groupId, artifactId, getVersion(), type, "The groupId cannot be empty.");
	}

	if (artifactId == null) {
	throw new InvalidArtifactRTException(
	groupId, artifactId, getVersion(), type, "The artifactId cannot be empty.");
	}

	if (type == null) {
	throw new InvalidArtifactRTException(groupId, artifactId, getVersion(), type, "The type cannot be empty.");
	}

	if ((version == null) && (versionRange == null)) {
	throw new InvalidArtifactRTException(
	groupId, artifactId, getVersion(), type, "The version cannot be empty.");
	}
	}

	private boolean empty(String value) {
	return (value == null) \|\| (value.trim().length() < 1);
	}

	public String getClassifier() {
	return classifier;
	}

	public boolean hasClassifier() {
	return classifier != null && !classifier.isEmpty();
	}

	public String getScope() {
	return scope;
	}

	public String getGroupId() {
	return groupId;
	}

	public String getArtifactId() {
	return artifactId;
	}

	public String getVersion() {
	return version;
	}

	public void setVersion(String version) {
	this.version = version;
	setBaseVersionInternal(version);
	versionRange = null;
	}

	public String getType() {
	return type;
	}

	public void setFile(File file) {
	this.file = file;
	}

	public File getFile() {
	return file;
	}

	public ArtifactRepository getRepository() {
	return repository;
	}

	public void setRepository(ArtifactRepository repository) {
	this.repository = repository;
	}

	// ----------------------------------------------------------------------
	//
	// ----------------------------------------------------------------------

	public String getId() {
	return getDependencyConflictId() + ":" + getBaseVersion();
	}

	public String getDependencyConflictId() {
	StringBuilder sb = new StringBuilder(128);
	sb.append(getGroupId());
	sb.append(':');
	appendArtifactTypeClassifierString(sb);
	return sb.toString();
	}

	private void appendArtifactTypeClassifierString(StringBuilder sb) {
	sb.append(getArtifactId());
	sb.append(':');
	sb.append(getType());
	if (hasClassifier()) {
	sb.append(':');
	sb.append(getClassifier());
	}
	}

	public void addMetadata(ArtifactMetadata metadata) {
	if (metadataMap == null) {
	metadataMap = new HashMap<>();
	}

	ArtifactMetadata m = metadataMap.get(metadata.getKey());
	if (m != null) {
	m.merge(metadata);
	} else {
	metadataMap.put(metadata.getKey(), metadata);
	}
	}

	public Collection<ArtifactMetadata> getMetadataList() {
	if (metadataMap == null) {
	return Collections.emptyList();
	}

	return Collections.unmodifiableCollection(metadataMap.values());
	}

	// ----------------------------------------------------------------------
	// Object overrides
	// ----------------------------------------------------------------------

	public String toString() {
	StringBuilder sb = new StringBuilder();
	if (getGroupId() != null) {
	sb.append(getGroupId());
	sb.append(':');
	}
	appendArtifactTypeClassifierString(sb);
	sb.append(':');
	if (getBaseVersionInternal() != null) {
	sb.append(getBaseVersionInternal());
	} else {
	sb.append(versionRange.toString());
	}
	if (scope != null) {
	sb.append(':');
	sb.append(scope);
	}
	return sb.toString();
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) {
	return true;
	}
	if (o == null \|\| getClass() != o.getClass()) {
	return false;
	}
	DefaultArtifact that = (DefaultArtifact) o;
	return Objects.equals(groupId, that.groupId)
	&& Objects.equals(artifactId, that.artifactId)
	&& Objects.equals(type, that.type)
	&& Objects.equals(classifier, that.classifier)
	&& Objects.equals(version, that.version);
	}

	@Override
	public int hashCode() {
	return Objects.hash(groupId, artifactId, type, classifier, version);
	}

	public String getBaseVersion() {
	if (baseVersion == null && version != null) {
	setBaseVersionInternal(version);
	}

	return baseVersion;
	}

	protected String getBaseVersionInternal() {
	if ((baseVersion == null) && (version != null)) {
	setBaseVersionInternal(version);
	}

	return baseVersion;
	}

	public void setBaseVersion(String baseVersion) {
	setBaseVersionInternal(baseVersion);
	}

	protected void setBaseVersionInternal(String baseVersion) {
	this.baseVersion = ArtifactUtils.toSnapshotVersion(baseVersion);
	}

	public int compareTo(Artifact a) {
	int result = groupId.compareTo(a.getGroupId());
	if (result == 0) {
	result = artifactId.compareTo(a.getArtifactId());
	if (result == 0) {
	result = type.compareTo(a.getType());
	if (result == 0) {
	if (classifier == null) {
	if (a.getClassifier() != null) {
	result = 1;
	}
	} else {
	if (a.getClassifier() != null) {
	result = classifier.compareTo(a.getClassifier());
	} else {
	result = -1;
	}
	}
	if (result == 0) {
	// We don't consider the version range in the comparison, just the resolved version
	result = new DefaultArtifactVersion(version)
	.compareTo(new DefaultArtifactVersion(a.getVersion()));
	}
	}
	}
	}
	return result;
	}

	public void updateVersion(String version, ArtifactRepository localRepository) {
	setResolvedVersion(version);
	setFile(new File(localRepository.getBasedir(), localRepository.pathOf(this)));
	}

	public String getDownloadUrl() {
	return downloadUrl;
	}

	public void setDownloadUrl(String downloadUrl) {
	this.downloadUrl = downloadUrl;
	}

	public ArtifactFilter getDependencyFilter() {
	return dependencyFilter;
	}

	public void setDependencyFilter(ArtifactFilter artifactFilter) {
	dependencyFilter = artifactFilter;
	}

	public ArtifactHandler getArtifactHandler() {
	return artifactHandler;
	}

	public List<String> getDependencyTrail() {
	return dependencyTrail;
	}

	public void setDependencyTrail(List<String> dependencyTrail) {
	this.dependencyTrail = dependencyTrail;
	}

	public void setScope(String scope) {
	this.scope = scope;
	}

	public VersionRange getVersionRange() {
	return versionRange;
	}

	public void setVersionRange(VersionRange versionRange) {
	this.versionRange = versionRange;
	selectVersionFromNewRangeIfAvailable();
	}

	private void selectVersionFromNewRangeIfAvailable() {
	if ((versionRange != null) && (versionRange.getRecommendedVersion() != null)) {
	selectVersion(versionRange.getRecommendedVersion().toString());
	} else {
	version = null;
	baseVersion = null;
	}
	}

	public void selectVersion(String version) {
	this.version = version;
	setBaseVersionInternal(version);
	}

	public void setGroupId(String groupId) {
	this.groupId = groupId;
	}

	public void setArtifactId(String artifactId) {
	this.artifactId = artifactId;
	}

	public boolean isSnapshot() {
	return getBaseVersion() != null
	&& (getBaseVersion().endsWith(SNAPSHOT_VERSION)
	\|\| getBaseVersion().equals(LATEST_VERSION));
	}

	public void setResolved(boolean resolved) {
	this.resolved = resolved;
	}

	public boolean isResolved() {
	return resolved;
	}

	public void setResolvedVersion(String version) {
	this.version = version;
	// retain baseVersion
	}

	public void setArtifactHandler(ArtifactHandler artifactHandler) {
	this.artifactHandler = artifactHandler;
	}

	public void setRelease(boolean release) {
	this.release = release;
	}

	public boolean isRelease() {
	return release;
	}

	public List<ArtifactVersion> getAvailableVersions() {
	return availableVersions;
	}

	public void setAvailableVersions(List<ArtifactVersion> availableVersions) {
	this.availableVersions = availableVersions;
	}

	public boolean isOptional() {
	return optional;
	}

	public ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException {
	return versionRange.getSelectedVersion(this);
	}

	public boolean isSelectedVersionKnown() throws OverConstrainedVersionException {
	return versionRange.isSelectedVersionKnown(this);
	}

	public void setOptional(boolean optional) {
	this.optional = optional;
	}
	}