proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
apache_maven
|
maven/maven-compat/src/main/java/org/apache/maven/usability/plugin/ExpressionDocumenter.java
|
ExpressionDocumenter
|
load
|
class ExpressionDocumenter {
private static final String[] EXPRESSION_ROOTS = {"project", "settings", "session", "plugin", "rootless"};
private static final String EXPRESSION_DOCO_ROOTPATH = "META-INF/maven/plugin-expressions/";
private static Map<String, Expression> expressionDocumentation;
public static Map<String, Expression> load() throws ExpressionDocumentationException {<FILL_FUNCTION_BODY>}
/**
* <expressions>
* <expression>
* <syntax>project.distributionManagementArtifactRepository</syntax>
* <origin><![CDATA[
* <distributionManagement>
* <repository>
* <id>some-repo</id>
* <url>scp://host/path</url>
* </repository>
* <snapshotRepository>
* <id>some-snap-repo</id>
* <url>scp://host/snapshot-path</url>
* </snapshotRepository>
* </distributionManagement>
* ]]></origin>
* <usage><![CDATA[
* The repositories onto which artifacts should be deployed.
* One is for releases, the other for snapshots.
* ]]></usage>
* </expression>
* <expressions>
*
* @throws IOException
* @throws XmlPullParserException
*/
private static Map<String, Expression> parseExpressionDocumentation(InputStream docStream)
throws IOException, XmlPullParserException {
ParamdocXpp3Reader paramdocReader = new ParamdocXpp3Reader();
ExpressionDocumentation documentation = paramdocReader.read(docStream, true);
List<Expression> expressions = documentation.getExpressions();
Map<String, Expression> bySyntax = new HashMap<>();
if (expressions != null && !expressions.isEmpty()) {
for (Expression expression : expressions) {
bySyntax.put(expression.getSyntax(), expression);
}
}
return bySyntax;
}
private static ClassLoader initializeDocLoader() throws ExpressionDocumentationException {
String myResourcePath = ExpressionDocumenter.class.getName().replace('.', '/') + ".class";
URL myResource = ExpressionDocumenter.class.getClassLoader().getResource(myResourcePath);
assert myResource != null : "The resource is this class itself loaded by its own classloader and must exist";
String myClasspathEntry = myResource.getPath();
myClasspathEntry = myClasspathEntry.substring(0, myClasspathEntry.length() - (myResourcePath.length() + 2));
if (myClasspathEntry.startsWith("file:")) {
myClasspathEntry = myClasspathEntry.substring("file:".length());
}
URL docResource;
try {
docResource = new File(myClasspathEntry).toURL();
} catch (MalformedURLException e) {
throw new ExpressionDocumentationException(
"Cannot construct expression documentation classpath" + " resource base.", e);
}
return new URLClassLoader(new URL[] {docResource});
}
}
|
if (expressionDocumentation == null) {
expressionDocumentation = new HashMap<>();
ClassLoader docLoader = initializeDocLoader();
for (String root : EXPRESSION_ROOTS) {
try (InputStream docStream =
docLoader.getResourceAsStream(EXPRESSION_DOCO_ROOTPATH + root + ".paramdoc.xml")) {
if (docStream != null) {
Map<String, Expression> doco = parseExpressionDocumentation(docStream);
expressionDocumentation.putAll(doco);
}
} catch (IOException e) {
throw new ExpressionDocumentationException(
"Failed to read documentation for expression root: " + root, e);
} catch (XmlPullParserException e) {
throw new ExpressionDocumentationException(
"Failed to parse documentation for expression root: " + root, e);
}
}
}
return expressionDocumentation;
| 812
| 232
| 1,044
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/RepositoryUtils.java
|
MavenArtifactTypeRegistry
|
overlay
|
class MavenArtifactTypeRegistry implements ArtifactTypeRegistry {
private final ArtifactHandlerManager handlerManager;
MavenArtifactTypeRegistry(ArtifactHandlerManager handlerManager) {
this.handlerManager = handlerManager;
}
public ArtifactType get(String stereotypeId) {
ArtifactHandler handler = handlerManager.getArtifactHandler(stereotypeId);
return newArtifactType(stereotypeId, handler);
}
}
public static Collection<Artifact> toArtifacts(Collection<org.apache.maven.artifact.Artifact> artifactsToConvert) {
return artifactsToConvert.stream().map(RepositoryUtils::toArtifact).collect(Collectors.toList());
}
public static WorkspaceRepository getWorkspace(RepositorySystemSession session) {
WorkspaceReader reader = session.getWorkspaceReader();
return (reader != null) ? reader.getRepository() : null;
}
public static boolean repositoriesEquals(List<RemoteRepository> r1, List<RemoteRepository> r2) {
if (r1.size() != r2.size()) {
return false;
}
for (Iterator<RemoteRepository> it1 = r1.iterator(), it2 = r2.iterator(); it1.hasNext(); ) {
if (!repositoryEquals(it1.next(), it2.next())) {
return false;
}
}
return true;
}
public static int repositoriesHashCode(List<RemoteRepository> repositories) {
int result = 17;
for (RemoteRepository repository : repositories) {
result = 31 * result + repositoryHashCode(repository);
}
return result;
}
public static RepositorySystemSession overlay(
ArtifactRepository repository, RepositorySystemSession session, RepositorySystem system) {<FILL_FUNCTION_BODY>
|
if (repository == null || repository.getBasedir() == null) {
return session;
}
DefaultRepositorySystemSession newSession;
if (session != null) {
LocalRepositoryManager lrm = session.getLocalRepositoryManager();
if (lrm != null && lrm.getRepository().getBasedir().equals(new File(repository.getBasedir()))) {
return session;
}
newSession = new DefaultRepositorySystemSession(session);
} else {
newSession = new DefaultRepositorySystemSession(h -> false); // no close handle used
}
final LocalRepositoryManager llrm =
system.newLocalRepositoryManager(newSession, new LocalRepository(repository.getBasedir()));
newSession.setLocalRepositoryManager(llrm);
return newSession;
| 465
| 198
| 663
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/factory/DefaultArtifactFactory.java
|
DefaultArtifactFactory
|
createArtifact
|
class DefaultArtifactFactory implements ArtifactFactory {
private final ArtifactHandlerManager artifactHandlerManager;
@Inject
public DefaultArtifactFactory(ArtifactHandlerManager artifactHandlerManager) {
this.artifactHandlerManager = artifactHandlerManager;
}
public Artifact createArtifact(String groupId, String artifactId, String version, String scope, String type) {
return createArtifact(groupId, artifactId, version, scope, type, null, null);
}
public Artifact createArtifactWithClassifier(
String groupId, String artifactId, String version, String type, String classifier) {
return createArtifact(groupId, artifactId, version, null, type, classifier, null);
}
public Artifact createDependencyArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String type,
String classifier,
String scope) {
return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, null);
}
public Artifact createDependencyArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String type,
String classifier,
String scope,
boolean optional) {
return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, null, optional);
}
public Artifact createDependencyArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String type,
String classifier,
String scope,
String inheritedScope) {
return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, inheritedScope);
}
public Artifact createDependencyArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String type,
String classifier,
String scope,
String inheritedScope,
boolean optional) {
return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, inheritedScope, optional);
}
public Artifact createBuildArtifact(String groupId, String artifactId, String version, String packaging) {
return createArtifact(groupId, artifactId, version, null, packaging, null, null);
}
public Artifact createProjectArtifact(String groupId, String artifactId, String version) {
return createProjectArtifact(groupId, artifactId, version, null);
}
public Artifact createParentArtifact(String groupId, String artifactId, String version) {
return createProjectArtifact(groupId, artifactId, version);
}
public Artifact createPluginArtifact(String groupId, String artifactId, VersionRange versionRange) {
return createArtifact(groupId, artifactId, versionRange, "maven-plugin", null, Artifact.SCOPE_RUNTIME, null);
}
public Artifact createProjectArtifact(String groupId, String artifactId, String version, String scope) {
return createArtifact(groupId, artifactId, version, scope, "pom");
}
public Artifact createExtensionArtifact(String groupId, String artifactId, VersionRange versionRange) {
return createArtifact(groupId, artifactId, versionRange, "jar", null, Artifact.SCOPE_RUNTIME, null);
}
private Artifact createArtifact(
String groupId,
String artifactId,
String version,
String scope,
String type,
String classifier,
String inheritedScope) {
VersionRange versionRange = null;
if (version != null) {
versionRange = VersionRange.createFromVersion(version);
}
return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, inheritedScope);
}
private Artifact createArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String type,
String classifier,
String scope,
String inheritedScope) {
return createArtifact(groupId, artifactId, versionRange, type, classifier, scope, inheritedScope, false);
}
private Artifact createArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String type,
String classifier,
String scope,
String inheritedScope,
boolean optional) {<FILL_FUNCTION_BODY>}
}
|
String desiredScope = Artifact.SCOPE_RUNTIME;
if (inheritedScope == null) {
desiredScope = scope;
} else if (Artifact.SCOPE_TEST.equals(scope) || Artifact.SCOPE_PROVIDED.equals(scope)) {
return null;
} else if (Artifact.SCOPE_COMPILE.equals(scope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
// added to retain compile artifactScope. Remove if you want compile inherited as runtime
desiredScope = Artifact.SCOPE_COMPILE;
}
if (Artifact.SCOPE_TEST.equals(inheritedScope)) {
desiredScope = Artifact.SCOPE_TEST;
}
if (Artifact.SCOPE_PROVIDED.equals(inheritedScope)) {
desiredScope = Artifact.SCOPE_PROVIDED;
}
if (Artifact.SCOPE_SYSTEM.equals(scope)) {
// system scopes come through unchanged...
desiredScope = Artifact.SCOPE_SYSTEM;
}
ArtifactHandler handler = artifactHandlerManager.getArtifactHandler(type);
return new DefaultArtifact(
groupId, artifactId, versionRange, desiredScope, type, classifier, handler, optional);
| 1,073
| 336
| 1,409
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/handler/DefaultArtifactHandler.java
|
DefaultArtifactHandler
|
getPackaging
|
class DefaultArtifactHandler implements ArtifactHandler {
private final String type;
private String extension;
private String classifier;
private String directory;
private String packaging;
private boolean includesDependencies;
private String language;
@Deprecated
private boolean addedToClasspath;
/**
* Default ctor for Plexus compatibility, as many plugins have artifact handlers declared in legacy Plexus XML.
* Do not use directly!
*
* @deprecated This ctor is present only for Plexus XML defined component compatibility, do not use it.
*/
@Deprecated
public DefaultArtifactHandler() {
this.type = null;
}
public DefaultArtifactHandler(final String type) {
this(type, null, null, null, null, false, null, false);
}
@SuppressWarnings("checkstyle:ParameterNumber")
public DefaultArtifactHandler(
final String type,
final String extension,
final String classifier,
final String directory,
final String packaging,
final boolean includesDependencies,
final String language,
final boolean addedToClasspath) {
this.type = requireNonNull(type);
this.extension = extension;
this.classifier = classifier;
this.directory = directory;
this.packaging = packaging;
this.includesDependencies = includesDependencies;
this.language = language;
this.addedToClasspath = addedToClasspath;
}
public String getType() {
return type;
}
@Override
public String getExtension() {
if (extension == null) {
return type;
}
return extension;
}
public void setExtension(final String extension) {
this.extension = extension;
}
@Override
public String getClassifier() {
return classifier;
}
public void setClassifier(final String classifier) {
this.classifier = classifier;
}
@Override
public String getDirectory() {
if (directory == null) {
return getPackaging() + "s";
}
return directory;
}
public void setDirectory(final String directory) {
this.directory = directory;
}
@Override
public String getPackaging() {<FILL_FUNCTION_BODY>}
public void setPackaging(final String packaging) {
this.packaging = packaging;
}
@Override
public boolean isIncludesDependencies() {
return includesDependencies;
}
public void setIncludesDependencies(final boolean includesDependencies) {
this.includesDependencies = includesDependencies;
}
@Override
public String getLanguage() {
if (language == null) {
return "none";
}
return language;
}
public void setLanguage(final String language) {
this.language = language;
}
@Override
@Deprecated
public boolean isAddedToClasspath() {
return addedToClasspath;
}
@Deprecated
public void setAddedToClasspath(final boolean addedToClasspath) {
this.addedToClasspath = addedToClasspath;
}
}
|
if (packaging == null) {
return type;
}
return packaging;
| 821
| 26
| 847
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/handler/manager/DefaultArtifactHandlerManager.java
|
DefaultArtifactHandlerManager
|
onEvent
|
class DefaultArtifactHandlerManager extends AbstractEventSpy implements ArtifactHandlerManager {
private final TypeRegistry typeRegistry;
private final ConcurrentHashMap<String, ArtifactHandler> allHandlers;
@Inject
public DefaultArtifactHandlerManager(TypeRegistry typeRegistry) {
this.typeRegistry = requireNonNull(typeRegistry, "null typeRegistry");
this.allHandlers = new ConcurrentHashMap<>();
}
@Override
public void onEvent(Object event) {<FILL_FUNCTION_BODY>}
@Override
public ArtifactHandler getArtifactHandler(String id) {
return allHandlers.computeIfAbsent(id, k -> {
Type type = typeRegistry.require(id);
return new DefaultArtifactHandler(
id,
type.getExtension(),
type.getClassifier(),
null,
null,
type.isIncludesDependencies(),
type.getLanguage().id(),
type.getPathTypes().contains(JavaPathType.CLASSES));
// TODO: watch out for module path
});
// Note: here, type decides is artifact added to "build path" (for example during resolution)
// and "build path" is intermediate data that is used to create actual Java classpath/modulepath
// but to create those, proper filtering should happen via Type properties.
}
@Override
public void addHandlers(Map<String, ArtifactHandler> handlers) {
throw new UnsupportedOperationException("Adding handlers programmatically is not supported anymore");
}
@Deprecated
public Set<String> getHandlerTypes() {
throw new UnsupportedOperationException("Querying handlers programmatically is not supported anymore");
}
}
|
if (event instanceof ExecutionEvent) {
ExecutionEvent executionEvent = (ExecutionEvent) event;
if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
allHandlers.clear();
}
}
| 430
| 64
| 494
|
<methods>public non-sealed void <init>() ,public void close() throws java.lang.Exception,public void init(org.apache.maven.eventspy.EventSpy.Context) throws java.lang.Exception,public void onEvent(java.lang.Object) throws java.lang.Exception<variables>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/handler/manager/LegacyArtifactHandlerManager.java
|
LegacyArtifactHandlerManager
|
onEvent
|
class LegacyArtifactHandlerManager extends AbstractEventSpy {
private final Map<String, ArtifactHandler> artifactHandlers;
private final Map<String, ArtifactHandler> allHandlers = new ConcurrentHashMap<>();
@Inject
public LegacyArtifactHandlerManager(Map<String, ArtifactHandler> artifactHandlers) {
this.artifactHandlers = requireNonNull(artifactHandlers);
}
@Override
public void onEvent(Object event) {<FILL_FUNCTION_BODY>}
public ArtifactHandler getArtifactHandler(String type) {
requireNonNull(type, "null type");
ArtifactHandler handler = allHandlers.get(type);
if (handler == null) {
handler = artifactHandlers.get(type);
if (handler == null) {
handler = new DefaultArtifactHandler(type);
} else {
allHandlers.put(type, handler);
}
}
return handler;
}
}
|
if (event instanceof ExecutionEvent) {
ExecutionEvent executionEvent = (ExecutionEvent) event;
if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
allHandlers.clear();
}
}
| 248
| 64
| 312
|
<methods>public non-sealed void <init>() ,public void close() throws java.lang.Exception,public void init(org.apache.maven.eventspy.EventSpy.Context) throws java.lang.Exception,public void onEvent(java.lang.Object) throws java.lang.Exception<variables>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/repository/DefaultRepositoryRequest.java
|
DefaultRepositoryRequest
|
getRemoteRepositories
|
class DefaultRepositoryRequest implements RepositoryRequest {
private boolean offline;
private boolean forceUpdate;
private ArtifactRepository localRepository;
private List<ArtifactRepository> remoteRepositories;
/**
* Creates an empty repository request.
*/
public DefaultRepositoryRequest() {
// enables no-arg constructor
}
/**
* Creates a shallow copy of the specified repository request.
*
* @param repositoryRequest The repository request to copy from, must not be {@code null}.
*/
public DefaultRepositoryRequest(RepositoryRequest repositoryRequest) {
setLocalRepository(repositoryRequest.getLocalRepository());
setRemoteRepositories(repositoryRequest.getRemoteRepositories());
setOffline(repositoryRequest.isOffline());
setForceUpdate(repositoryRequest.isForceUpdate());
}
public static RepositoryRequest getRepositoryRequest(MavenSession session, MavenProject project) {
RepositoryRequest request = new DefaultRepositoryRequest();
request.setLocalRepository(session.getLocalRepository());
if (project != null) {
request.setRemoteRepositories(project.getPluginArtifactRepositories());
}
request.setOffline(session.isOffline());
request.setForceUpdate(session.getRequest().isUpdateSnapshots());
return request;
}
public boolean isOffline() {
return offline;
}
public DefaultRepositoryRequest setOffline(boolean offline) {
this.offline = offline;
return this;
}
public boolean isForceUpdate() {
return forceUpdate;
}
public DefaultRepositoryRequest setForceUpdate(boolean forceUpdate) {
this.forceUpdate = forceUpdate;
return this;
}
public ArtifactRepository getLocalRepository() {
return localRepository;
}
public DefaultRepositoryRequest setLocalRepository(ArtifactRepository localRepository) {
this.localRepository = localRepository;
return this;
}
public List<ArtifactRepository> getRemoteRepositories() {<FILL_FUNCTION_BODY>}
public DefaultRepositoryRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {
this.remoteRepositories = remoteRepositories;
return this;
}
}
|
if (remoteRepositories == null) {
remoteRepositories = new ArrayList<>();
}
return remoteRepositories;
| 579
| 41
| 620
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/repository/layout/DefaultRepositoryLayout.java
|
DefaultRepositoryLayout
|
pathOf
|
class DefaultRepositoryLayout implements ArtifactRepositoryLayout {
private static final char PATH_SEPARATOR = '/';
private static final char GROUP_SEPARATOR = '.';
private static final char ARTIFACT_SEPARATOR = '-';
public String getId() {
return "default";
}
public String pathOf(Artifact artifact) {<FILL_FUNCTION_BODY>}
public String pathOfLocalRepositoryMetadata(ArtifactMetadata metadata, ArtifactRepository repository) {
return pathOfRepositoryMetadata(metadata, metadata.getLocalFilename(repository));
}
private String pathOfRepositoryMetadata(ArtifactMetadata metadata, String filename) {
StringBuilder path = new StringBuilder(128);
path.append(formatAsDirectory(metadata.getGroupId())).append(PATH_SEPARATOR);
if (!metadata.storedInGroupDirectory()) {
path.append(metadata.getArtifactId()).append(PATH_SEPARATOR);
if (metadata.storedInArtifactVersionDirectory()) {
path.append(metadata.getBaseVersion()).append(PATH_SEPARATOR);
}
}
path.append(filename);
return path.toString();
}
public String pathOfRemoteRepositoryMetadata(ArtifactMetadata metadata) {
return pathOfRepositoryMetadata(metadata, metadata.getRemoteFilename());
}
private String formatAsDirectory(String directory) {
return directory.replace(GROUP_SEPARATOR, PATH_SEPARATOR);
}
@Override
public String toString() {
return getId();
}
}
|
ArtifactHandler artifactHandler = artifact.getArtifactHandler();
StringBuilder path = new StringBuilder(128);
path.append(formatAsDirectory(artifact.getGroupId())).append(PATH_SEPARATOR);
path.append(artifact.getArtifactId()).append(PATH_SEPARATOR);
path.append(artifact.getBaseVersion()).append(PATH_SEPARATOR);
path.append(artifact.getArtifactId()).append(ARTIFACT_SEPARATOR).append(artifact.getVersion());
if (artifact.hasClassifier()) {
path.append(ARTIFACT_SEPARATOR).append(artifact.getClassifier());
}
if (artifactHandler.getExtension() != null
&& !artifactHandler.getExtension().isEmpty()) {
path.append(GROUP_SEPARATOR).append(artifactHandler.getExtension());
}
return path.toString();
| 396
| 227
| 623
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/repository/metadata/io/DefaultMetadataReader.java
|
DefaultMetadataReader
|
read
|
class DefaultMetadataReader implements MetadataReader {
public Metadata read(File input, Map<String, ?> options) throws IOException {
Objects.requireNonNull(input, "input cannot be null");
return read(Files.newInputStream(input.toPath()), options);
}
public Metadata read(Reader input, Map<String, ?> options) throws IOException {<FILL_FUNCTION_BODY>}
public Metadata read(InputStream input, Map<String, ?> options) throws IOException {
Objects.requireNonNull(input, "input cannot be null");
try (InputStream in = input) {
return new Metadata(new MetadataStaxReader().read(in, isStrict(options)));
} catch (XMLStreamException e) {
throw new MetadataParseException(
e.getMessage(),
e.getLocation().getLineNumber(),
e.getLocation().getColumnNumber(),
e);
}
}
private boolean isStrict(Map<String, ?> options) {
Object value = (options != null) ? options.get(IS_STRICT) : null;
return value == null || Boolean.parseBoolean(value.toString());
}
}
|
Objects.requireNonNull(input, "input cannot be null");
try (Reader in = input) {
return new Metadata(new MetadataStaxReader().read(in, isStrict(options)));
} catch (XMLStreamException e) {
throw new MetadataParseException(
e.getMessage(),
e.getLocation().getLineNumber(),
e.getLocation().getColumnNumber(),
e);
}
| 300
| 110
| 410
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/AbstractScopeArtifactFilter.java
|
AbstractScopeArtifactFilter
|
addScopeInternal
|
class AbstractScopeArtifactFilter implements ArtifactFilter {
private boolean compileScope;
private boolean runtimeScope;
private boolean testScope;
private boolean providedScope;
private boolean systemScope;
void addScopeInternal(String scope) {<FILL_FUNCTION_BODY>}
public boolean include(Artifact artifact) {
if (Artifact.SCOPE_COMPILE.equals(artifact.getScope())) {
return compileScope;
} else if (Artifact.SCOPE_RUNTIME.equals(artifact.getScope())) {
return runtimeScope;
} else if (Artifact.SCOPE_TEST.equals(artifact.getScope())) {
return testScope;
} else if (Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) {
return providedScope;
} else if (Artifact.SCOPE_SYSTEM.equals(artifact.getScope())) {
return systemScope;
} else {
return true;
}
}
}
|
if (Artifact.SCOPE_COMPILE.equals(scope)) {
systemScope = true;
providedScope = true;
compileScope = true;
} else if (Artifact.SCOPE_RUNTIME.equals(scope)) {
compileScope = true;
runtimeScope = true;
} else if (Artifact.SCOPE_COMPILE_PLUS_RUNTIME.equals(scope)) {
systemScope = true;
providedScope = true;
compileScope = true;
runtimeScope = true;
} else if (Artifact.SCOPE_RUNTIME_PLUS_SYSTEM.equals(scope)) {
systemScope = true;
compileScope = true;
runtimeScope = true;
} else if (Artifact.SCOPE_TEST.equals(scope)) {
systemScope = true;
providedScope = true;
compileScope = true;
runtimeScope = true;
testScope = true;
}
| 256
| 244
| 500
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/AndArtifactFilter.java
|
AndArtifactFilter
|
equals
|
class AndArtifactFilter implements ArtifactFilter {
private Set<ArtifactFilter> filters;
public AndArtifactFilter() {
this.filters = new LinkedHashSet<>();
}
public AndArtifactFilter(List<ArtifactFilter> filters) {
this.filters = new LinkedHashSet<>(filters);
}
public boolean include(Artifact artifact) {
boolean include = true;
for (Iterator<ArtifactFilter> i = filters.iterator(); i.hasNext() && include; ) {
ArtifactFilter filter = i.next();
if (!filter.include(artifact)) {
include = false;
}
}
return include;
}
public void add(ArtifactFilter artifactFilter) {
filters.add(artifactFilter);
}
public List<ArtifactFilter> getFilters() {
return new ArrayList<>(filters);
}
@Override
public int hashCode() {
int hash = 17;
hash = hash * 31 + filters.hashCode();
return hash;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (this == obj) {
return true;
}
if (!(obj instanceof AndArtifactFilter)) {
return false;
}
AndArtifactFilter other = (AndArtifactFilter) obj;
return filters.equals(other.filters);
| 299
| 72
| 371
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/CumulativeScopeArtifactFilter.java
|
CumulativeScopeArtifactFilter
|
addScopes
|
class CumulativeScopeArtifactFilter extends AbstractScopeArtifactFilter {
private Set<String> scopes;
/**
* Create a new filter with the specified scopes and their implied scopes enabled.
*
* @param scopes The scopes to enable, along with all implied scopes, may be {@code null}.
*/
public CumulativeScopeArtifactFilter(Collection<String> scopes) {
this.scopes = new HashSet<>();
addScopes(scopes);
}
/**
* Creates a new filter that combines the specified filters.
*
* @param filters The filters to combine, may be {@code null}.
*/
public CumulativeScopeArtifactFilter(CumulativeScopeArtifactFilter... filters) {
this.scopes = new HashSet<>();
if (filters != null) {
for (CumulativeScopeArtifactFilter filter : filters) {
addScopes(filter.getScopes());
}
}
}
private void addScopes(Collection<String> scopes) {<FILL_FUNCTION_BODY>}
private void addScope(String scope) {
this.scopes.add(scope);
addScopeInternal(scope);
}
public Set<String> getScopes() {
return scopes;
}
@Override
public int hashCode() {
int hash = 17;
hash = hash * 31 + scopes.hashCode();
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof CumulativeScopeArtifactFilter)) {
return false;
}
CumulativeScopeArtifactFilter that = (CumulativeScopeArtifactFilter) obj;
return scopes.equals(that.scopes);
}
}
|
if (scopes != null) {
for (String scope : scopes) {
addScope(scope);
}
}
| 482
| 38
| 520
|
<methods>public boolean include(org.apache.maven.artifact.Artifact) <variables>private boolean compileScope,private boolean providedScope,private boolean runtimeScope,private boolean systemScope,private boolean testScope
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/ExclusionArtifactFilter.java
|
ExclusionArtifactFilter
|
createPathProxy
|
class ExclusionArtifactFilter implements ArtifactFilter {
private final List<Exclusion> exclusions;
private final List<Predicate<Artifact>> predicates;
public ExclusionArtifactFilter(List<Exclusion> exclusions) {
this.exclusions = exclusions;
this.predicates =
exclusions.stream().map(ExclusionArtifactFilter::toPredicate).collect(Collectors.toList());
}
@Override
public boolean include(Artifact artifact) {
return predicates.stream().noneMatch(p -> p.test(artifact));
}
private static Predicate<Artifact> toPredicate(Exclusion exclusion) {
PathMatcher groupId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getGroupId());
PathMatcher artifactId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getArtifactId());
Predicate<Artifact> predGroupId = a -> groupId.matches(createPathProxy(a.getGroupId()));
Predicate<Artifact> predArtifactId = a -> artifactId.matches(createPathProxy(a.getArtifactId()));
return predGroupId.and(predArtifactId);
}
/**
* In order to reuse the glob matcher from the filesystem, we need
* to create Path instances. Those are only used with the toString method.
* This hack works because the only system-dependent thing is the path
* separator which should not be part of the groupId or artifactId.
*/
private static Path createPathProxy(String value) {<FILL_FUNCTION_BODY>}
}
|
return (Path) Proxy.newProxyInstance(
ExclusionArtifactFilter.class.getClassLoader(), new Class[] {Path.class}, (proxy1, method, args) -> {
if ("toString".equals(method.getName())) {
return value;
}
throw new UnsupportedOperationException();
});
| 416
| 82
| 498
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/ExclusionSetFilter.java
|
ExclusionSetFilter
|
equals
|
class ExclusionSetFilter implements ArtifactFilter {
private Set<String> excludes;
public ExclusionSetFilter(String[] excludes) {
this.excludes = new LinkedHashSet<>(Arrays.asList(excludes));
}
public ExclusionSetFilter(Set<String> excludes) {
this.excludes = excludes;
}
public boolean include(Artifact artifact) {
String id = artifact.getArtifactId();
if (excludes.contains(id)) {
return false;
}
id = artifact.getGroupId() + ':' + id;
return !excludes.contains(id);
}
@Override
public int hashCode() {
int hash = 17;
hash = hash * 31 + excludes.hashCode();
return hash;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (this == obj) {
return true;
}
if (!(obj instanceof ExclusionSetFilter)) {
return false;
}
ExclusionSetFilter other = (ExclusionSetFilter) obj;
return excludes.equals(other.excludes);
| 242
| 73
| 315
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/IncludesArtifactFilter.java
|
IncludesArtifactFilter
|
equals
|
class IncludesArtifactFilter implements ArtifactFilter {
private final Set<String> patterns;
public IncludesArtifactFilter(List<String> patterns) {
this.patterns = new LinkedHashSet<>(patterns);
}
public boolean include(Artifact artifact) {
String id = artifact.getGroupId() + ":" + artifact.getArtifactId();
boolean matched = false;
for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {
// TODO what about wildcards? Just specifying groups? versions?
if (id.equals(i.next())) {
matched = true;
}
}
return matched;
}
public List<String> getPatterns() {
return new ArrayList<>(patterns);
}
@Override
public int hashCode() {
int hash = 17;
hash = hash * 31 + patterns.hashCode();
return hash;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (this == obj) {
return true;
}
// make sure IncludesArtifactFilter is not equal ExcludesArtifactFilter!
if (obj == null || getClass() != obj.getClass()) {
return false;
}
IncludesArtifactFilter other = (IncludesArtifactFilter) obj;
return patterns.equals(other.patterns);
| 276
| 99
| 375
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/artifact/resolver/filter/ScopeArtifactFilter.java
|
ScopeArtifactFilter
|
equals
|
class ScopeArtifactFilter extends AbstractScopeArtifactFilter {
private final String scope;
public ScopeArtifactFilter(String scope) {
this.scope = scope;
addScopeInternal(scope);
}
public String getScope() {
return scope;
}
@Override
public int hashCode() {
int hash = 17;
hash = hash * 31 + (scope != null ? scope.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (this == obj) {
return true;
}
if (!(obj instanceof ScopeArtifactFilter)) {
return false;
}
ScopeArtifactFilter other = (ScopeArtifactFilter) obj;
return Objects.equals(scope, other.scope);
| 158
| 76
| 234
|
<methods>public boolean include(org.apache.maven.artifact.Artifact) <variables>private boolean compileScope,private boolean providedScope,private boolean runtimeScope,private boolean systemScope,private boolean testScope
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/configuration/BasedirBeanConfigurationPathTranslator.java
|
BasedirBeanConfigurationPathTranslator
|
translatePath
|
class BasedirBeanConfigurationPathTranslator implements BeanConfigurationPathTranslator {
private final File basedir;
/**
* Creates a new path translator using the specified base directory.
*
* @param basedir The base directory to resolve relative paths against, may be {@code null} to disable path
* translation.
*/
public BasedirBeanConfigurationPathTranslator(File basedir) {
this.basedir = basedir;
}
public File translatePath(File path) {<FILL_FUNCTION_BODY>}
}
|
File result = path;
if (path != null && basedir != null) {
if (path.isAbsolute()) {
// path is already absolute, we're done
} else if (path.getPath().startsWith(File.separator)) {
// drive-relative Windows path, don't align with base dir but with drive root
result = path.getAbsoluteFile();
} else {
// an ordinary relative path, align with base dir
result = new File(new File(basedir, path.getPath()).toURI().normalize()).getAbsoluteFile();
}
}
return result;
| 141
| 160
| 301
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/configuration/DefaultBeanConfigurationRequest.java
|
DefaultBeanConfigurationRequest
|
findPlugin
|
class DefaultBeanConfigurationRequest implements BeanConfigurationRequest {
private Object bean;
private Object configuration;
private String configurationElement;
private ClassLoader classLoader;
private BeanConfigurationValuePreprocessor valuePreprocessor;
private BeanConfigurationPathTranslator pathTranslator;
public Object getBean() {
return bean;
}
public DefaultBeanConfigurationRequest setBean(Object bean) {
this.bean = bean;
return this;
}
public Object getConfiguration() {
return configuration;
}
public String getConfigurationElement() {
return configurationElement;
}
public DefaultBeanConfigurationRequest setConfiguration(Object configuration) {
return setConfiguration(configuration, null);
}
public DefaultBeanConfigurationRequest setConfiguration(Object configuration, String element) {
this.configuration = configuration;
this.configurationElement = element;
return this;
}
/**
* Sets the configuration to the configuration taken from the specified build plugin in the POM. First, the build
* plugins will be searched for the specified plugin, if that fails, the plugin management section will be searched.
*
* @param model The POM to extract the plugin configuration from, may be {@code null}.
* @param pluginGroupId The group id of the plugin whose configuration should be used, must not be {@code null} or
* empty.
* @param pluginArtifactId The artifact id of the plugin whose configuration should be used, must not be
* {@code null} or empty.
* @param pluginExecutionId The id of a plugin execution whose configuration should be used, may be {@code null} or
* empty to use the general plugin configuration.
* @return This request for chaining, never {@code null}.
*/
public DefaultBeanConfigurationRequest setConfiguration(
Model model, String pluginGroupId, String pluginArtifactId, String pluginExecutionId) {
Plugin plugin = findPlugin(model, pluginGroupId, pluginArtifactId);
if (plugin != null) {
if (pluginExecutionId != null && !pluginExecutionId.isEmpty()) {
for (PluginExecution execution : plugin.getExecutions()) {
if (pluginExecutionId.equals(execution.getId())) {
setConfiguration(execution.getConfiguration());
break;
}
}
} else {
setConfiguration(plugin.getConfiguration());
}
}
return this;
}
private Plugin findPlugin(Model model, String groupId, String artifactId) {<FILL_FUNCTION_BODY>}
public ClassLoader getClassLoader() {
return classLoader;
}
public DefaultBeanConfigurationRequest setClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
return this;
}
public BeanConfigurationValuePreprocessor getValuePreprocessor() {
return valuePreprocessor;
}
public DefaultBeanConfigurationRequest setValuePreprocessor(BeanConfigurationValuePreprocessor valuePreprocessor) {
this.valuePreprocessor = valuePreprocessor;
return this;
}
public BeanConfigurationPathTranslator getPathTranslator() {
return pathTranslator;
}
public DefaultBeanConfigurationRequest setPathTranslator(BeanConfigurationPathTranslator pathTranslator) {
this.pathTranslator = pathTranslator;
return this;
}
}
|
if (Objects.requireNonNull(groupId, "groupId cannot be null").isEmpty()) {
throw new IllegalArgumentException("groupId cannot be empty");
}
if (Objects.requireNonNull(artifactId, "artifactId cannot be null").isEmpty()) {
throw new IllegalArgumentException("artifactId cannot be empty");
}
if (model != null) {
Build build = model.getBuild();
if (build != null) {
for (Plugin plugin : build.getPlugins()) {
if (groupId.equals(plugin.getGroupId()) && artifactId.equals(plugin.getArtifactId())) {
return plugin;
}
}
PluginManagement mgmt = build.getPluginManagement();
if (mgmt != null) {
for (Plugin plugin : mgmt.getPlugins()) {
if (groupId.equals(plugin.getGroupId()) && artifactId.equals(plugin.getArtifactId())) {
return plugin;
}
}
}
}
}
return null;
| 829
| 256
| 1,085
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/configuration/internal/DefaultBeanConfigurator.java
|
DefaultBeanConfigurator
|
configureBean
|
class DefaultBeanConfigurator implements BeanConfigurator {
private final ConverterLookup converterLookup;
public DefaultBeanConfigurator() {
converterLookup = new EnhancedConverterLookup();
}
public void configureBean(BeanConfigurationRequest request) throws BeanConfigurationException {<FILL_FUNCTION_BODY>}
static class BeanExpressionEvaluator implements TypeAwareExpressionEvaluator {
private final BeanConfigurationValuePreprocessor preprocessor;
private final BeanConfigurationPathTranslator translator;
BeanExpressionEvaluator(BeanConfigurationRequest request) {
preprocessor = request.getValuePreprocessor();
translator = request.getPathTranslator();
}
public Object evaluate(String expression, Class<?> type) throws ExpressionEvaluationException {
if (preprocessor != null) {
try {
return preprocessor.preprocessValue(expression, type);
} catch (BeanConfigurationException e) {
throw new ExpressionEvaluationException(e.getMessage(), e);
}
}
return expression;
}
public Object evaluate(String expression) throws ExpressionEvaluationException {
return evaluate(expression, null);
}
public File alignToBaseDirectory(File file) {
if (translator != null) {
return translator.translatePath(file);
}
return file;
}
}
static class XmlConverter extends AbstractConfigurationConverter {
@Override
public boolean canConvert(Class<?> type) {
return XmlNode.class.equals(type);
}
@Override
public Object fromConfiguration(
final ConverterLookup lookup,
final PlexusConfiguration configuration,
final Class<?> type,
final Class<?> enclosingType,
final ClassLoader loader,
final ExpressionEvaluator evaluator,
final ConfigurationListener listener)
throws ComponentConfigurationException {
try {
return toXml(configuration, evaluator);
} catch (ExpressionEvaluationException e) {
throw new ComponentConfigurationException("Unable to convert configuration to xml node", e);
}
}
XmlNode toXml(PlexusConfiguration config, ExpressionEvaluator evaluator) throws ExpressionEvaluationException {
List<XmlNode> children = new ArrayList<>();
for (PlexusConfiguration c : config.getChildren()) {
children.add(toXml(c, evaluator));
}
String name = config.getName();
Object value = evaluator.evaluate(config.getValue());
return new XmlNodeImpl(name, value != null ? value.toString() : null, null, children, null);
}
}
static class PathConverter extends AbstractBasicConverter {
@Override
public boolean canConvert(Class<?> type) {
return Path.class.equals(type);
}
@Override
protected Object fromString(String value) throws ComponentConfigurationException {
return Paths.get(value.replace('/' == File.separatorChar ? '\\' : '/', File.separatorChar));
}
@Override
public Object fromConfiguration(
final ConverterLookup lookup,
final PlexusConfiguration configuration,
final Class<?> type,
final Class<?> enclosingType,
final ClassLoader loader,
final ExpressionEvaluator evaluator,
final ConfigurationListener listener)
throws ComponentConfigurationException {
final Object result =
super.fromConfiguration(lookup, configuration, type, enclosingType, loader, evaluator, listener);
return result instanceof Path
? evaluator.alignToBaseDirectory(((Path) result).toFile()).toPath()
: result;
}
}
}
|
Objects.requireNonNull(request, "request cannot be null");
Objects.requireNonNull(request.getBean(), "request.bean cannot be null");
Object configuration = request.getConfiguration();
if (configuration == null) {
return;
}
PlexusConfiguration plexusConfig;
if (configuration instanceof PlexusConfiguration) {
plexusConfig = (PlexusConfiguration) configuration;
} else if (configuration instanceof Xpp3Dom) {
plexusConfig = new XmlPlexusConfiguration((Xpp3Dom) configuration);
} else {
throw new BeanConfigurationException("unsupported bean configuration source ("
+ configuration.getClass().getName() + ")");
}
if (request.getConfigurationElement() != null) {
plexusConfig = plexusConfig.getChild(request.getConfigurationElement());
}
ClassLoader classLoader = request.getClassLoader();
if (classLoader == null) {
classLoader = request.getBean().getClass().getClassLoader();
}
BeanExpressionEvaluator evaluator = new BeanExpressionEvaluator(request);
ObjectWithFieldsConverter converter = new EnhancedConfigurationConverter();
try {
converter.processConfiguration(
converterLookup, request.getBean(), classLoader, plexusConfig, evaluator, null);
} catch (ComponentConfigurationException e) {
throw new BeanConfigurationException(e.getMessage(), e);
}
| 925
| 367
| 1,292
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/configuration/internal/EnhancedComponentConfigurator.java
|
EnhancedComponentConfigurator
|
configureComponent
|
class EnhancedComponentConfigurator extends BasicComponentConfigurator {
public EnhancedComponentConfigurator() {
converterLookup = new EnhancedConverterLookup();
}
@Override
public void configureComponent(
final Object component,
final PlexusConfiguration configuration,
final ExpressionEvaluator evaluator,
final ClassRealm realm,
final ConfigurationListener listener)
throws ComponentConfigurationException {
try {
ClassRealmConverter.pushContextRealm(realm);
this.configureComponent(component, configuration, evaluator, (ClassLoader) realm, listener);
} finally {
ClassRealmConverter.popContextRealm();
}
}
public void configureComponent(
Object component,
PlexusConfiguration configuration,
ExpressionEvaluator evaluator,
ClassLoader loader,
ConfigurationListener listener)
throws ComponentConfigurationException {<FILL_FUNCTION_BODY>}
}
|
new EnhancedConfigurationConverter()
.processConfiguration(
converterLookup,
component,
loader, //
configuration,
evaluator,
listener);
| 235
| 46
| 281
|
<methods>public void <init>() ,public void configureComponent(java.lang.Object, org.codehaus.plexus.configuration.PlexusConfiguration, org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator, org.codehaus.plexus.classworlds.realm.ClassRealm, org.codehaus.plexus.component.configurator.ConfigurationListener) throws org.codehaus.plexus.component.configurator.ComponentConfigurationException<variables>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/configuration/internal/EnhancedConfigurationConverter.java
|
EnhancedConfigurationConverter
|
fromConfiguration
|
class EnhancedConfigurationConverter extends ObjectWithFieldsConverter {
protected Object fromExpression(
final PlexusConfiguration configuration, final ExpressionEvaluator evaluator, final Class<?> type)
throws ComponentConfigurationException {
String value = configuration.getValue();
try {
Object result = null;
if (null != value && !value.isEmpty()) {
if (evaluator instanceof TypeAwareExpressionEvaluator) {
result = ((TypeAwareExpressionEvaluator) evaluator).evaluate(value, type);
} else {
result = evaluator.evaluate(value);
}
}
if (null == result && configuration.getChildCount() == 0) {
value = configuration.getAttribute("default-value");
if (null != value && !value.isEmpty()) {
if (evaluator instanceof TypeAwareExpressionEvaluator) {
result = ((TypeAwareExpressionEvaluator) evaluator).evaluate(value, type);
} else {
result = evaluator.evaluate(value);
}
}
}
failIfNotTypeCompatible(result, type, configuration);
return result;
} catch (final ExpressionEvaluationException e) {
final String reason = String.format(
"Cannot evaluate expression '%s' for configuration entry '%s'", value, configuration.getName());
throw new ComponentConfigurationException(configuration, reason, e);
}
}
public Object fromConfiguration(
final ConverterLookup lookup,
final PlexusConfiguration configuration,
final Class<?> type,
final Class<?> enclosingType,
final ClassLoader loader,
final ExpressionEvaluator evaluator,
final ConfigurationListener listener)
throws ComponentConfigurationException {<FILL_FUNCTION_BODY>}
}
|
final Object value = fromExpression(configuration, evaluator, type);
if (type.isInstance(value)) {
return value;
}
try {
final Class<?> implType = getClassForImplementationHint(type, configuration, loader);
if (null == value && implType.isInterface() && configuration.getChildCount() == 0) {
return null; // nothing to process
}
final Object bean = instantiateObject(implType);
if (null == value) {
processConfiguration(lookup, bean, loader, configuration, evaluator, listener);
} else {
new CompositeBeanHelper(lookup, loader, evaluator, listener).setDefault(bean, value, configuration);
}
return bean;
} catch (final ComponentConfigurationException e) {
if (null == e.getFailedConfiguration()) {
e.setFailedConfiguration(configuration);
}
throw e;
}
| 440
| 231
| 671
|
<methods>public void <init>() ,public boolean canConvert(Class#RAW) ,public java.lang.Object fromConfiguration(org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup, org.codehaus.plexus.configuration.PlexusConfiguration, Class#RAW, Class#RAW, java.lang.ClassLoader, org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator, org.codehaus.plexus.component.configurator.ConfigurationListener) throws org.codehaus.plexus.component.configurator.ComponentConfigurationException,public void processConfiguration(org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup, java.lang.Object, java.lang.ClassLoader, org.codehaus.plexus.configuration.PlexusConfiguration) throws org.codehaus.plexus.component.configurator.ComponentConfigurationException,public void processConfiguration(org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup, java.lang.Object, java.lang.ClassLoader, org.codehaus.plexus.configuration.PlexusConfiguration, org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator) throws org.codehaus.plexus.component.configurator.ComponentConfigurationException,public void processConfiguration(org.codehaus.plexus.component.configurator.converters.lookup.ConverterLookup, java.lang.Object, java.lang.ClassLoader, org.codehaus.plexus.configuration.PlexusConfiguration, org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator, org.codehaus.plexus.component.configurator.ConfigurationListener) throws org.codehaus.plexus.component.configurator.ComponentConfigurationException<variables>static Class#RAW class$java$util$Collection,static Class#RAW class$java$util$Dictionary,static Class#RAW class$java$util$Map
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/configuration/internal/EnhancedConverterLookup.java
|
EnhancedConverterLookup
|
lookupConverterForType
|
class EnhancedConverterLookup implements ConverterLookup {
private final ConverterLookup delegate = new DefaultConverterLookup();
EnhancedConverterLookup() {
registerConverter(new DefaultBeanConfigurator.PathConverter());
registerConverter(new DefaultBeanConfigurator.XmlConverter());
}
@Override
public void registerConverter(ConfigurationConverter converter) {
delegate.registerConverter(converter);
}
@Override
public ConfigurationConverter lookupConverterForType(Class<?> type) throws ComponentConfigurationException {<FILL_FUNCTION_BODY>}
}
|
ConfigurationConverter converter = delegate.lookupConverterForType(type);
return converter.getClass().equals(ObjectWithFieldsConverter.class)
? new EnhancedConfigurationConverter()
: converter;
| 144
| 51
| 195
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/eventspy/internal/EventSpyDispatcher.java
|
EventSpyDispatcher
|
init
|
class EventSpyDispatcher {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final List<EventSpy> eventSpies;
@Inject
public EventSpyDispatcher(List<EventSpy> eventSpies) {
// make copy to get rid of needless overhead for dynamic lookups
this.eventSpies = new ArrayList<>(eventSpies);
}
public ExecutionListener chainListener(ExecutionListener listener) {
if (eventSpies.isEmpty()) {
return listener;
}
return new EventSpyExecutionListener(this, listener);
}
public RepositoryListener chainListener(RepositoryListener listener) {
if (eventSpies.isEmpty()) {
return listener;
}
return new EventSpyRepositoryListener(this, listener);
}
public void init(EventSpy.Context context) {<FILL_FUNCTION_BODY>}
public void onEvent(Object event) {
if (eventSpies.isEmpty()) {
return;
}
for (EventSpy eventSpy : eventSpies) {
try {
eventSpy.onEvent(event);
} catch (Exception | LinkageError e) {
logError("notify", e, eventSpy);
}
}
}
public void close() {
if (eventSpies.isEmpty()) {
return;
}
for (EventSpy eventSpy : eventSpies) {
try {
eventSpy.close();
} catch (Exception | LinkageError e) {
logError("close", e, eventSpy);
}
}
}
private void logError(String action, Throwable e, EventSpy spy) {
String msg = "Failed to " + action + " spy " + spy.getClass().getName() + ": " + e.getMessage();
if (logger.isDebugEnabled()) {
logger.warn(msg, e);
} else {
logger.warn(msg);
}
}
}
|
if (eventSpies.isEmpty()) {
return;
}
for (EventSpy eventSpy : eventSpies) {
try {
eventSpy.init(context);
} catch (Exception | LinkageError e) {
logError("initialize", e, eventSpy);
}
}
| 513
| 84
| 597
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/exception/DefaultExceptionHandler.java
|
DefaultExceptionHandler
|
getReference
|
class DefaultExceptionHandler implements ExceptionHandler {
public ExceptionSummary handleException(Throwable exception) {
return handle("", exception);
}
private ExceptionSummary handle(String message, Throwable exception) {
String reference = getReference(exception);
List<ExceptionSummary> children = null;
if (exception instanceof ProjectBuildingException) {
List<ProjectBuildingResult> results = ((ProjectBuildingException) exception).getResults();
children = new ArrayList<>();
for (ProjectBuildingResult result : results) {
ExceptionSummary child = handle(result);
if (child != null) {
children.add(child);
}
}
message = "The build could not read " + children.size() + " project" + (children.size() == 1 ? "" : "s");
} else {
message = getMessage(message, exception);
}
return new ExceptionSummary(exception, message, reference, children);
}
private ExceptionSummary handle(ProjectBuildingResult result) {
List<ExceptionSummary> children = new ArrayList<>();
for (ModelProblem problem : result.getProblems()) {
ExceptionSummary child = handle(problem, result.getProjectId());
if (child != null) {
children.add(child);
}
}
if (children.isEmpty()) {
return null;
}
String message = System.lineSeparator()
+ "The project " + (result.getProjectId().isEmpty() ? "" : result.getProjectId() + " ")
+ "(" + result.getPomFile() + ") has "
+ children.size() + " error" + (children.size() == 1 ? "" : "s");
return new ExceptionSummary(null, message, null, children);
}
private ExceptionSummary handle(ModelProblem problem, String projectId) {
if (ModelProblem.Severity.ERROR.compareTo(problem.getSeverity()) >= 0) {
String message = problem.getMessage();
String location = ModelProblemUtils.formatLocation(problem, projectId);
if (!location.isEmpty()) {
message += " @ " + location;
}
return handle(message, problem.getException());
} else {
return null;
}
}
private String getReference(Throwable exception) {<FILL_FUNCTION_BODY>}
private boolean isNoteworthyException(Throwable exception) {
if (exception == null) {
return false;
} else if (exception instanceof Error) {
return true;
} else if (exception instanceof RuntimeException) {
return false;
} else {
return !exception.getClass().getName().startsWith("java");
}
}
private String getMessage(String message, Throwable exception) {
String fullMessage = (message != null) ? message : "";
// To break out of possible endless loop when getCause returns "this"
for (Throwable t = exception; t != null && t != t.getCause(); t = t.getCause()) {
String exceptionMessage = t.getMessage();
if (t instanceof AbstractMojoExecutionException) {
String longMessage = ((AbstractMojoExecutionException) t).getLongMessage();
if (longMessage != null && !longMessage.isEmpty()) {
if ((exceptionMessage == null || exceptionMessage.isEmpty())
|| longMessage.contains(exceptionMessage)) {
exceptionMessage = longMessage;
} else if (!exceptionMessage.contains(longMessage)) {
exceptionMessage = join(exceptionMessage, System.lineSeparator() + longMessage);
}
}
}
if (exceptionMessage == null || exceptionMessage.isEmpty()) {
exceptionMessage = t.getClass().getSimpleName();
}
if (t instanceof UnknownHostException && !fullMessage.contains("host")) {
fullMessage = join(fullMessage, "Unknown host " + exceptionMessage);
} else if (!fullMessage.contains(exceptionMessage)) {
fullMessage = join(fullMessage, exceptionMessage);
}
}
return fullMessage.trim();
}
private String join(String message1, String message2) {
String message = "";
if (message1 != null && !message1.isEmpty()) {
message = message1.trim();
}
if (message2 != null && !message2.isEmpty()) {
if (message != null && !message.isEmpty()) {
if (message.endsWith(".") || message.endsWith("!") || message.endsWith(":")) {
message += " ";
} else {
message += ": ";
}
}
message += message2;
}
return message;
}
}
|
String reference = "";
if (exception != null) {
if (exception instanceof MojoExecutionException) {
reference = MojoExecutionException.class.getSimpleName();
Throwable cause = exception.getCause();
if (cause instanceof IOException) {
cause = cause.getCause();
if (cause instanceof ConnectException) {
reference = ConnectException.class.getSimpleName();
}
}
} else if (exception instanceof MojoFailureException) {
reference = MojoFailureException.class.getSimpleName();
} else if (exception instanceof LinkageError) {
reference = LinkageError.class.getSimpleName();
} else if (exception instanceof PluginExecutionException) {
Throwable cause = exception.getCause();
if (cause instanceof PluginContainerException) {
Throwable cause2 = cause.getCause();
if (cause2 instanceof NoClassDefFoundError) {
String message = cause2.getMessage();
if (message != null && message.contains("org/sonatype/aether/")) {
reference = "AetherClassNotFound";
}
}
}
if (reference == null || reference.isEmpty()) {
reference = getReference(cause);
}
if (reference == null || reference.isEmpty()) {
reference = exception.getClass().getSimpleName();
}
} else if (exception instanceof LifecycleExecutionException) {
reference = getReference(exception.getCause());
} else if (isNoteworthyException(exception)) {
reference = exception.getClass().getSimpleName();
}
}
if ((reference != null && !reference.isEmpty()) && !reference.startsWith("http:")) {
reference = "http://cwiki.apache.org/confluence/display/MAVEN/" + reference;
}
return reference;
| 1,179
| 470
| 1,649
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/DefaultBuildResumptionAnalyzer.java
|
DefaultBuildResumptionAnalyzer
|
determineBuildResumptionData
|
class DefaultBuildResumptionAnalyzer implements BuildResumptionAnalyzer {
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultBuildResumptionAnalyzer.class);
@Override
public Optional<BuildResumptionData> determineBuildResumptionData(final MavenExecutionResult result) {<FILL_FUNCTION_BODY>}
}
|
if (!result.hasExceptions()) {
return Optional.empty();
}
List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();
boolean hasNoSuccess =
sortedProjects.stream().noneMatch(project -> result.getBuildSummary(project) instanceof BuildSuccess);
if (hasNoSuccess) {
return Optional.empty();
}
List<String> remainingProjects = sortedProjects.stream()
.filter(project -> result.getBuildSummary(project) == null
|| result.getBuildSummary(project) instanceof BuildFailure)
.map(project -> project.getGroupId() + ":" + project.getArtifactId())
.collect(Collectors.toList());
if (remainingProjects.isEmpty()) {
LOGGER.info("No remaining projects found, resuming the build would not make sense.");
return Optional.empty();
}
return Optional.of(new BuildResumptionData(remainingProjects));
| 84
| 250
| 334
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/DefaultBuildResumptionDataRepository.java
|
DefaultBuildResumptionDataRepository
|
convertToProperties
|
class DefaultBuildResumptionDataRepository implements BuildResumptionDataRepository {
private static final String RESUME_PROPERTIES_FILENAME = "resume.properties";
private static final String REMAINING_PROJECTS = "remainingProjects";
private static final String PROPERTY_DELIMITER = ", ";
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultBuildResumptionDataRepository.class);
@Override
public void persistResumptionData(MavenProject rootProject, BuildResumptionData buildResumptionData)
throws BuildResumptionPersistenceException {
Properties properties = convertToProperties(buildResumptionData);
Path resumeProperties = Paths.get(rootProject.getBuild().getDirectory(), RESUME_PROPERTIES_FILENAME);
try {
Files.createDirectories(resumeProperties.getParent());
try (Writer writer = Files.newBufferedWriter(resumeProperties)) {
properties.store(writer, null);
}
} catch (IOException e) {
String message = "Could not create " + RESUME_PROPERTIES_FILENAME + " file.";
throw new BuildResumptionPersistenceException(message, e);
}
}
private Properties convertToProperties(final BuildResumptionData buildResumptionData) {<FILL_FUNCTION_BODY>}
@Override
public void applyResumptionData(MavenExecutionRequest request, MavenProject rootProject) {
Properties properties =
loadResumptionFile(Paths.get(rootProject.getBuild().getDirectory()));
applyResumptionProperties(request, properties);
}
@Override
public void removeResumptionData(MavenProject rootProject) {
Path resumeProperties = Paths.get(rootProject.getBuild().getDirectory(), RESUME_PROPERTIES_FILENAME);
try {
Files.deleteIfExists(resumeProperties);
} catch (IOException e) {
LOGGER.warn("Could not delete {} file. ", RESUME_PROPERTIES_FILENAME, e);
}
}
private Properties loadResumptionFile(Path rootBuildDirectory) {
Properties properties = new Properties();
Path path = rootBuildDirectory.resolve(RESUME_PROPERTIES_FILENAME);
if (!Files.exists(path)) {
LOGGER.warn("The {} file does not exist. The --resume / -r feature will not work.", path);
return properties;
}
try (Reader reader = Files.newBufferedReader(path)) {
properties.load(reader);
} catch (IOException e) {
LOGGER.warn("Unable to read {}. The --resume / -r feature will not work.", path);
}
return properties;
}
// This method is made package-private for testing purposes
void applyResumptionProperties(MavenExecutionRequest request, Properties properties) {
String str1 = request.getResumeFrom();
if (properties.containsKey(REMAINING_PROJECTS) && !(str1 != null && !str1.isEmpty())) {
String propertyValue = properties.getProperty(REMAINING_PROJECTS);
Stream.of(propertyValue.split(PROPERTY_DELIMITER))
.filter(str -> str != null && !str.isEmpty())
.forEach(request.getProjectActivation()::activateOptionalProject);
LOGGER.info("Resuming from {} due to the --resume / -r feature.", propertyValue);
}
}
}
|
Properties properties = new Properties();
String value = String.join(PROPERTY_DELIMITER, buildResumptionData.getRemainingProjects());
properties.setProperty(REMAINING_PROJECTS, value);
return properties;
| 856
| 64
| 920
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/DefaultMavenExecutionRequestPopulator.java
|
DefaultMavenExecutionRequestPopulator
|
createLocalRepository
|
class DefaultMavenExecutionRequestPopulator implements MavenExecutionRequestPopulator {
private final MavenRepositorySystem repositorySystem;
@Inject
public DefaultMavenExecutionRequestPopulator(MavenRepositorySystem repositorySystem) {
this.repositorySystem = repositorySystem;
}
@Override
public MavenExecutionRequest populateFromToolchains(MavenExecutionRequest request, PersistedToolchains toolchains)
throws MavenExecutionRequestPopulationException {
if (toolchains != null) {
Map<String, List<ToolchainModel>> groupedToolchains = new HashMap<>(2);
for (ToolchainModel model : toolchains.getToolchains()) {
if (!groupedToolchains.containsKey(model.getType())) {
groupedToolchains.put(model.getType(), new ArrayList<>());
}
groupedToolchains.get(model.getType()).add(model);
}
request.setToolchains(groupedToolchains);
}
return request;
}
@Override
public MavenExecutionRequest populateDefaults(MavenExecutionRequest request)
throws MavenExecutionRequestPopulationException {
baseDirectory(request);
localRepository(request);
populateDefaultPluginGroups(request);
return request;
}
//
//
//
private void populateDefaultPluginGroups(MavenExecutionRequest request) {
request.addPluginGroup("org.apache.maven.plugins");
request.addPluginGroup("org.codehaus.mojo");
}
private void localRepository(MavenExecutionRequest request) throws MavenExecutionRequestPopulationException {
// ------------------------------------------------------------------------
// Local Repository
//
// 1. Use a value has been passed in via the configuration
// 2. Use value in the resultant settings
// 3. Use default value
// ------------------------------------------------------------------------
if (request.getLocalRepository() == null) {
request.setLocalRepository(createLocalRepository(request));
}
if (request.getLocalRepositoryPath() == null) {
request.setLocalRepositoryPath(new File(request.getLocalRepository().getBasedir()).getAbsoluteFile());
}
}
// ------------------------------------------------------------------------
// Artifact Transfer Mechanism
// ------------------------------------------------------------------------
private ArtifactRepository createLocalRepository(MavenExecutionRequest request)
throws MavenExecutionRequestPopulationException {<FILL_FUNCTION_BODY>}
private void baseDirectory(MavenExecutionRequest request) {
if (request.getBaseDirectory() == null && request.getPom() != null) {
request.setBaseDirectory(request.getPom().getAbsoluteFile().getParentFile());
}
}
/*if_not[MAVEN4]*/
@Override
@Deprecated
public MavenExecutionRequest populateFromSettings(MavenExecutionRequest request, Settings settings)
throws MavenExecutionRequestPopulationException {
if (settings == null) {
return request;
}
request.setOffline(settings.isOffline());
request.setInteractiveMode(settings.isInteractiveMode());
request.setPluginGroups(settings.getPluginGroups());
request.setLocalRepositoryPath(settings.getLocalRepository());
for (Server server : settings.getServers()) {
server = server.clone();
request.addServer(server);
}
// <proxies>
// <proxy>
// <active>true</active>
// <protocol>http</protocol>
// <host>proxy.somewhere.com</host>
// <port>8080</port>
// <username>proxyuser</username>
// <password>somepassword</password>
// <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
// </proxy>
// </proxies>
for (Proxy proxy : settings.getProxies()) {
if (!proxy.isActive()) {
continue;
}
proxy = proxy.clone();
request.addProxy(proxy);
}
// <mirrors>
// <mirror>
// <id>nexus</id>
// <mirrorOf>*</mirrorOf>
// <url>http://repository.sonatype.org/content/groups/public</url>
// </mirror>
// </mirrors>
for (Mirror mirror : settings.getMirrors()) {
mirror = mirror.clone();
request.addMirror(mirror);
}
request.setActiveProfiles(settings.getActiveProfiles());
for (org.apache.maven.settings.Profile rawProfile : settings.getProfiles()) {
request.addProfile(SettingsUtils.convertFromSettingsProfile(rawProfile));
if (settings.getActiveProfiles().contains(rawProfile.getId())) {
List<Repository> remoteRepositories = rawProfile.getRepositories();
for (Repository remoteRepository : remoteRepositories) {
try {
request.addRemoteRepository(MavenRepositorySystem.buildArtifactRepository(remoteRepository));
} catch (InvalidRepositoryException e) {
// do nothing for now
}
}
List<Repository> pluginRepositories = rawProfile.getPluginRepositories();
for (Repository pluginRepo : pluginRepositories) {
try {
request.addPluginArtifactRepository(MavenRepositorySystem.buildArtifactRepository(pluginRepo));
} catch (InvalidRepositoryException e) {
// do nothing for now
}
}
}
}
return request;
}
/*end[MAVEN4]*/
}
|
String localRepositoryPath = null;
if (request.getLocalRepositoryPath() != null) {
localRepositoryPath = request.getLocalRepositoryPath().getAbsolutePath();
}
if (localRepositoryPath == null || localRepositoryPath.isEmpty()) {
localRepositoryPath = new File(System.getProperty("user.home"), ".m2/repository").getAbsolutePath();
}
try {
return repositorySystem.createLocalRepository(new File(localRepositoryPath));
} catch (Exception e) {
throw new MavenExecutionRequestPopulationException("Cannot create local repository.", e);
}
| 1,451
| 153
| 1,604
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/ProjectActivation.java
|
ProjectActivationSettings
|
addProjectActivation
|
class ProjectActivationSettings {
/**
* The selector of a project. This can be the project directory, [groupId]:[artifactId] or :[artifactId].
*/
final String selector;
/**
* This describes how/when to active or deactivate the project.
*/
final ActivationSettings activationSettings;
ProjectActivationSettings(String selector, ActivationSettings activationSettings) {
this.selector = selector;
this.activationSettings = activationSettings;
}
}
/**
* List of activated and deactivated projects.
*/
private final List<ProjectActivationSettings> activations = new ArrayList<>();
/**
* Adds a project activation to the request.
* @param selector The selector of the project.
* @param active Should the project be activated?
* @param optional Can the build continue if the project does not exist?
*/
public void addProjectActivation(String selector, boolean active, boolean optional) {<FILL_FUNCTION_BODY>
|
final ActivationSettings settings = ActivationSettings.of(active, optional);
this.activations.add(new ProjectActivationSettings(selector, settings));
| 249
| 40
| 289
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/ReactorManager.java
|
ReactorManager
|
blackList
|
class ReactorManager {
public static final String FAIL_FAST = "fail-fast";
public static final String FAIL_AT_END = "fail-at-end";
public static final String FAIL_NEVER = "fail-never";
public static final String MAKE_MODE = "make";
public static final String MAKE_DEPENDENTS_MODE = "make-dependents";
// make projects that depend on me, and projects that I depend on
public static final String MAKE_BOTH_MODE = "make-both";
private List<String> blackList = new ArrayList<>();
private Map<String, BuildFailure> buildFailuresByProject = new HashMap<>();
private Map<String, Map<String, Map>> pluginContextsByProjectAndPluginKey = new HashMap<>();
private String failureBehavior = FAIL_FAST;
private final ProjectSorter sorter;
private Map<String, BuildSuccess> buildSuccessesByProject = new HashMap<>();
public ReactorManager(List<MavenProject> projects) throws CycleDetectedException, DuplicateProjectException {
this.sorter = new ProjectSorter(projects);
}
public Map getPluginContext(PluginDescriptor plugin, MavenProject project) {
Map<String, Map> pluginContextsByKey =
pluginContextsByProjectAndPluginKey.computeIfAbsent(project.getId(), k -> new HashMap<>());
return pluginContextsByKey.computeIfAbsent(plugin.getPluginLookupKey(), k -> new HashMap<>());
}
public void setFailureBehavior(String failureBehavior) {
if (failureBehavior == null) {
this.failureBehavior = FAIL_FAST; // default
return;
}
if (FAIL_FAST.equals(failureBehavior)
|| FAIL_AT_END.equals(failureBehavior)
|| FAIL_NEVER.equals(failureBehavior)) {
this.failureBehavior = failureBehavior;
} else {
throw new IllegalArgumentException("Invalid failure behavior (must be one of: '" + FAIL_FAST + "', '"
+ FAIL_AT_END + "', '" + FAIL_NEVER + "').");
}
}
public String getFailureBehavior() {
return failureBehavior;
}
public void blackList(MavenProject project) {
blackList(getProjectKey(project));
}
private void blackList(String id) {<FILL_FUNCTION_BODY>}
public boolean isBlackListed(MavenProject project) {
return blackList.contains(getProjectKey(project));
}
private static String getProjectKey(MavenProject project) {
return ArtifactUtils.versionlessKey(project.getGroupId(), project.getArtifactId());
}
public void registerBuildFailure(MavenProject project, Exception error, String task, long time) {
buildFailuresByProject.put(getProjectKey(project), new BuildFailure(project, time, error));
}
public boolean hasBuildFailures() {
return !buildFailuresByProject.isEmpty();
}
public boolean hasBuildFailure(MavenProject project) {
return buildFailuresByProject.containsKey(getProjectKey(project));
}
public boolean hasMultipleProjects() {
return sorter.hasMultipleProjects();
}
public List<MavenProject> getSortedProjects() {
return sorter.getSortedProjects();
}
public boolean hasBuildSuccess(MavenProject project) {
return buildSuccessesByProject.containsKey(getProjectKey(project));
}
public void registerBuildSuccess(MavenProject project, long time) {
buildSuccessesByProject.put(getProjectKey(project), new BuildSuccess(project, time));
}
public BuildFailure getBuildFailure(MavenProject project) {
return buildFailuresByProject.get(getProjectKey(project));
}
public BuildSuccess getBuildSuccess(MavenProject project) {
return buildSuccessesByProject.get(getProjectKey(project));
}
public boolean executedMultipleProjects() {
return buildFailuresByProject.size() + buildSuccessesByProject.size() > 1;
}
}
|
if (!blackList.contains(id)) {
blackList.add(id);
List<String> dependents = sorter.getDependents(id);
if (dependents != null && !dependents.isEmpty()) {
for (String dependentId : dependents) {
if (!buildSuccessesByProject.containsKey(dependentId)
&& !buildFailuresByProject.containsKey(dependentId)) {
blackList(dependentId);
}
}
}
}
| 1,084
| 126
| 1,210
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/scope/internal/MojoExecutionScope.java
|
ScopeState
|
scope
|
class ScopeState {
private final Map<Key<?>, Provider<?>> seeded = new HashMap<>();
private final Map<Key<?>, Object> provided = new HashMap<>();
}
private final ThreadLocal<LinkedList<ScopeState>> values = new ThreadLocal<>();
public MojoExecutionScope() {}
public void enter() {
LinkedList<ScopeState> stack = values.get();
if (stack == null) {
stack = new LinkedList<>();
values.set(stack);
}
stack.addFirst(new ScopeState());
}
private ScopeState getScopeState() {
LinkedList<ScopeState> stack = values.get();
if (stack == null || stack.isEmpty()) {
throw new IllegalStateException();
}
return stack.getFirst();
}
public void exit() throws MojoExecutionException {
final LinkedList<ScopeState> stack = values.get();
if (stack == null || stack.isEmpty()) {
throw new IllegalStateException();
}
stack.removeFirst();
if (stack.isEmpty()) {
values.remove();
}
}
public <T> void seed(Class<T> clazz, Provider<T> value) {
getScopeState().seeded.put(Key.get(clazz), value);
}
public <T> void seed(Class<T> clazz, final T value) {
getScopeState().seeded.put(Key.get(clazz), Providers.of(value));
}
public <T> Provider<T> scope(final Key<T> key, final Provider<T> unscoped) {<FILL_FUNCTION_BODY>
|
return () -> {
LinkedList<ScopeState> stack = values.get();
if (stack == null || stack.isEmpty()) {
throw new OutOfScopeException("Cannot access " + key + " outside of a scoping block");
}
ScopeState state = stack.getFirst();
Provider<?> seeded = state.seeded.get(key);
if (seeded != null) {
return (T) seeded.get();
}
T provided = (T) state.provided.get(key);
if (provided == null && unscoped != null) {
provided = unscoped.get();
state.provided.put(key, provided);
}
return provided;
};
| 434
| 192
| 626
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/execution/scope/internal/MojoExecutionScopeModule.java
|
MojoExecutionScopeModule
|
configure
|
class MojoExecutionScopeModule extends AbstractModule {
protected final MojoExecutionScope scope;
public MojoExecutionScopeModule(MojoExecutionScope scope) {
this.scope = scope;
}
@Override
protected void configure() {<FILL_FUNCTION_BODY>}
}
|
bindScope(MojoExecutionScoped.class, scope);
// bindScope(org.apache.maven.api.di.MojoExecutionScoped.class, scope);
bind(MojoExecutionScope.class).toInstance(scope);
bind(MavenProject.class)
.toProvider(MojoExecutionScope.seededKeyProvider())
.in(scope);
bind(MojoExecution.class)
.toProvider(MojoExecutionScope.seededKeyProvider())
.in(scope);
bind(Log.class).toProvider(MojoExecutionScope.seededKeyProvider()).in(scope);
bind(org.apache.maven.api.Project.class)
.toProvider(MojoExecutionScope.seededKeyProvider())
.in(scope);
bind(org.apache.maven.api.MojoExecution.class)
.toProvider(MojoExecutionScope.seededKeyProvider())
.in(scope);
| 75
| 231
| 306
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/extension/internal/CoreExtensionEntry.java
|
CoreExtensionEntry
|
discoverFrom
|
class CoreExtensionEntry {
private final ClassRealm realm;
private final Set<String> artifacts;
private final Set<String> packages;
private final String key;
private final XmlNode configuration;
public CoreExtensionEntry(
ClassRealm realm,
Collection<String> artifacts,
Collection<String> packages,
String key,
XmlNode configuration) {
this.realm = realm;
this.artifacts = Collections.unmodifiableSet(new HashSet<>(artifacts));
this.packages = Collections.unmodifiableSet(new HashSet<>(packages));
this.key = key;
this.configuration = configuration;
}
/**
* Returns ClassLoader used to load extension classes.
*/
public ClassRealm getClassRealm() {
return realm;
}
/**
* Returns artifacts exported by the extension, identified by groupId:artifactId string key.
*/
public Set<String> getExportedArtifacts() {
return artifacts;
}
/**
* Returns classpath elements exported by the extension.
*/
public Set<String> getExportedPackages() {
return packages;
}
/**
* The key that can must used to identify the configuration using the
* {@link javax.inject.Named} annotation.
*/
public String getKey() {
return key;
}
/**
* Returns the configuration for this extension.
*/
public XmlNode getConfiguration() {
return configuration;
}
private static final ExtensionDescriptorBuilder BUILDER = new ExtensionDescriptorBuilder();
public static CoreExtensionEntry discoverFrom(ClassRealm loader) {<FILL_FUNCTION_BODY>}
public static CoreExtensionEntry discoverFrom(
ClassRealm loader, Collection<File> classpath, String key, XmlNode configuration) {
Set<String> artifacts = new LinkedHashSet<>();
Set<String> packages = new LinkedHashSet<>();
try {
for (File entry : classpath) {
ExtensionDescriptor descriptor = BUILDER.build(entry);
if (descriptor != null) {
artifacts.addAll(descriptor.getExportedArtifacts());
packages.addAll(descriptor.getExportedPackages());
}
}
} catch (IOException ignored) {
// exports descriptors are entirely optional
}
return new CoreExtensionEntry(loader, artifacts, packages, key, configuration);
}
}
|
Set<String> artifacts = new LinkedHashSet<>();
Set<String> packages = new LinkedHashSet<>();
try {
Enumeration<URL> urls = loader.getResources(BUILDER.getExtensionDescriptorLocation());
while (urls.hasMoreElements()) {
try (InputStream is = urls.nextElement().openStream()) {
ExtensionDescriptor descriptor = BUILDER.build(is);
artifacts.addAll(descriptor.getExportedArtifacts());
packages.addAll(descriptor.getExportedPackages());
}
}
} catch (IOException ignored) {
// exports descriptors are entirely optional
}
return new CoreExtensionEntry(loader, artifacts, packages, null, null);
| 630
| 187
| 817
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/graph/DefaultProjectDependencyGraph.java
|
DefaultProjectDependencyGraph
|
getUpstreamProjects
|
class DefaultProjectDependencyGraph implements ProjectDependencyGraph {
private final ProjectSorter sorter;
private final List<MavenProject> allProjects;
private final Map<MavenProject, Integer> order;
private final Map<String, MavenProject> projects;
/**
* Creates a new project dependency graph based on the specified projects.
*
* @param projects The projects to create the dependency graph with
* @throws DuplicateProjectException
* @throws CycleDetectedException
*/
public DefaultProjectDependencyGraph(Collection<MavenProject> projects)
throws CycleDetectedException, DuplicateProjectException {
this(projects, projects);
}
/**
* Creates a new project dependency graph based on the specified projects.
*
* @param allProjects All collected projects.
* @param projects The projects to create the dependency graph with.
* @throws DuplicateProjectException
* @throws CycleDetectedException
* @since 3.5.0
* @deprecated Use {@link #DefaultProjectDependencyGraph(Collection, Collection)} instead.
*/
@Deprecated
public DefaultProjectDependencyGraph(List<MavenProject> allProjects, Collection<MavenProject> projects)
throws CycleDetectedException, DuplicateProjectException {
this((Collection<MavenProject>) allProjects, projects);
}
/**
* Creates a new project dependency graph based on the specified projects.
*
* @param allProjects All collected projects.
* @param projects The projects to create the dependency graph with.
* @throws DuplicateProjectException
* @throws CycleDetectedException
* @since 4.0.0
*/
public DefaultProjectDependencyGraph(Collection<MavenProject> allProjects, Collection<MavenProject> projects)
throws CycleDetectedException, DuplicateProjectException {
this.allProjects = Collections.unmodifiableList(new ArrayList<>(allProjects));
this.sorter = new ProjectSorter(projects);
this.order = new HashMap<>();
this.projects = new HashMap<>();
List<MavenProject> sorted = this.sorter.getSortedProjects();
for (int index = 0; index < sorted.size(); index++) {
MavenProject project = sorted.get(index);
String id = ProjectSorter.getId(project);
this.projects.put(id, project);
this.order.put(project, index);
}
}
/**
* @since 3.5.0
*/
public List<MavenProject> getAllProjects() {
return this.allProjects;
}
public List<MavenProject> getSortedProjects() {
return new ArrayList<>(sorter.getSortedProjects());
}
public List<MavenProject> getDownstreamProjects(MavenProject project, boolean transitive) {
Objects.requireNonNull(project, "project cannot be null");
Set<String> projectIds = new HashSet<>();
getDownstreamProjects(ProjectSorter.getId(project), projectIds, transitive);
return getSortedProjects(projectIds);
}
private void getDownstreamProjects(String projectId, Set<String> projectIds, boolean transitive) {
for (String id : sorter.getDependents(projectId)) {
if (projectIds.add(id) && transitive) {
getDownstreamProjects(id, projectIds, transitive);
}
}
}
public List<MavenProject> getUpstreamProjects(MavenProject project, boolean transitive) {
Objects.requireNonNull(project, "project cannot be null");
Set<String> projectIds = new HashSet<>();
getUpstreamProjects(ProjectSorter.getId(project), projectIds, transitive);
return getSortedProjects(projectIds);
}
private void getUpstreamProjects(String projectId, Collection<String> projectIds, boolean transitive) {<FILL_FUNCTION_BODY>}
private List<MavenProject> getSortedProjects(Set<String> projectIds) {
return projectIds.stream()
.map(projects::get)
.sorted(Comparator.comparingInt(order::get))
.collect(Collectors.toList());
}
@Override
public String toString() {
return sorter.getSortedProjects().toString();
}
}
|
for (String id : sorter.getDependencies(projectId)) {
if (projectIds.add(id) && transitive) {
getUpstreamProjects(id, projectIds, transitive);
}
}
| 1,126
| 59
| 1,185
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/graph/FilteredProjectDependencyGraph.java
|
FilteredProjectDependencyGraph
|
getSortedProjects
|
class FilteredProjectDependencyGraph implements ProjectDependencyGraph {
private ProjectDependencyGraph projectDependencyGraph;
private Map<MavenProject, ?> whiteList;
private List<MavenProject> sortedProjects;
/**
* Creates a new project dependency graph from the specified graph.
*
* @param projectDependencyGraph The project dependency graph to create a sub view from, must not be {@code null}.
* @param whiteList The projects on which the dependency view should focus, must not be {@code null}.
*/
FilteredProjectDependencyGraph(
ProjectDependencyGraph projectDependencyGraph, Collection<? extends MavenProject> whiteList) {
this.projectDependencyGraph =
Objects.requireNonNull(projectDependencyGraph, "projectDependencyGraph cannot be null");
this.whiteList = new IdentityHashMap<>();
for (MavenProject project : whiteList) {
this.whiteList.put(project, null);
}
}
/**
* @since 3.5.0
*/
public List<MavenProject> getAllProjects() {
return this.projectDependencyGraph.getAllProjects();
}
public List<MavenProject> getSortedProjects() {<FILL_FUNCTION_BODY>}
public List<MavenProject> getDownstreamProjects(MavenProject project, boolean transitive) {
return applyFilter(projectDependencyGraph.getDownstreamProjects(project, transitive));
}
public List<MavenProject> getUpstreamProjects(MavenProject project, boolean transitive) {
return applyFilter(projectDependencyGraph.getUpstreamProjects(project, transitive));
}
private List<MavenProject> applyFilter(Collection<? extends MavenProject> projects) {
List<MavenProject> filtered = new ArrayList<>(projects.size());
for (MavenProject project : projects) {
if (whiteList.containsKey(project)) {
filtered.add(project);
}
}
return filtered;
}
@Override
public String toString() {
return getSortedProjects().toString();
}
}
|
if (sortedProjects == null) {
sortedProjects = applyFilter(projectDependencyGraph.getSortedProjects());
}
return new ArrayList<>(sortedProjects);
| 533
| 50
| 583
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/graph/ProjectSelector.java
|
ProjectSelector
|
getOptionalProjectsBySelectors
|
class ProjectSelector {
private static final Logger LOGGER = LoggerFactory.getLogger(ProjectSelector.class);
public Set<MavenProject> getRequiredProjectsBySelectors(
MavenExecutionRequest request, List<MavenProject> projects, Set<String> projectSelectors)
throws MavenExecutionException {
Set<MavenProject> selectedProjects = new LinkedHashSet<>();
File baseDirectory = getBaseDirectoryFromRequest(request);
for (String selector : projectSelectors) {
Optional<MavenProject> optSelectedProject =
findOptionalProjectBySelector(projects, baseDirectory, selector);
if (!optSelectedProject.isPresent()) {
String message = "Could not find the selected project in the reactor: " + selector;
throw new MavenExecutionException(message, request.getPom());
}
MavenProject selectedProject = optSelectedProject.get();
selectedProjects.add(selectedProject);
selectedProjects.addAll(getChildProjects(selectedProject, request));
}
return selectedProjects;
}
public Set<MavenProject> getOptionalProjectsBySelectors(
MavenExecutionRequest request, List<MavenProject> projects, Set<String> projectSelectors) {<FILL_FUNCTION_BODY>}
private List<MavenProject> getChildProjects(MavenProject parent, MavenExecutionRequest request) {
final List<MavenProject> children = parent.getCollectedProjects();
if (children != null && request.isRecursive()) {
return children;
} else {
return new ArrayList<>();
}
}
private Optional<MavenProject> findOptionalProjectBySelector(
List<MavenProject> projects, File reactorDirectory, String selector) {
return projects.stream()
.filter(project -> isMatchingProject(project, selector, reactorDirectory))
.findFirst();
}
File getBaseDirectoryFromRequest(MavenExecutionRequest request) {
return request.getBaseDirectory() != null ? new File(request.getBaseDirectory()) : null;
}
boolean isMatchingProject(MavenProject project, String selector, File reactorDirectory) {
// [groupId]:artifactId
if (selector.contains(":")) {
String id = ':' + project.getArtifactId();
if (id.equals(selector)) {
return true;
}
id = project.getGroupId() + id;
return id.equals(selector);
}
// relative path, e.g. "sub", "../sub" or "."
else if (reactorDirectory != null) {
File selectedProject =
new File(new File(reactorDirectory, selector).toURI().normalize());
if (selectedProject.isFile()) {
return selectedProject.equals(project.getFile());
} else if (selectedProject.isDirectory()) {
return selectedProject.equals(project.getBasedir());
}
}
return false;
}
}
|
Set<MavenProject> resolvedOptionalProjects = new LinkedHashSet<>();
Set<String> unresolvedOptionalSelectors = new HashSet<>();
File baseDirectory = getBaseDirectoryFromRequest(request);
for (String selector : projectSelectors) {
Optional<MavenProject> optSelectedProject =
findOptionalProjectBySelector(projects, baseDirectory, selector);
if (optSelectedProject.isPresent()) {
resolvedOptionalProjects.add(optSelectedProject.get());
resolvedOptionalProjects.addAll(getChildProjects(optSelectedProject.get(), request));
} else {
unresolvedOptionalSelectors.add(selector);
}
}
if (!unresolvedOptionalSelectors.isEmpty()) {
LOGGER.info("The requested optional projects {} do not exist.", unresolvedOptionalSelectors);
}
return resolvedOptionalProjects;
| 752
| 214
| 966
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/MultilineMessageHelper.java
|
MultilineMessageHelper
|
separatorLine
|
class MultilineMessageHelper {
private static final int DEFAULT_MAX_SIZE = 65;
private static final char BOX_CHAR = '*';
private static final Pattern S_FILTER = Pattern.compile("\\s+");
public static String separatorLine() {<FILL_FUNCTION_BODY>}
public static List<String> format(String... lines) {
int size = DEFAULT_MAX_SIZE;
int remainder = size - 4; // 4 chars = 2 box_char + 2 spaces
List<String> result = new ArrayList<>();
StringBuilder sb = new StringBuilder(size);
// first line
sb.setLength(0);
repeat(sb, BOX_CHAR, size);
result.add(sb.toString());
// lines
for (String line : lines) {
sb.setLength(0);
String[] words = S_FILTER.split(line);
for (String word : words) {
if (sb.length() >= remainder - word.length() - (sb.length() > 0 ? 1 : 0)) {
repeat(sb, ' ', remainder - sb.length());
result.add(BOX_CHAR + " " + sb + " " + BOX_CHAR);
sb.setLength(0);
}
if (sb.length() > 0) {
sb.append(' ');
}
sb.append(word);
}
while (sb.length() < remainder) {
sb.append(' ');
}
result.add(BOX_CHAR + " " + sb + " " + BOX_CHAR);
}
// last line
sb.setLength(0);
repeat(sb, BOX_CHAR, size);
result.add(sb.toString());
return result;
}
private static void repeat(StringBuilder sb, char c, int nb) {
for (int i = 0; i < nb; i++) {
sb.append(c);
}
}
}
|
StringBuilder sb = new StringBuilder(DEFAULT_MAX_SIZE);
repeat(sb, '*', DEFAULT_MAX_SIZE);
return sb.toString();
| 509
| 41
| 550
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/aether/LegacyRepositorySystemSessionExtender.java
|
LegacyRepositorySystemSessionExtender
|
injectMirror
|
class LegacyRepositorySystemSessionExtender implements RepositorySystemSessionExtender {
@Override
public void extend(
MavenExecutionRequest mavenExecutionRequest,
Map<String, Object> configProperties,
MirrorSelector mirrorSelector,
ProxySelector proxySelector,
AuthenticationSelector authenticationSelector) {
injectMirror(mavenExecutionRequest.getRemoteRepositories(), mavenExecutionRequest.getMirrors());
injectProxy(proxySelector, mavenExecutionRequest.getRemoteRepositories());
injectAuthentication(authenticationSelector, mavenExecutionRequest.getRemoteRepositories());
injectMirror(mavenExecutionRequest.getPluginArtifactRepositories(), mavenExecutionRequest.getMirrors());
injectProxy(proxySelector, mavenExecutionRequest.getPluginArtifactRepositories());
injectAuthentication(authenticationSelector, mavenExecutionRequest.getPluginArtifactRepositories());
}
private void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {
if (repositories != null && mirrors != null) {
for (ArtifactRepository repository : repositories) {
Mirror mirror = MavenRepositorySystem.getMirror(repository, mirrors);
injectMirror(repository, mirror);
}
}
}
private void injectMirror(ArtifactRepository repository, Mirror mirror) {<FILL_FUNCTION_BODY>}
private void injectProxy(ProxySelector selector, List<ArtifactRepository> repositories) {
if (repositories != null && selector != null) {
for (ArtifactRepository repository : repositories) {
repository.setProxy(getProxy(selector, repository));
}
}
}
private org.apache.maven.repository.Proxy getProxy(ProxySelector selector, ArtifactRepository repository) {
if (selector != null) {
RemoteRepository repo = RepositoryUtils.toRepo(repository);
org.eclipse.aether.repository.Proxy proxy = selector.getProxy(repo);
if (proxy != null) {
org.apache.maven.repository.Proxy p = new org.apache.maven.repository.Proxy();
p.setHost(proxy.getHost());
p.setProtocol(proxy.getType());
p.setPort(proxy.getPort());
if (proxy.getAuthentication() != null) {
repo = new RemoteRepository.Builder(repo).setProxy(proxy).build();
AuthenticationContext authCtx = AuthenticationContext.forProxy(null, repo);
p.setUserName(authCtx.get(AuthenticationContext.USERNAME));
p.setPassword(authCtx.get(AuthenticationContext.PASSWORD));
p.setNtlmDomain(authCtx.get(AuthenticationContext.NTLM_DOMAIN));
p.setNtlmHost(authCtx.get(AuthenticationContext.NTLM_WORKSTATION));
authCtx.close();
}
return p;
}
}
return null;
}
private void injectAuthentication(AuthenticationSelector selector, List<ArtifactRepository> repositories) {
if (repositories != null && selector != null) {
for (ArtifactRepository repository : repositories) {
repository.setAuthentication(getAuthentication(selector, repository));
}
}
}
private Authentication getAuthentication(AuthenticationSelector selector, ArtifactRepository repository) {
if (selector != null) {
RemoteRepository repo = RepositoryUtils.toRepo(repository);
org.eclipse.aether.repository.Authentication auth = selector.getAuthentication(repo);
if (auth != null) {
repo = new RemoteRepository.Builder(repo)
.setAuthentication(auth)
.build();
AuthenticationContext authCtx = AuthenticationContext.forRepository(null, repo);
Authentication result = new Authentication(
authCtx.get(AuthenticationContext.USERNAME), authCtx.get(AuthenticationContext.PASSWORD));
result.setPrivateKey(authCtx.get(AuthenticationContext.PRIVATE_KEY_PATH));
result.setPassphrase(authCtx.get(AuthenticationContext.PRIVATE_KEY_PASSPHRASE));
authCtx.close();
return result;
}
}
return null;
}
}
|
if (mirror != null) {
ArtifactRepository original = MavenRepositorySystem.createArtifactRepository(
repository.getId(),
repository.getUrl(),
repository.getLayout(),
repository.getSnapshots(),
repository.getReleases());
repository.setMirroredRepositories(Collections.singletonList(original));
repository.setId(mirror.getId());
repository.setUrl(mirror.getUrl());
if (mirror.getLayout() != null && !mirror.getLayout().isEmpty()) {
repository.setLayout(original.getLayout());
}
repository.setBlocked(mirror.isBlocked());
}
| 1,061
| 176
| 1,237
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/aether/LoggingRepositoryListener.java
|
LoggingRepositoryListener
|
metadataResolved
|
class LoggingRepositoryListener extends AbstractRepositoryListener {
private final Logger logger;
LoggingRepositoryListener(Logger logger) {
this.logger = logger;
}
@Override
public void artifactInstalling(RepositoryEvent event) {
logger.info("Installing {} to {}", event.getArtifact().getFile(), event.getFile());
}
@Override
public void metadataInstalling(RepositoryEvent event) {
logger.debug("Installing {} to {}", event.getMetadata(), event.getFile());
}
@Override
public void metadataResolved(RepositoryEvent event) {<FILL_FUNCTION_BODY>}
@Override
public void metadataInvalid(RepositoryEvent event) {
Exception exception = event.getException();
Object metadata;
if (event.getMetadata().getFile() != null) {
metadata = event.getMetadata().getFile();
} else {
metadata = event.getMetadata();
}
String errorType = " is invalid";
if (exception instanceof FileNotFoundException) {
errorType = " is inaccessible";
}
String msg = "";
if (exception != null) {
msg = ": " + exception.getMessage();
}
if (logger.isDebugEnabled()) {
logger.warn("The metadata {} {}{}", metadata, errorType, msg, exception);
} else {
logger.warn("The metadata {} {}{}", metadata, errorType, msg);
}
}
@Override
public void artifactDescriptorInvalid(RepositoryEvent event) {
// The exception stack trace is not really interesting here
// but the message itself may be quite details and span multiple
// lines with errors in it, so only display it at debug level.
String msg = "The POM for {} is invalid, transitive dependencies (if any) will not be available: {}";
if (logger.isDebugEnabled()) {
logger.warn(msg, event.getArtifact(), event.getException().getMessage());
} else {
logger.warn(msg, event.getArtifact(), "enable verbose output (-X) for more details");
}
}
@Override
public void artifactDescriptorMissing(RepositoryEvent event) {
logger.warn("The POM for {} is missing, no dependency information available", event.getArtifact());
}
}
|
Exception e = event.getException();
if (e != null) {
if (e instanceof MetadataNotFoundException) {
logger.debug(e.getMessage());
} else if (logger.isDebugEnabled()) {
logger.warn(e.getMessage(), e);
} else {
logger.warn(e.getMessage());
}
}
| 579
| 91
| 670
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/aether/PropertyContributorExtender.java
|
PropertyContributorExtender
|
extend
|
class PropertyContributorExtender implements MavenExecutionRequestExtender {
private final Lookup lookup;
@Inject
PropertyContributorExtender(Lookup lookup) {
this.lookup = lookup;
}
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
public void extend(MavenExecutionRequest mavenExecutionRequest) {<FILL_FUNCTION_BODY>}
}
|
Map<String, PropertyContributor> effectivePropertyContributors = lookup.lookupMap(PropertyContributor.class);
if (!effectivePropertyContributors.isEmpty()) {
HashMap<String, String> userPropertiesMap = new HashMap<>((Map) mavenExecutionRequest.getUserProperties());
for (PropertyContributor contributor : effectivePropertyContributors.values()) {
contributor.contribute(userPropertiesMap);
}
Properties newProperties = new Properties();
newProperties.putAll(userPropertiesMap);
mavenExecutionRequest.setUserProperties(newProperties);
}
| 109
| 148
| 257
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/aether/ReverseTreeRepositoryListener.java
|
ReverseTreeRepositoryListener
|
isInScope
|
class ReverseTreeRepositoryListener extends AbstractRepositoryListener {
@Override
public void artifactResolved(RepositoryEvent event) {
requireNonNull(event, "event cannot be null");
if (!isLocalRepositoryArtifactOrMissing(event.getSession(), event.getArtifact())) {
return;
}
RequestTrace trace = event.getTrace();
CollectStepData collectStepTrace = null;
ArtifactRequest artifactRequest = null;
ArtifactDescriptorRequest artifactDescriptorRequest = null;
Plugin plugin = null;
while (trace != null) {
Object data = trace.getData();
if (data instanceof CollectStepData) {
collectStepTrace = (CollectStepData) data;
} else if (data instanceof ArtifactDescriptorRequest) {
artifactDescriptorRequest = (ArtifactDescriptorRequest) data;
} else if (data instanceof ArtifactRequest) {
artifactRequest = (ArtifactRequest) data;
} else if (data instanceof Plugin) {
plugin = (Plugin) data;
}
trace = trace.getParent();
}
Path trackingDir;
boolean missing = event.getFile() == null;
if (missing) {
// missing artifact - let's track the path anyway
File dir = event.getSession().getLocalRepository().getBasedir();
dir = new File(
dir, event.getSession().getLocalRepositoryManager().getPathForLocalArtifact(event.getArtifact()));
trackingDir = dir.getParentFile().toPath().resolve(".tracking");
} else {
trackingDir = event.getFile().getParentFile().toPath().resolve(".tracking");
}
String baseName;
String ext = missing ? ".miss" : ".dep";
Path trackingFile = null;
String indent = "";
ArrayList<String> trackingData = new ArrayList<>();
if (collectStepTrace == null && plugin != null) {
ext = ".plugin";
baseName = plugin.getGroupId() + "_" + plugin.getArtifactId() + "_" + plugin.getVersion();
trackingFile = trackingDir.resolve(baseName + ext);
if (Files.exists(trackingFile)) {
return;
}
if (event.getArtifact() != null) {
trackingData.add(indent + event.getArtifact());
indent += " ";
}
trackingData.add(indent + plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion());
indent += " ";
InputLocation location = plugin.getLocation("");
if (location != null && location.getSource() != null) {
trackingData.add(indent + location.getSource().getModelId() + " (implicit)");
indent += " ";
}
} else if (collectStepTrace != null) {
if (collectStepTrace.getPath().get(0).getArtifact() == null) {
return;
}
baseName = ArtifactIdUtils.toId(collectStepTrace.getPath().get(0).getArtifact())
.replace(":", "_");
trackingFile = trackingDir.resolve(baseName + ext);
if (Files.exists(trackingFile)) {
return;
}
Artifact resolvedArtifact = event.getArtifact();
Artifact nodeArtifact = collectStepTrace.getNode().getArtifact();
if (isInScope(resolvedArtifact, nodeArtifact) || "pom".equals(resolvedArtifact.getExtension())) {
Dependency node = collectStepTrace.getNode();
trackingData.add(resolvedArtifact.toString());
indent += " ";
trackingData.add(indent + node + " (" + collectStepTrace.getContext() + ")");
ListIterator<DependencyNode> iter = collectStepTrace
.getPath()
.listIterator(collectStepTrace.getPath().size());
while (iter.hasPrevious()) {
DependencyNode curr = iter.previous();
indent += " ";
trackingData.add(indent + curr + " (" + collectStepTrace.getContext() + ")");
}
}
}
if (trackingFile == null) {
return;
}
try {
Files.createDirectories(trackingDir);
trackingData.add("");
if (!missing) {
if (event.getRepository() != null) {
trackingData.add("Repository: " + event.getRepository());
}
} else {
List<RemoteRepository> repositories = new ArrayList<>();
if (artifactRequest != null && artifactRequest.getRepositories() != null) {
repositories.addAll(artifactRequest.getRepositories());
} else if (artifactDescriptorRequest != null && artifactDescriptorRequest.getRepositories() != null) {
repositories.addAll(artifactDescriptorRequest.getRepositories());
}
if (!repositories.isEmpty()) {
trackingData.add("Configured repositories:");
for (RemoteRepository r : repositories) {
trackingData.add(" - " + r.getId() + " : " + r.getUrl());
}
} else {
trackingData.add("No repositories configured");
}
}
Files.write(trackingFile, trackingData, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
/**
* Returns {@code true} if passed in artifact is originating from local repository. In other words, we want
* to process and store tracking information ONLY into local repository, not to any other place. This method
* filters out currently built artifacts, as events are fired for them as well, but their resolved artifact
* file would point to checked out source-tree, not the local repository.
* <p>
* Visible for testing.
*/
static boolean isLocalRepositoryArtifactOrMissing(RepositorySystemSession session, Artifact artifact) {
return artifact.getFile() == null
|| artifact.getFile()
.getPath()
.startsWith(session.getLocalRepository().getBasedir().getPath());
}
/**
* Unravels trace tree (going upwards from current node), looking for {@link CollectStepData} trace data.
* This method may return {@code null} if no collect step data found in passed trace data or it's parents.
* <p>
* Visible for testing.
*/
static CollectStepData lookupCollectStepData(RequestTrace trace) {
CollectStepData collectStepTrace = null;
while (trace != null) {
if (trace.getData() instanceof CollectStepData) {
collectStepTrace = (CollectStepData) trace.getData();
break;
}
trace = trace.getParent();
}
return collectStepTrace;
}
/**
* The event "artifact resolved" if fired WHENEVER an artifact is resolved, BUT it happens also when an artifact
* descriptor (model, the POM) is being built, and parent (and parent of parent...) is being asked for. Hence, this
* method "filters" out in WHICH artifact are we interested in, but it intentionally neglects extension as
* ArtifactDescriptorReader modifies extension to "pom" during collect. So all we have to rely on is GAV only.
*/
static boolean isInScope(Artifact artifact, Artifact nodeArtifact) {<FILL_FUNCTION_BODY>}
}
|
return Objects.equals(artifact.getGroupId(), nodeArtifact.getGroupId())
&& Objects.equals(artifact.getArtifactId(), nodeArtifact.getArtifactId())
&& Objects.equals(artifact.getVersion(), nodeArtifact.getVersion());
| 1,873
| 69
| 1,942
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/aether/TypeRegistryAdapter.java
|
TypeRegistryAdapter
|
get
|
class TypeRegistryAdapter implements ArtifactTypeRegistry {
private final TypeRegistry typeRegistry;
TypeRegistryAdapter(TypeRegistry typeRegistry) {
this.typeRegistry = requireNonNull(typeRegistry, "typeRegistry");
}
@Override
public ArtifactType get(String typeId) {<FILL_FUNCTION_BODY>}
}
|
Type type = typeRegistry.require(typeId);
if (type instanceof ArtifactType) {
return (ArtifactType) type;
}
if (type != null) {
return new DefaultType(
type.id(),
type.getLanguage(),
type.getExtension(),
type.getClassifier(),
type.isIncludesDependencies(),
type.getPathTypes().toArray(new PathType[0]));
}
return null;
| 86
| 121
| 207
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultArtifactManager.java
|
DefaultArtifactManager
|
setPath
|
class DefaultArtifactManager implements ArtifactManager {
@Nonnull
private final InternalMavenSession session;
private final Map<String, Path> paths = new ConcurrentHashMap<>();
@Inject
public DefaultArtifactManager(@Nonnull InternalMavenSession session) {
this.session = session;
}
@Nonnull
@Override
public Optional<Path> getPath(@Nonnull Artifact artifact) {
String id = id(nonNull(artifact, "artifact"));
if (session.getMavenSession().getAllProjects() != null) {
for (MavenProject project : session.getMavenSession().getAllProjects()) {
if (id.equals(id(project.getArtifact()))
&& project.getArtifact().getFile() != null) {
return Optional.of(project.getArtifact().getFile().toPath());
}
}
}
Path path = paths.get(id);
if (path == null && artifact instanceof DefaultArtifact) {
File file = ((DefaultArtifact) artifact).getArtifact().getFile();
if (file != null) {
path = file.toPath();
}
}
return Optional.ofNullable(path);
}
@Override
public void setPath(@Nonnull Artifact artifact, Path path) {<FILL_FUNCTION_BODY>}
/**
* Retrieve a stream of the project's artifacts.
* Do not include the POM artifact as the file can't be set anyway.
*/
private Stream<org.apache.maven.artifact.Artifact> getProjectArtifacts(MavenProject project) {
return Stream.concat(Stream.of(project.getArtifact()), project.getAttachedArtifacts().stream());
}
private String id(org.apache.maven.artifact.Artifact artifact) {
return artifact.getGroupId()
+ ":" + artifact.getArtifactId()
+ ":" + artifact.getArtifactHandler().getExtension()
+ (artifact.getClassifier() == null || artifact.getClassifier().isEmpty()
? ""
: ":" + artifact.getClassifier())
+ ":" + artifact.getVersion();
}
private String id(Artifact artifact) {
return artifact.key();
}
}
|
String id = id(nonNull(artifact, "artifact"));
if (session.getMavenSession().getAllProjects() != null) {
session.getMavenSession().getAllProjects().stream()
.flatMap(this::getProjectArtifacts)
.filter(a -> Objects.equals(id, id(a)))
.forEach(a -> a.setFile(path != null ? path.toFile() : null));
}
if (path == null) {
paths.remove(id);
} else {
paths.put(id, path);
}
| 578
| 152
| 730
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultDependencyResolver.java
|
DefaultDependencyResolver
|
resolve
|
class DefaultDependencyResolver implements DependencyResolver {
@Override
public List<Node> flatten(Session s, Node node, PathScope scope) throws DependencyResolverException {
InternalSession session = InternalSession.from(s);
DependencyNode root = cast(AbstractNode.class, node, "node").getDependencyNode();
List<DependencyNode> dependencies = session.getRepositorySystem()
.flattenDependencyNodes(session.getSession(), root, getScopeDependencyFilter(scope));
dependencies.remove(root);
return map(dependencies, session::getNode);
}
private static DependencyFilter getScopeDependencyFilter(PathScope scope) {
Set<String> scopes =
scope.dependencyScopes().stream().map(DependencyScope::id).collect(Collectors.toSet());
return (n, p) -> {
org.eclipse.aether.graph.Dependency d = n.getDependency();
return d == null || scopes.contains(d.getScope());
};
}
/**
* Collects, flattens and resolves the dependencies.
*
* @param request the request to resolve
* @return the result of the resolution
*/
@Override
public DependencyResolverResult resolve(DependencyResolverRequest request)
throws DependencyCollectorException, DependencyResolverException, ArtifactResolverException {<FILL_FUNCTION_BODY>}
private static DependencyResolverException cannotReadModuleInfo(final Path path, final IOException cause) {
return new DependencyResolverException("Cannot read module information of " + path, cause);
}
}
|
InternalSession session =
InternalSession.from(nonNull(request, "request").getSession());
Predicate<PathType> filter = request.getPathTypeFilter();
PathModularizationCache cache = new PathModularizationCache(); // TODO: should be project-wide cache.
DependencyCollectorResult collectorResult =
session.getService(DependencyCollector.class).collect(request);
List<Node> nodes = flatten(session, collectorResult.getRoot(), request.getPathScope());
List<ArtifactCoordinate> coordinates = nodes.stream()
.map(Node::getDependency)
.filter(Objects::nonNull)
.map(Artifact::toCoordinate)
.collect(Collectors.toList());
Map<Artifact, Path> artifacts = session.resolveArtifacts(coordinates);
DefaultDependencyResolverResult result = new DefaultDependencyResolverResult(
collectorResult.getExceptions(), collectorResult.getRoot(), nodes.size());
for (Node node : nodes) {
Dependency d = node.getDependency();
Path path = (d != null) ? artifacts.get(d) : null;
try {
result.addDependency(node, d, filter, path, cache);
} catch (IOException e) {
throw cannotReadModuleInfo(path, e);
}
}
return result;
| 394
| 333
| 727
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultLifecycleRegistry.java
|
LifecycleWrapperProvider
|
wrap
|
class LifecycleWrapperProvider implements LifecycleProvider {
private final Map<String, org.apache.maven.lifecycle.Lifecycle> lifecycles;
@Inject
LifecycleWrapperProvider(Map<String, org.apache.maven.lifecycle.Lifecycle> lifecycles) {
this.lifecycles = lifecycles;
}
@Override
public Collection<Lifecycle> provides() {
return lifecycles.values().stream().map(this::wrap).collect(Collectors.toList());
}
private Lifecycle wrap(org.apache.maven.lifecycle.Lifecycle lifecycle) {<FILL_FUNCTION_BODY>}
}
|
return new Lifecycle() {
@Override
public String id() {
return lifecycle.getId();
}
@Override
public Collection<Phase> phases() {
// TODO: implement
throw new UnsupportedOperationException();
}
};
| 195
| 73
| 268
|
<methods>public Optional<org.apache.maven.api.Lifecycle> lookup(java.lang.String) <variables>protected final non-sealed Map<java.lang.String,org.apache.maven.api.Lifecycle> values
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultLookup.java
|
DefaultLookup
|
lookupOptional
|
class DefaultLookup implements Lookup {
private final PlexusContainer container;
@Inject
public DefaultLookup(PlexusContainer container) {
this.container = container;
}
@Override
public <T> T lookup(Class<T> type) {
try {
return container.lookup(type);
} catch (ComponentLookupException e) {
throw new LookupException(e);
}
}
@Override
public <T> T lookup(Class<T> type, String name) {
try {
return container.lookup(type, name);
} catch (ComponentLookupException e) {
throw new LookupException(e);
}
}
@Override
public <T> Optional<T> lookupOptional(Class<T> type) {
try {
return Optional.of(container.lookup(type));
} catch (ComponentLookupException e) {
if (e.getCause() instanceof NoSuchElementException) {
return Optional.empty();
}
throw new LookupException(e);
}
}
@Override
public <T> Optional<T> lookupOptional(Class<T> type, String name) {<FILL_FUNCTION_BODY>}
@Override
public <T> List<T> lookupList(Class<T> type) {
try {
return container.lookupList(type);
} catch (ComponentLookupException e) {
throw new LookupException(e);
}
}
@Override
public <T> Map<String, T> lookupMap(Class<T> type) {
try {
return container.lookupMap(type);
} catch (ComponentLookupException e) {
throw new LookupException(e);
}
}
}
|
try {
return Optional.of(container.lookup(type, name));
} catch (ComponentLookupException e) {
if (e.getCause() instanceof NoSuchElementException) {
return Optional.empty();
}
throw new LookupException(e);
}
| 460
| 75
| 535
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultMojoExecution.java
|
DefaultMojoExecution
|
getPlugin
|
class DefaultMojoExecution implements MojoExecution {
private final InternalMavenSession session;
private final org.apache.maven.plugin.MojoExecution delegate;
public DefaultMojoExecution(InternalMavenSession session, org.apache.maven.plugin.MojoExecution delegate) {
this.session = session;
this.delegate = delegate;
}
public org.apache.maven.plugin.MojoExecution getDelegate() {
return delegate;
}
@Override
public Plugin getPlugin() {<FILL_FUNCTION_BODY>}
@Override
public PluginExecution getModel() {
return delegate.getPlugin().getExecutions().stream()
.filter(pe -> Objects.equals(pe.getId(), getExecutionId()))
.findFirst()
.map(org.apache.maven.model.PluginExecution::getDelegate)
.orElse(null);
}
@Override
public MojoDescriptor getDescriptor() {
return delegate.getMojoDescriptor().getMojoDescriptorV4();
}
@Override
public String getLifecyclePhase() {
return delegate.getLifecyclePhase();
}
@Override
public String getExecutionId() {
return delegate.getExecutionId();
}
@Override
public String getGoal() {
return delegate.getGoal();
}
@Override
public Optional<XmlNode> getConfiguration() {
return Optional.of(delegate.getConfiguration()).map(Xpp3Dom::getDom);
}
@Override
public String toString() {
return delegate.toString();
}
}
|
return new Plugin() {
@Override
public org.apache.maven.api.model.Plugin getModel() {
return delegate.getPlugin().getDelegate();
}
@Override
public PluginDescriptor getDescriptor() {
return delegate.getMojoDescriptor().getPluginDescriptor().getPluginDescriptorV4();
}
@Override
public List<Lifecycle> getLifecycles() {
try {
return Collections.unmodifiableList(new ArrayList<>(delegate.getMojoDescriptor()
.getPluginDescriptor()
.getLifecycleMappings()
.values()));
} catch (Exception e) {
throw new RuntimeException("Unable to load plugin lifecycles", e);
}
}
@Override
public ClassLoader getClassLoader() {
return delegate.getMojoDescriptor().getRealm();
}
@Override
public Artifact getArtifact() {
org.apache.maven.artifact.Artifact artifact =
delegate.getMojoDescriptor().getPluginDescriptor().getPluginArtifact();
org.eclipse.aether.artifact.Artifact resolverArtifact = RepositoryUtils.toArtifact(artifact);
return resolverArtifact != null ? session.getArtifact(resolverArtifact) : null;
}
@Override
public Map<String, Dependency> getDependenciesMap() {
DependencyNode resolverNode =
delegate.getMojoDescriptor().getPluginDescriptor().getDependencyNode();
DefaultNode node = new DefaultNode(session, resolverNode, false);
return Collections.unmodifiableMap(node.stream()
.filter(Objects::nonNull)
.map(Node::getDependency)
.filter(Objects::nonNull)
.collect(Collectors.toMap(d -> d.getGroupId() + ":" + d.getArtifactId(), d -> d)));
}
};
| 418
| 482
| 900
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultPackagingRegistry.java
|
DefaultPackagingRegistry
|
lookup
|
class DefaultPackagingRegistry
extends ExtensibleEnumRegistries.DefaultExtensibleEnumRegistry<Packaging, PackagingProvider>
implements PackagingRegistry {
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPackagingRegistry.class);
private final Lookup lookup;
private final TypeRegistry typeRegistry;
@Inject
public DefaultPackagingRegistry(Lookup lookup, TypeRegistry typeRegistry, List<PackagingProvider> providers) {
super(providers);
this.lookup = lookup;
this.typeRegistry = typeRegistry;
}
@Override
public Optional<Packaging> lookup(String id) {<FILL_FUNCTION_BODY>}
private Map<String, PluginContainer> getPlugins(LifecycleMapping lifecycleMapping) {
Map<String, PluginContainer> lfs = new HashMap<>();
lifecycleMapping.getLifecycles().forEach((id, lifecycle) -> {
Map<String, Plugin> plugins = new HashMap<>();
lifecycle
.getLifecyclePhases()
.forEach((phase, lifecyclePhase) -> parseLifecyclePhaseDefinitions(plugins, phase, lifecyclePhase));
lfs.put(id, PluginContainer.newBuilder().plugins(plugins.values()).build());
});
return lfs;
}
private void parseLifecyclePhaseDefinitions(Map<String, Plugin> plugins, String phase, LifecyclePhase goals) {
InputSource inputSource =
new InputSource(DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID, null);
InputLocation location = new InputLocation(-1, -1, inputSource, 0);
List<LifecycleMojo> mojos = goals.getMojos();
if (mojos != null) {
for (int i = 0; i < mojos.size(); i++) {
LifecycleMojo mojo = mojos.get(i);
// Compute goal coordinates
String groupId, artifactId, version, goal;
String[] p = mojo.getGoal().trim().split(":");
if (p.length == 3) {
// <groupId>:<artifactId>:<goal>
groupId = p[0];
artifactId = p[1];
version = null;
goal = p[2];
} else if (p.length == 4) {
// <groupId>:<artifactId>:<version>:<goal>
groupId = p[0];
artifactId = p[1];
version = p[2];
goal = p[3];
} else {
// invalid
LOGGER.warn(
"Ignored invalid goal specification '{}' from lifecycle mapping for phase {}",
mojo.getGoal(),
phase);
continue;
}
String key = groupId + ":" + artifactId;
// Build plugin
List<PluginExecution> execs = new ArrayList<>();
List<Dependency> deps = new ArrayList<>();
Plugin existing = plugins.get(key);
if (existing != null) {
if (version == null) {
version = existing.getVersion();
}
execs.addAll(existing.getExecutions());
deps.addAll(existing.getDependencies());
}
PluginExecution execution = PluginExecution.newBuilder()
.id(getExecutionId(existing, goal))
.priority(i - mojos.size())
.phase(phase)
.goals(List.of(goal))
.configuration(mojo.getConfiguration())
.location("", location)
.location("id", location)
.location("phase", location)
.location("goals", location)
.build();
execs.add(execution);
if (mojo.getDependencies() != null) {
mojo.getDependencies().forEach(d -> deps.add(d.getDelegate()));
}
Plugin plugin = Plugin.newBuilder()
.groupId(groupId)
.artifactId(artifactId)
.version(version)
.location("", location)
.location("groupId", location)
.location("artifactId", location)
.location("version", location)
.executions(execs)
.dependencies(deps)
.build();
plugins.put(key, plugin);
}
}
}
private static String getExecutionId(Plugin plugin, String goal) {
Set<String> existingIds = plugin != null
? plugin.getExecutions().stream().map(PluginExecution::getId).collect(Collectors.toSet())
: Set.of();
String base = "default-" + goal;
String id = base;
for (int index = 1; existingIds.contains(id); index++) {
id = base + '-' + index;
}
return id;
}
private record DefaultPackaging(String id, Type type, Map<String, PluginContainer> plugins) implements Packaging {}
}
|
id = id.toLowerCase(Locale.ROOT);
// TODO: we should be able to inject a Map<String, LifecycleMapping> directly,
// however, SISU visibility filtering can only happen when an explicit
// lookup is performed. The whole problem here is caused by "project extensions"
// which are bound to a project's classloader, without any clear definition
// of a "project scope"
LifecycleMapping lifecycleMapping =
lookup.lookupOptional(LifecycleMapping.class, id).orElse(null);
if (lifecycleMapping == null) {
return Optional.empty();
}
Type type = typeRegistry.lookup(id).orElse(null);
if (type == null) {
return Optional.empty();
}
return Optional.of(new DefaultPackaging(id, type, getPlugins(lifecycleMapping)));
| 1,295
| 228
| 1,523
|
<methods>public Optional<org.apache.maven.api.Packaging> lookup(java.lang.String) <variables>protected final non-sealed Map<java.lang.String,org.apache.maven.api.Packaging> values
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultPluginXmlFactory.java
|
DefaultPluginXmlFactory
|
write
|
class DefaultPluginXmlFactory implements PluginXmlFactory {
@Override
public PluginDescriptor read(@Nonnull XmlReaderRequest request) throws XmlReaderException {
nonNull(request, "request");
Path path = request.getPath();
URL url = request.getURL();
Reader reader = request.getReader();
InputStream inputStream = request.getInputStream();
if (path == null && url == null && reader == null && inputStream == null) {
throw new IllegalArgumentException("path, url, reader or inputStream must be non null");
}
try {
PluginDescriptorStaxReader xml = new PluginDescriptorStaxReader();
xml.setAddDefaultEntities(request.isAddDefaultEntities());
if (inputStream != null) {
return xml.read(inputStream, request.isStrict());
} else if (reader != null) {
return xml.read(reader, request.isStrict());
} else if (path != null) {
try (InputStream is = Files.newInputStream(path)) {
return xml.read(is, request.isStrict());
}
} else {
try (InputStream is = url.openStream()) {
return xml.read(is, request.isStrict());
}
}
} catch (Exception e) {
throw new XmlReaderException("Unable to read plugin: " + getMessage(e), getLocation(e), e);
}
}
@Override
public void write(XmlWriterRequest<PluginDescriptor> request) throws XmlWriterException {<FILL_FUNCTION_BODY>}
/**
* Simply parse the given xml string.
*
* @param xml the input xml string
* @return the parsed object
* @throws XmlReaderException if an error occurs during the parsing
* @see #toXmlString(Object)
*/
public static PluginDescriptor fromXml(@Nonnull String xml) throws XmlReaderException {
return new DefaultPluginXmlFactory().fromXmlString(xml);
}
/**
* Simply converts the given content to an xml string.
*
* @param content the object to convert
* @return the xml string representation
* @throws XmlWriterException if an error occurs during the transformation
* @see #fromXmlString(String)
*/
public static String toXml(@Nonnull PluginDescriptor content) throws XmlWriterException {
return new DefaultPluginXmlFactory().toXmlString(content);
}
}
|
nonNull(request, "request");
PluginDescriptor content = nonNull(request.getContent(), "content");
Path path = request.getPath();
OutputStream outputStream = request.getOutputStream();
Writer writer = request.getWriter();
if (writer == null && outputStream == null && path == null) {
throw new IllegalArgumentException("writer, outputStream or path must be non null");
}
try {
if (writer != null) {
new PluginDescriptorStaxWriter().write(writer, content);
} else if (outputStream != null) {
new PluginDescriptorStaxWriter().write(outputStream, content);
} else {
try (OutputStream os = Files.newOutputStream(path)) {
new PluginDescriptorStaxWriter().write(outputStream, content);
}
}
} catch (Exception e) {
throw new XmlWriterException("Unable to write plugin: " + getMessage(e), getLocation(e), e);
}
| 613
| 247
| 860
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultProject.java
|
DefaultProject
|
getManagedDependencies
|
class DefaultProject implements Project {
private final InternalMavenSession session;
private final MavenProject project;
private final Packaging packaging;
public DefaultProject(InternalMavenSession session, MavenProject project) {
this.session = session;
this.project = project;
this.packaging = session.requirePackaging(project.getPackaging());
}
public InternalMavenSession getSession() {
return session;
}
public MavenProject getProject() {
return project;
}
@Nonnull
@Override
public String getGroupId() {
return project.getGroupId();
}
@Nonnull
@Override
public String getArtifactId() {
return project.getArtifactId();
}
@Nonnull
@Override
public String getVersion() {
return project.getVersion();
}
@Nonnull
@Override
public List<Artifact> getArtifacts() {
org.eclipse.aether.artifact.Artifact pomArtifact = RepositoryUtils.toArtifact(new ProjectArtifact(project));
org.eclipse.aether.artifact.Artifact projectArtifact = RepositoryUtils.toArtifact(project.getArtifact());
ArrayList<Artifact> result = new ArrayList<>(2);
result.add(session.getArtifact(pomArtifact));
if (!ArtifactIdUtils.equalsVersionlessId(pomArtifact, projectArtifact)) {
result.add(session.getArtifact(projectArtifact));
}
return Collections.unmodifiableList(result);
}
@Nonnull
@Override
public Packaging getPackaging() {
return packaging;
}
@Nonnull
@Override
public Model getModel() {
return project.getModel().getDelegate();
}
@Nonnull
@Override
public Path getPomPath() {
return nonNull(project.getFile(), "pomPath").toPath();
}
@Override
public Path getBasedir() {
return nonNull(project.getBasedir(), "basedir").toPath();
}
@Nonnull
@Override
public List<DependencyCoordinate> getDependencies() {
return new MappedList<>(getModel().getDependencies(), this::toDependency);
}
@Nonnull
@Override
public List<DependencyCoordinate> getManagedDependencies() {<FILL_FUNCTION_BODY>}
@Override
public boolean isTopProject() {
return getBasedir().equals(getSession().getTopDirectory());
}
@Override
public boolean isRootProject() {
return getBasedir().equals(getRootDirectory());
}
@Override
public Path getRootDirectory() {
return project.getRootDirectory();
}
@Override
public Optional<Project> getParent() {
MavenProject parent = project.getParent();
return parent != null ? Optional.of(session.getProject(parent)) : Optional.empty();
}
@Nonnull
private DependencyCoordinate toDependency(org.apache.maven.api.model.Dependency dependency) {
return new DependencyCoordinate() {
@Override
public String getGroupId() {
return dependency.getGroupId();
}
@Override
public String getArtifactId() {
return dependency.getArtifactId();
}
@Override
public String getClassifier() {
return dependency.getClassifier();
}
@Override
public VersionConstraint getVersion() {
return session.parseVersionConstraint(dependency.getVersion());
}
@Override
public String getExtension() {
return getType().getExtension();
}
@Override
public Type getType() {
String type = dependency.getType();
return session.requireType(type);
}
@Nonnull
@Override
public DependencyScope getScope() {
String scope = dependency.getScope() != null ? dependency.getScope() : "";
return session.requireDependencyScope(scope);
}
@Override
public Boolean getOptional() {
return dependency.isOptional();
}
@Nonnull
@Override
public Collection<Exclusion> getExclusions() {
return new MappedCollection<>(dependency.getExclusions(), this::toExclusion);
}
private Exclusion toExclusion(org.apache.maven.api.model.Exclusion exclusion) {
return new Exclusion() {
@Nullable
@Override
public String getGroupId() {
return exclusion.getGroupId();
}
@Nullable
@Override
public String getArtifactId() {
return exclusion.getArtifactId();
}
};
}
};
}
}
|
DependencyManagement dependencyManagement = getModel().getDependencyManagement();
if (dependencyManagement != null) {
return new MappedList<>(dependencyManagement.getDependencies(), this::toDependency);
}
return Collections.emptyList();
| 1,223
| 63
| 1,286
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultProjectBuilder.java
|
DefaultProjectBuilder
|
getDependencyResolverResult
|
class DefaultProjectBuilder implements ProjectBuilder {
private final org.apache.maven.project.ProjectBuilder builder;
@Inject
public DefaultProjectBuilder(org.apache.maven.project.ProjectBuilder builder) {
this.builder = builder;
}
@SuppressWarnings("MethodLength")
@Nonnull
@Override
public ProjectBuilderResult build(ProjectBuilderRequest request)
throws ProjectBuilderException, IllegalArgumentException {
InternalMavenSession session = InternalMavenSession.from(request.getSession());
try {
List<ArtifactRepository> repositories = session.toArtifactRepositories(session.getRemoteRepositories());
ProjectBuildingRequest req = new DefaultProjectBuildingRequest()
.setRepositorySession(session.getSession())
.setRemoteRepositories(repositories)
.setPluginArtifactRepositories(repositories)
.setProcessPlugins(request.isProcessPlugins());
ProjectBuildingResult res;
if (request.getPath().isPresent()) {
Path path = request.getPath().get();
res = builder.build(path.toFile(), req);
} else if (request.getSource().isPresent()) {
Source source = request.getSource().get();
ModelSource2 modelSource = new SourceWrapper(source);
res = builder.build(modelSource, req);
} else {
throw new IllegalArgumentException("Invalid request");
}
return new ProjectBuilderResult() {
@Nonnull
@Override
public String getProjectId() {
return res.getProjectId();
}
@Nonnull
@Override
public Optional<Path> getPomFile() {
return Optional.ofNullable(res.getPomFile()).map(File::toPath);
}
@Nonnull
@Override
public Optional<Project> getProject() {
return Optional.ofNullable(res.getProject()).map(session::getProject);
}
@Nonnull
@Override
public Collection<BuilderProblem> getProblems() {
return new MappedCollection<>(res.getProblems(), this::toProblem);
}
private BuilderProblem toProblem(ModelProblem problem) {
return new BuilderProblem() {
@Override
public String getSource() {
return problem.getSource();
}
@Override
public int getLineNumber() {
return problem.getLineNumber();
}
@Override
public int getColumnNumber() {
return problem.getColumnNumber();
}
@Override
public String getLocation() {
StringBuilder buffer = new StringBuilder(256);
if (!getSource().isEmpty()) {
buffer.append(getSource());
}
if (getLineNumber() > 0) {
if (buffer.length() > 0) {
buffer.append(", ");
}
buffer.append("line ").append(getLineNumber());
}
if (getColumnNumber() > 0) {
if (buffer.length() > 0) {
buffer.append(", ");
}
buffer.append("column ").append(getColumnNumber());
}
return buffer.toString();
}
@Override
public Exception getException() {
return problem.getException();
}
@Override
public String getMessage() {
return problem.getMessage();
}
@Override
public Severity getSeverity() {
return Severity.valueOf(problem.getSeverity().name());
}
};
}
@Nonnull
@Override
public Optional<DependencyCollectorResult> getDependencyResolverResult() {<FILL_FUNCTION_BODY>}
};
} catch (ProjectBuildingException e) {
throw new ProjectBuilderException("Unable to build project", e);
}
}
private static class SourceWrapper implements ModelSource2 {
private final Source source;
SourceWrapper(Source source) {
this.source = source;
}
@Override
public InputStream getInputStream() throws IOException {
return source.openStream();
}
@Override
public String getLocation() {
return source.getLocation();
}
@Override
public ModelSource2 getRelatedSource(String relPath) {
Source rel = source.resolve(relPath);
return rel != null ? new SourceWrapper(rel) : null;
}
@Override
public URI getLocationURI() {
Path path = source.getPath();
return path != null ? path.toUri() : URI.create(source.getLocation());
}
}
}
|
return Optional.ofNullable(res.getDependencyResolutionResult())
.map(r -> new DependencyCollectorResult() {
@Override
public List<Exception> getExceptions() {
return r.getCollectionErrors();
}
@Override
public Node getRoot() {
return session.getNode(r.getDependencyGraph());
}
});
| 1,167
| 97
| 1,264
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultProjectManager.java
|
DefaultProjectManager
|
getAttachedArtifacts
|
class DefaultProjectManager implements ProjectManager {
private final InternalMavenSession session;
private final ArtifactManager artifactManager;
@Inject
public DefaultProjectManager(InternalMavenSession session, ArtifactManager artifactManager) {
this.session = session;
this.artifactManager = artifactManager;
}
@Nonnull
@Override
public Optional<Path> getPath(Project project) {
Optional<Artifact> mainArtifact = project.getMainArtifact();
if (mainArtifact.isPresent()) {
return artifactManager.getPath(mainArtifact.get());
}
return Optional.empty();
}
@Nonnull
@Override
public Collection<Artifact> getAttachedArtifacts(Project project) {<FILL_FUNCTION_BODY>}
@Override
public Collection<Artifact> getAllArtifacts(Project project) {
ArrayList<Artifact> result = new ArrayList<>(2);
result.addAll(project.getArtifacts());
result.addAll(getAttachedArtifacts(project));
return Collections.unmodifiableCollection(result);
}
@Override
public void attachArtifact(Project project, Artifact artifact, Path path) {
getMavenProject(project)
.addAttachedArtifact(RepositoryUtils.toArtifact(
((DefaultProject) project).getSession().toArtifact(artifact)));
artifactManager.setPath(artifact, path);
}
@Override
public List<Path> getCompileSourceRoots(Project project, ProjectScope scope) {
MavenProject prj = getMavenProject(nonNull(project, "project"));
List<String> roots;
if (nonNull(scope, "scope") == ProjectScope.MAIN) {
roots = prj.getCompileSourceRoots();
} else if (scope == ProjectScope.TEST) {
roots = prj.getTestCompileSourceRoots();
} else {
throw new IllegalArgumentException("Unsupported scope " + scope);
}
return roots.stream()
.map(Paths::get)
.collect(Collectors.collectingAndThen(toList(), Collections::unmodifiableList));
}
@Override
public void addCompileSourceRoot(Project project, ProjectScope scope, Path sourceRoot) {
MavenProject prj = getMavenProject(nonNull(project, "project"));
String root = nonNull(sourceRoot, "sourceRoot").toAbsolutePath().toString();
if (nonNull(scope, "scope") == ProjectScope.MAIN) {
prj.addCompileSourceRoot(root);
} else if (scope == ProjectScope.TEST) {
prj.addTestCompileSourceRoot(root);
} else {
throw new IllegalArgumentException("Unsupported scope " + scope);
}
}
@Override
public List<Resource> getResources(@Nonnull Project project, @Nonnull ProjectScope scope) {
Project prj = nonNull(project, "project");
if (nonNull(scope, "scope") == ProjectScope.MAIN) {
return prj.getBuild().getResources();
} else if (scope == ProjectScope.TEST) {
return prj.getBuild().getTestResources();
} else {
throw new IllegalArgumentException("Unsupported scope " + scope);
}
}
@Override
public void addResource(@Nonnull Project project, @Nonnull ProjectScope scope, @Nonnull Resource resource) {
// TODO: we should not modify the underlying model here, but resources should be stored
// TODO: in a separate field in the project, however, that could break v3 plugins
MavenProject prj = getMavenProject(nonNull(project, "project"));
org.apache.maven.model.Resource res = new org.apache.maven.model.Resource(nonNull(resource, "resource"));
if (nonNull(scope, "scope") == ProjectScope.MAIN) {
prj.addResource(res);
} else if (scope == ProjectScope.TEST) {
prj.addTestResource(res);
} else {
throw new IllegalArgumentException("Unsupported scope " + scope);
}
}
@Override
public List<RemoteRepository> getRemoteProjectRepositories(Project project) {
return Collections.unmodifiableList(new MappedList<>(
((DefaultProject) project).getProject().getRemoteProjectRepositories(), session::getRemoteRepository));
}
@Override
public List<RemoteRepository> getRemotePluginRepositories(Project project) {
return Collections.unmodifiableList(new MappedList<>(
((DefaultProject) project).getProject().getRemotePluginRepositories(), session::getRemoteRepository));
}
@Override
public void setProperty(Project project, String key, String value) {
Properties properties = getMavenProject(project).getProperties();
if (value == null) {
properties.remove(key);
} else {
properties.setProperty(key, value);
}
}
@Override
public Map<String, String> getProperties(Project project) {
return Collections.unmodifiableMap(
new PropertiesAsMap(((DefaultProject) project).getProject().getProperties()));
}
@Override
public Optional<Project> getExecutionProject(Project project) {
// Session keep tracks of the Project per project id,
// so we cannot use session.getProject(p) for forked projects
// which are temporary clones
return Optional.ofNullable(getMavenProject(project).getExecutionProject())
.map(p -> new DefaultProject(session, p));
}
private MavenProject getMavenProject(Project project) {
return ((DefaultProject) project).getProject();
}
}
|
InternalMavenSession session = ((DefaultProject) project).getSession();
Collection<Artifact> attached = map(
getMavenProject(project).getAttachedArtifacts(),
a -> session.getArtifact(RepositoryUtils.toArtifact(a)));
return Collections.unmodifiableCollection(attached);
| 1,436
| 81
| 1,517
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultPrompter.java
|
DefaultPrompter
|
promptForPassword
|
class DefaultPrompter implements Prompter {
private static final String PROMPTER_CLASS = "org.codehaus.plexus.components.interactivity.Prompter";
private final PlexusContainer container;
@Inject
public DefaultPrompter(PlexusContainer container) {
this.container = container;
}
@Override
public String prompt(String message, List<String> possibleValues, String defaultReply) throws PrompterException {
try {
Class<?> clazz = container.getContainerRealm().loadClass(PROMPTER_CLASS);
Object instance = container.lookup(clazz);
Method method = clazz.getMethod("prompt", String.class, List.class, String.class);
return (String) method.invoke(instance, message, possibleValues, defaultReply);
} catch (Exception e) {
throw new PrompterException("Unable to call prompter", e);
}
}
@Override
public String promptForPassword(String message) throws PrompterException {<FILL_FUNCTION_BODY>}
@Override
public void showMessage(String message) throws PrompterException {
try {
Class<?> clazz = container.getContainerRealm().loadClass(PROMPTER_CLASS);
Object instance = container.lookup(clazz);
Method method = clazz.getMethod("showMessage", String.class);
method.invoke(instance, message);
} catch (Exception e) {
throw new PrompterException("Unable to call prompter", e);
}
}
}
|
try {
Class<?> clazz = container.getContainerRealm().loadClass(PROMPTER_CLASS);
Object instance = container.lookup(clazz);
Method method = clazz.getMethod("promptForPassword", String.class);
return (String) method.invoke(instance, message);
} catch (Exception e) {
throw new PrompterException("Unable to call prompter", e);
}
| 403
| 111
| 514
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultSession.java
|
DefaultSession
|
toArtifactRepository
|
class DefaultSession extends AbstractSession implements InternalMavenSession {
private final MavenSession mavenSession;
private final MavenRepositorySystem mavenRepositorySystem;
private final RuntimeInformation runtimeInformation;
private final Map<String, Project> allProjects = Collections.synchronizedMap(new WeakHashMap<>());
@SuppressWarnings("checkstyle:ParameterNumber")
public DefaultSession(
@Nonnull MavenSession session,
@Nonnull RepositorySystem repositorySystem,
@Nullable List<RemoteRepository> remoteRepositories,
@Nonnull MavenRepositorySystem mavenRepositorySystem,
@Nonnull Lookup lookup,
@Nonnull RuntimeInformation runtimeInformation) {
super(
nonNull(session).getRepositorySession(),
repositorySystem,
remoteRepositories,
remoteRepositories == null
? map(session.getRequest().getRemoteRepositories(), RepositoryUtils::toRepo)
: null,
lookup);
this.mavenSession = session;
this.mavenRepositorySystem = mavenRepositorySystem;
this.runtimeInformation = runtimeInformation;
}
public MavenSession getMavenSession() {
return mavenSession;
}
@Override
public List<Project> getProjects(List<MavenProject> projects) {
return projects == null ? null : map(projects, this::getProject);
}
@Override
public Project getProject(MavenProject project) {
return allProjects.computeIfAbsent(project.getId(), id -> new DefaultProject(this, project));
}
@Override
public List<ArtifactRepository> toArtifactRepositories(List<RemoteRepository> repositories) {
return repositories == null ? null : map(repositories, this::toArtifactRepository);
}
@Nonnull
@Override
public Settings getSettings() {
return mavenSession.getSettings().getDelegate();
}
@Nonnull
@Override
public Map<String, String> getUserProperties() {
return Collections.unmodifiableMap(new PropertiesAsMap(mavenSession.getUserProperties()));
}
@Nonnull
@Override
public Map<String, String> getSystemProperties() {
return Collections.unmodifiableMap(new PropertiesAsMap(mavenSession.getSystemProperties()));
}
@Nonnull
@Override
public Map<String, String> getEffectiveProperties(@Nullable Project project) {
HashMap<String, String> result = new HashMap<>(getSystemProperties());
if (project != null) {
result.putAll(project.getModel().getProperties());
}
result.putAll(getUserProperties());
return result;
}
@Nonnull
@Override
public Version getMavenVersion() {
return parseVersion(runtimeInformation.getMavenVersion());
}
@Override
public int getDegreeOfConcurrency() {
return mavenSession.getRequest().getDegreeOfConcurrency();
}
@Nonnull
@Override
public Instant getStartTime() {
return mavenSession.getRequest().getStartTime().toInstant();
}
@Override
public Path getRootDirectory() {
return mavenSession.getRequest().getRootDirectory();
}
@Override
public Path getTopDirectory() {
return mavenSession.getRequest().getTopDirectory();
}
@Nonnull
@Override
public List<Project> getProjects() {
return getProjects(mavenSession.getProjects());
}
@Nonnull
@Override
public Map<String, Object> getPluginContext(Project project) {
nonNull(project, "project");
try {
MojoExecution mojoExecution = lookup.lookup(MojoExecution.class);
MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
return mavenSession.getPluginContext(pluginDescriptor, ((DefaultProject) project).getProject());
} catch (LookupException e) {
throw new MavenException("The PluginContext is only available during a mojo execution", e);
}
}
protected Session newSession(RepositorySystemSession repoSession, List<RemoteRepository> repositories) {
final MavenSession ms = nonNull(mavenSession);
final MavenSession mss;
if (repoSession != ms.getRepositorySession()) {
mss = new MavenSession(repoSession, ms.getRequest(), ms.getResult());
} else {
mss = ms;
}
return newSession(mss, repositories);
}
protected Session newSession(MavenSession mavenSession, List<RemoteRepository> repositories) {
return new DefaultSession(
nonNull(mavenSession),
getRepositorySystem(),
repositories,
mavenRepositorySystem,
lookup,
runtimeInformation);
}
public ArtifactRepository toArtifactRepository(RemoteRepository repository) {<FILL_FUNCTION_BODY>}
}
|
if (repository instanceof DefaultRemoteRepository) {
org.eclipse.aether.repository.RemoteRepository rr = ((DefaultRemoteRepository) repository).getRepository();
try {
return mavenRepositorySystem.createRepository(
rr.getUrl(),
rr.getId(),
rr.getPolicy(false).isEnabled(),
rr.getPolicy(false).getUpdatePolicy(),
rr.getPolicy(true).isEnabled(),
rr.getPolicy(true).getUpdatePolicy(),
rr.getPolicy(false).getChecksumPolicy());
} catch (Exception e) {
throw new RuntimeException("Unable to create repository", e);
}
} else {
// TODO
throw new UnsupportedOperationException("Not yet implemented");
}
| 1,269
| 194
| 1,463
|
<methods>public void <init>(RepositorySystemSession, RepositorySystem, List<org.apache.maven.api.RemoteRepository>, List<org.eclipse.aether.repository.RemoteRepository>, org.apache.maven.api.services.Lookup) ,public org.apache.maven.api.Node collectDependencies(org.apache.maven.api.Artifact) ,public org.apache.maven.api.Node collectDependencies(org.apache.maven.api.Project) ,public org.apache.maven.api.Node collectDependencies(org.apache.maven.api.DependencyCoordinate) ,public org.apache.maven.api.Artifact createArtifact(java.lang.String, java.lang.String, java.lang.String, java.lang.String) ,public org.apache.maven.api.Artifact createArtifact(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) ,public org.apache.maven.api.ArtifactCoordinate createArtifactCoordinate(java.lang.String, java.lang.String, java.lang.String, java.lang.String) ,public org.apache.maven.api.ArtifactCoordinate createArtifactCoordinate(java.lang.String) ,public org.apache.maven.api.ArtifactCoordinate createArtifactCoordinate(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) ,public org.apache.maven.api.ArtifactCoordinate createArtifactCoordinate(org.apache.maven.api.Artifact) ,public org.apache.maven.api.DependencyCoordinate createDependencyCoordinate(org.apache.maven.api.ArtifactCoordinate) ,public org.apache.maven.api.DependencyCoordinate createDependencyCoordinate(org.apache.maven.api.Dependency) ,public org.apache.maven.api.LocalRepository createLocalRepository(java.nio.file.Path) ,public org.apache.maven.api.RemoteRepository createRemoteRepository(java.lang.String, java.lang.String) ,public org.apache.maven.api.RemoteRepository createRemoteRepository(Repository) ,public transient void deployArtifact(org.apache.maven.api.RemoteRepository, org.apache.maven.api.Artifact[]) ,public List<org.apache.maven.api.Node> flattenDependencies(org.apache.maven.api.Node, org.apache.maven.api.PathScope) ,public org.apache.maven.api.Artifact getArtifact(org.eclipse.aether.artifact.Artifact) ,public Optional<java.nio.file.Path> getArtifactPath(org.apache.maven.api.Artifact) ,public org.apache.maven.api.SessionData getData() ,public org.apache.maven.api.Dependency getDependency(org.eclipse.aether.graph.Dependency) ,public Collection<org.apache.maven.api.Listener> getListeners() ,public org.apache.maven.api.LocalRepository getLocalRepository() ,public org.apache.maven.api.Node getNode(org.eclipse.aether.graph.DependencyNode) ,public org.apache.maven.api.Node getNode(org.eclipse.aether.graph.DependencyNode, boolean) ,public java.nio.file.Path getPathForLocalArtifact(org.apache.maven.api.Artifact) ,public java.nio.file.Path getPathForRemoteArtifact(org.apache.maven.api.RemoteRepository, org.apache.maven.api.Artifact) ,public List<org.apache.maven.api.RemoteRepository> getRemoteRepositories() ,public org.apache.maven.api.RemoteRepository getRemoteRepository(org.eclipse.aether.repository.RemoteRepository) ,public RepositorySystem getRepositorySystem() ,public T getService(Class<T>) throws java.util.NoSuchElementException,public RepositorySystemSession getSession() ,public transient void installArtifacts(org.apache.maven.api.Artifact[]) ,public void installArtifacts(Collection<org.apache.maven.api.Artifact>) ,public boolean isVersionSnapshot(java.lang.String) ,public org.apache.maven.api.Version parseVersion(java.lang.String) ,public org.apache.maven.api.VersionConstraint parseVersionConstraint(java.lang.String) ,public org.apache.maven.api.VersionRange parseVersionRange(java.lang.String) ,public void registerListener(org.apache.maven.api.Listener) ,public org.apache.maven.api.DependencyScope requireDependencyScope(java.lang.String) ,public org.apache.maven.api.Language requireLanguage(java.lang.String) ,public org.apache.maven.api.Packaging requirePackaging(java.lang.String) ,public org.apache.maven.api.PathScope requirePathScope(java.lang.String) ,public org.apache.maven.api.ProjectScope requireProjectScope(java.lang.String) ,public org.apache.maven.api.Type requireType(java.lang.String) ,public Entry<org.apache.maven.api.Artifact,java.nio.file.Path> resolveArtifact(org.apache.maven.api.ArtifactCoordinate) ,public Entry<org.apache.maven.api.Artifact,java.nio.file.Path> resolveArtifact(org.apache.maven.api.Artifact) ,public transient Map<org.apache.maven.api.Artifact,java.nio.file.Path> resolveArtifacts(org.apache.maven.api.ArtifactCoordinate[]) ,public Map<org.apache.maven.api.Artifact,java.nio.file.Path> resolveArtifacts(Collection<? extends org.apache.maven.api.ArtifactCoordinate>) ,public transient Map<org.apache.maven.api.Artifact,java.nio.file.Path> resolveArtifacts(org.apache.maven.api.Artifact[]) ,public List<java.nio.file.Path> resolveDependencies(org.apache.maven.api.DependencyCoordinate) ,public List<java.nio.file.Path> resolveDependencies(List<org.apache.maven.api.DependencyCoordinate>) ,public List<java.nio.file.Path> resolveDependencies(org.apache.maven.api.Project, org.apache.maven.api.PathScope) ,public Map<org.apache.maven.api.PathType,List<java.nio.file.Path>> resolveDependencies(org.apache.maven.api.DependencyCoordinate, org.apache.maven.api.PathScope, Collection<org.apache.maven.api.PathType>) ,public Map<org.apache.maven.api.PathType,List<java.nio.file.Path>> resolveDependencies(org.apache.maven.api.Project, org.apache.maven.api.PathScope, Collection<org.apache.maven.api.PathType>) ,public org.apache.maven.api.Version resolveVersion(org.apache.maven.api.ArtifactCoordinate) ,public List<org.apache.maven.api.Version> resolveVersionRange(org.apache.maven.api.ArtifactCoordinate) ,public void setArtifactPath(org.apache.maven.api.Artifact, java.nio.file.Path) ,public org.eclipse.aether.artifact.Artifact toArtifact(org.apache.maven.api.Artifact) ,public org.eclipse.aether.artifact.Artifact toArtifact(org.apache.maven.api.ArtifactCoordinate) ,public List<org.eclipse.aether.artifact.Artifact> toArtifacts(Collection<org.apache.maven.api.Artifact>) ,public List<org.eclipse.aether.graph.Dependency> toDependencies(Collection<org.apache.maven.api.DependencyCoordinate>, boolean) ,public org.eclipse.aether.graph.Dependency toDependency(org.apache.maven.api.DependencyCoordinate, boolean) ,public List<org.eclipse.aether.repository.RemoteRepository> toRepositories(List<org.apache.maven.api.RemoteRepository>) ,public org.eclipse.aether.repository.RemoteRepository toRepository(org.apache.maven.api.RemoteRepository) ,public org.eclipse.aether.repository.LocalRepository toRepository(org.apache.maven.api.LocalRepository) ,public void unregisterListener(org.apache.maven.api.Listener) ,public org.apache.maven.api.Session withLocalRepository(org.apache.maven.api.LocalRepository) ,public org.apache.maven.api.Session withRemoteRepositories(List<org.apache.maven.api.RemoteRepository>) <variables>private final Map<org.eclipse.aether.artifact.Artifact,org.apache.maven.api.Artifact> allArtifacts,private final Map<org.eclipse.aether.graph.Dependency,org.apache.maven.api.Dependency> allDependencies,private final Map<org.eclipse.aether.graph.DependencyNode,org.apache.maven.api.Node> allNodes,private final Map<org.eclipse.aether.repository.RemoteRepository,org.apache.maven.api.RemoteRepository> allRepositories,private final List<org.apache.maven.api.Listener> listeners,protected final non-sealed org.apache.maven.api.services.Lookup lookup,protected final non-sealed List<org.apache.maven.api.RemoteRepository> repositories,protected final non-sealed RepositorySystem repositorySystem,private final Map<Class<? extends org.apache.maven.api.Service>,org.apache.maven.api.Service> services,protected final non-sealed RepositorySystemSession session
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultSessionFactory.java
|
DefaultSessionFactory
|
newSession
|
class DefaultSessionFactory {
private final RepositorySystem repositorySystem;
private final MavenRepositorySystem mavenRepositorySystem;
private final Lookup lookup;
private final RuntimeInformation runtimeInformation;
@Inject
@SuppressWarnings("checkstyle:ParameterNumber")
public DefaultSessionFactory(
RepositorySystem repositorySystem,
MavenRepositorySystem mavenRepositorySystem,
Lookup lookup,
RuntimeInformation runtimeInformation) {
this.repositorySystem = repositorySystem;
this.mavenRepositorySystem = mavenRepositorySystem;
this.lookup = lookup;
this.runtimeInformation = runtimeInformation;
}
public InternalSession newSession(MavenSession mavenSession) {<FILL_FUNCTION_BODY>}
}
|
return new DefaultSession(
mavenSession, repositorySystem, null, mavenRepositorySystem, lookup, runtimeInformation);
| 183
| 31
| 214
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultToolchainManager.java
|
DefaultToolchainManager
|
storeToolchainToBuildContext
|
class DefaultToolchainManager implements ToolchainManager {
private final DefaultToolchainManagerPrivate toolchainManagerPrivate;
@Inject
public DefaultToolchainManager(DefaultToolchainManagerPrivate toolchainManagerPrivate) {
this.toolchainManagerPrivate = toolchainManagerPrivate;
}
@Override
public List<Toolchain> getToolchains(Session session, String type, Map<String, String> requirements)
throws ToolchainManagerException {
MavenSession s = InternalMavenSession.from(session).getMavenSession();
List<org.apache.maven.toolchain.Toolchain> toolchains =
toolchainManagerPrivate.getToolchains(s, type, requirements);
return new MappedList<>(toolchains, this::toToolchain);
}
@Override
public Optional<Toolchain> getToolchainFromBuildContext(Session session, String type)
throws ToolchainManagerException {
MavenSession s = InternalMavenSession.from(session).getMavenSession();
return Optional.ofNullable(toolchainManagerPrivate.getToolchainFromBuildContext(type, s))
.map(this::toToolchain);
}
@Override
public List<Toolchain> getToolchainsForType(Session session, String type) throws ToolchainManagerException {
try {
MavenSession s = InternalMavenSession.from(session).getMavenSession();
ToolchainPrivate[] toolchains = toolchainManagerPrivate.getToolchainsForType(type, s);
return new MappedList<>(Arrays.asList(toolchains), this::toToolchain);
} catch (MisconfiguredToolchainException e) {
throw new ToolchainManagerException("Unable to get toochains for type " + type, e);
}
}
@Override
public void storeToolchainToBuildContext(Session session, Toolchain toolchain) throws ToolchainManagerException {<FILL_FUNCTION_BODY>}
private Toolchain toToolchain(org.apache.maven.toolchain.Toolchain toolchain) {
return new ToolchainWrapper(toolchain);
}
private static class ToolchainWrapper implements Toolchain {
private final org.apache.maven.toolchain.Toolchain toolchain;
ToolchainWrapper(org.apache.maven.toolchain.Toolchain toolchain) {
this.toolchain = toolchain;
}
@Override
public String getType() {
return toolchain.getType();
}
@Override
public String findTool(String toolName) {
return toolchain.findTool(toolName);
}
@Override
public boolean matchesRequirements(Map<String, String> requirements) {
return ((ToolchainPrivate) toolchain).matchesRequirements(requirements);
}
}
}
|
MavenSession s = InternalMavenSession.from(session).getMavenSession();
org.apache.maven.toolchain.ToolchainPrivate tc =
(org.apache.maven.toolchain.ToolchainPrivate) ((ToolchainWrapper) toolchain).toolchain;
toolchainManagerPrivate.storeToolchainToBuildContext(tc, s);
| 687
| 86
| 773
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/DefaultTypeRegistry.java
|
DefaultTypeRegistry
|
require
|
class DefaultTypeRegistry extends AbstractEventSpy implements TypeRegistry {
private final Map<String, Type> types;
private final LanguageRegistry languageRegistry;
private final ConcurrentHashMap<String, Type> usedTypes;
private final LegacyArtifactHandlerManager manager;
@Inject
public DefaultTypeRegistry(
List<TypeProvider> providers, LanguageRegistry languageRegistry, LegacyArtifactHandlerManager manager) {
this.types = nonNull(providers, "providers").stream()
.flatMap(p -> p.provides().stream())
.collect(Collectors.toMap(Type::id, identity()));
this.languageRegistry = nonNull(languageRegistry, "languageRegistry");
this.usedTypes = new ConcurrentHashMap<>();
this.manager = nonNull(manager, "artifactHandlerManager");
}
@Override
public void onEvent(Object event) {
if (event instanceof ExecutionEvent) {
ExecutionEvent executionEvent = (ExecutionEvent) event;
if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
usedTypes.clear();
}
}
}
@Override
public Optional<Type> lookup(String id) {
return Optional.of(require(id));
}
@Override
@Nonnull
public Type require(String id) {<FILL_FUNCTION_BODY>}
}
|
nonNull(id, "id");
return usedTypes.computeIfAbsent(id, i -> {
Type type = types.get(id);
if (type == null) {
// Copy data as the ArtifactHandler is not immutable, but Type should be.
ArtifactHandler handler = manager.getArtifactHandler(id);
type = new DefaultType(
id,
languageRegistry.require(handler.getLanguage()),
handler.getExtension(),
handler.getClassifier(),
handler.isIncludesDependencies(),
JavaPathType.CLASSES,
JavaPathType.MODULES);
}
return type;
});
| 348
| 167
| 515
|
<methods>public non-sealed void <init>() ,public void close() throws java.lang.Exception,public void init(org.apache.maven.eventspy.EventSpy.Context) throws java.lang.Exception,public void onEvent(java.lang.Object) throws java.lang.Exception<variables>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/EventSpyImpl.java
|
EventSpyImpl
|
onEvent
|
class EventSpyImpl implements EventSpy {
private DefaultSessionFactory sessionFactory;
@Inject
EventSpyImpl(DefaultSessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@Override
public void init(Context context) throws Exception {}
@Override
public void onEvent(Object arg) throws Exception {<FILL_FUNCTION_BODY>}
@Override
public void close() throws Exception {}
}
|
if (arg instanceof ExecutionEvent) {
ExecutionEvent ee = (ExecutionEvent) arg;
InternalMavenSession session =
InternalMavenSession.from(ee.getSession().getSession());
Collection<Listener> listeners = session.getListeners();
if (!listeners.isEmpty()) {
Event event = new DefaultEvent(session, ee);
for (Listener listener : listeners) {
listener.onEvent(event);
}
}
}
| 117
| 119
| 236
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/Graph.java
|
Graph
|
visitAll
|
class Graph {
private enum DfsState {
VISITING,
VISITED
}
final Map<String, Vertex> vertices = new LinkedHashMap<>();
public Vertex getVertex(String id) {
return vertices.get(id);
}
public Collection<Vertex> getVertices() {
return vertices.values();
}
Vertex addVertex(String label) {
return vertices.computeIfAbsent(label, Vertex::new);
}
void addEdge(Vertex from, Vertex to) throws CycleDetectedException {
from.children.add(to);
to.parents.add(from);
List<String> cycle = findCycle(to);
if (cycle != null) {
// remove edge which introduced cycle
removeEdge(from, to);
throw new CycleDetectedException(
"Edge between '" + from.label + "' and '" + to.label + "' introduces to cycle in the graph", cycle);
}
}
void removeEdge(Vertex from, Vertex to) {
from.children.remove(to);
to.parents.remove(from);
}
List<String> visitAll() {
return visitAll(vertices.values(), new HashMap<>(), new ArrayList<>());
}
List<String> findCycle(Vertex vertex) {
return visitCycle(Collections.singleton(vertex), new HashMap<>(), new LinkedList<>());
}
private static List<String> visitAll(
Collection<Vertex> children, Map<Vertex, DfsState> stateMap, List<String> list) {<FILL_FUNCTION_BODY>}
private static List<String> visitCycle(
Collection<Vertex> children, Map<Vertex, DfsState> stateMap, LinkedList<String> cycle) {
for (Vertex v : children) {
DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
if (state == null) {
cycle.addLast(v.label);
List<String> ret = visitCycle(v.children, stateMap, cycle);
if (ret != null) {
return ret;
}
cycle.removeLast();
stateMap.put(v, DfsState.VISITED);
} else if (state == DfsState.VISITING) {
// we are already visiting this vertex, this mean we have a cycle
int pos = cycle.lastIndexOf(v.label);
List<String> ret = cycle.subList(pos, cycle.size());
ret.add(v.label);
return ret;
}
}
return null;
}
static class Vertex {
final String label;
final List<Vertex> children = new ArrayList<>();
final List<Vertex> parents = new ArrayList<>();
Vertex(String label) {
this.label = label;
}
String getLabel() {
return label;
}
List<Vertex> getChildren() {
return children;
}
List<Vertex> getParents() {
return parents;
}
}
static class CycleDetectedException extends RuntimeException {
private final List<String> cycle;
CycleDetectedException(String message, List<String> cycle) {
super(message);
this.cycle = cycle;
}
public List<String> getCycle() {
return cycle;
}
@Override
public String getMessage() {
return super.getMessage() + " " + String.join(" --> ", cycle);
}
}
}
|
for (Vertex v : children) {
DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
if (state == null) {
visitAll(v.children, stateMap, list);
stateMap.put(v, DfsState.VISITED);
list.add(v.label);
}
}
return list;
| 916
| 101
| 1,017
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/Lifecycles.java
|
Lifecycles
|
plugin
|
class Lifecycles {
static Lifecycle.Phase phase(String name) {
return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList());
}
static Lifecycle.Phase phase(String name, Plugin plugin) {
return new DefaultPhase(name, Collections.singletonList(plugin), Collections.emptyList());
}
static Plugin plugin(String coord, String phase) {<FILL_FUNCTION_BODY>}
static class DefaultPhase implements Lifecycle.Phase {
private final String name;
private final List<Plugin> plugins;
private final List<Lifecycle.Phase> phases;
DefaultPhase(String name, List<Plugin> plugins, List<Lifecycle.Phase> phases) {
this.name = name;
this.plugins = plugins;
this.phases = phases;
}
@Override
public String name() {
return name;
}
@Override
public List<Plugin> plugins() {
return plugins;
}
}
}
|
String[] c = coord.split(":");
return Plugin.newBuilder()
.groupId(c[0])
.artifactId(c[1])
.version(c[2])
.executions(Collections.singletonList(PluginExecution.newBuilder()
.id("default-" + c[3])
.phase(phase)
.goals(Collections.singletonList(c[3]))
.build()))
.build();
| 281
| 114
| 395
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/impl/SisuDiBridgeModule.java
|
SisuDiBridgeModule
|
configure
|
class SisuDiBridgeModule extends AbstractModule {
@Override
protected void configure() {<FILL_FUNCTION_BODY>}
}
|
Provider<PlexusContainer> containerProvider = getProvider(PlexusContainer.class);
Injector injector = new InjectorImpl() {
@Override
public <Q> Supplier<Q> getCompiledBinding(Key<Q> key) {
Set<Binding<Q>> res = getBindings(key);
if (res != null && !res.isEmpty()) {
List<Binding<Q>> bindingList = new ArrayList<>(res);
Comparator<Binding<Q>> comparing = Comparator.comparing(Binding::getPriority);
bindingList.sort(comparing.reversed());
Binding<Q> binding = bindingList.get(0);
return compile(binding);
}
if (key.getRawType() == List.class) {
Set<Binding<Object>> res2 = getBindings(key.getTypeParameter(0));
Set<Binding<Object>> res3 = res2 != null ? new HashSet<>(res2) : new HashSet<>();
try {
List<Object> l = containerProvider
.get()
.lookupList(key.getTypeParameter(0).getRawType());
l.forEach(o -> res3.add(new Binding.BindingToInstance<>(o)));
} catch (Throwable e) {
// ignore
e.printStackTrace();
}
List<Supplier<Object>> list =
res3.stream().map(this::compile).collect(Collectors.toList());
//noinspection unchecked
return () -> (Q) list(list);
}
if (key.getRawType() == Map.class) {
Key<?> k = key.getTypeParameter(0);
Key<Object> v = key.getTypeParameter(1);
if (k.getRawType() == String.class) {
Set<Binding<Object>> res2 = getBindings(v);
Set<Binding<Object>> res3 = res2 != null ? new HashSet<>(res2) : new HashSet<>();
Map<String, Supplier<Object>> map = res3.stream()
.filter(b -> b.getOriginalKey() == null
|| b.getOriginalKey().getQualifier() == null
|| b.getOriginalKey().getQualifier() instanceof String)
.collect(Collectors.toMap(
b -> (String)
(b.getOriginalKey() != null
? b.getOriginalKey().getQualifier()
: null),
this::compile));
//noinspection unchecked
return () -> (Q) map(map);
}
}
try {
Q t = containerProvider.get().lookup(key.getRawType());
return compile(new Binding.BindingToInstance<>(t));
} catch (Throwable e) {
// ignore
e.printStackTrace();
}
throw new DIException("No binding to construct an instance for key "
+ key.getDisplayString() + ". Existing bindings:\n"
+ getBoundKeys().stream()
.map(Key::toString)
.map(String::trim)
.sorted()
.distinct()
.collect(Collectors.joining("\n - ", " - ", "")));
}
};
injector.bindInstance(Injector.class, injector);
bind(Injector.class).toInstance(injector);
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
if (classLoader == null) {
classLoader = getClass().getClassLoader();
}
try {
for (Iterator<URL> it = classLoader
.getResources("META-INF/maven/org.apache.maven.api.di.Inject")
.asIterator();
it.hasNext(); ) {
URL url = it.next();
try (InputStream is = url.openStream()) {
String[] lines = new String(is.readAllBytes()).split("\n");
for (String className : lines) {
try {
Class<?> clazz = classLoader.loadClass(className);
injector.bindImplicit(clazz);
Class<Object> itf = (Class)
(clazz.isInterface()
? clazz
: clazz.getInterfaces().length > 0 ? clazz.getInterfaces()[0] : null);
if (itf != null) {
bind(itf).toProvider(() -> injector.getInstance(clazz));
}
} catch (ClassNotFoundException e) {
// ignore
e.printStackTrace();
}
}
}
}
} catch (IOException e) {
throw new MavenException(e);
}
Stream.of(
LanguageProvider.class,
LifecycleProvider.class,
PackagingProvider.class,
DefaultArtifactCoordinateFactory.class,
DefaultArtifactDeployer.class,
DefaultArtifactFactory.class,
DefaultArtifactInstaller.class,
DefaultArtifactResolver.class,
DefaultChecksumAlgorithmService.class,
DefaultDependencyCollector.class,
DefaultDependencyCoordinateFactory.class,
DefaultLocalRepositoryManager.class,
DefaultMessageBuilderFactory.class,
DefaultModelXmlFactory.class,
DefaultRepositoryFactory.class,
DefaultSettingsBuilder.class,
DefaultSettingsXmlFactory.class,
DefaultToolchainsBuilder.class,
DefaultToolchainsXmlFactory.class,
DefaultTransportProvider.class,
DefaultVersionParser.class,
DefaultVersionRangeResolver.class,
DefaultVersionResolver.class,
DefaultVersionSchemeProvider.class,
VersionScheme.class,
DefaultModelVersionParser.class,
DefaultRepositorySystemSessionFactory.class,
LegacyRepositorySystemSessionExtender.class,
ExtensibleEnumRegistries.DefaultLanguageRegistry.class,
ExtensibleEnumRegistries.DefaultPathScopeRegistry.class,
ExtensibleEnumRegistries.DefaultProjectScopeRegistry.class,
DefaultModelBuilder.class,
DefaultModelProcessor.class,
ModelParser.class,
DefaultModelValidator.class,
DefaultModelVersionProcessor.class,
DefaultModelNormalizer.class,
DefaultModelInterpolator.class,
DefaultPathTranslator.class,
DefaultUrlNormalizer.class,
DefaultRootLocator.class,
DefaultModelPathTranslator.class,
DefaultModelUrlNormalizer.class,
DefaultSuperPomProvider.class,
DefaultInheritanceAssembler.class,
DefaultProfileSelector.class,
ProfileActivator.class,
DefaultProfileInjector.class,
DefaultPluginManagementInjector.class,
DefaultDependencyManagementInjector.class,
DefaultDependencyManagementImporter.class,
DefaultLifecycleBindingsInjector.class,
DefaultPluginConfigurationExpander.class,
ProfileActivationFilePathInterpolator.class,
BuildModelTransformer.class,
DefaultArtifactDescriptorReader.class,
DistributionManagementArtifactRelocationSource.class,
UserPropertiesArtifactRelocationSource.class,
FileProfileActivator.class,
JdkVersionProfileActivator.class,
OperatingSystemProfileActivator.class,
PackagingProfileActivator.class,
PropertyProfileActivator.class)
.forEach((Class<?> clazz) -> {
injector.bindImplicit(clazz);
Class<Object> itf = (Class)
(clazz.isInterface()
? null
: clazz.getInterfaces().length > 0 ? clazz.getInterfaces()[0] : null);
if (itf != null) {
bind(itf).toProvider(() -> injector.getInstance(clazz));
}
});
| 39
| 1,939
| 1,978
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/transformation/impl/DefaultConsumerPomArtifactTransformer.java
|
DefaultConsumerPomArtifactTransformer
|
remapDeployArtifacts
|
class DefaultConsumerPomArtifactTransformer implements ConsumerPomArtifactTransformer {
private static final String CONSUMER_POM_CLASSIFIER = "consumer";
private static final String BUILD_POM_CLASSIFIER = "build";
private static final String NAMESPACE_FORMAT = "http://maven.apache.org/POM/%s";
private static final String SCHEMA_LOCATION_FORMAT = "https://maven.apache.org/xsd/maven-%s.xsd";
private final Set<Path> toDelete = new CopyOnWriteArraySet<>();
private final ConsumerPomBuilder builder;
@Inject
DefaultConsumerPomArtifactTransformer(ConsumerPomBuilder builder) {
this.builder = builder;
}
@SuppressWarnings("deprecation")
public void injectTransformedArtifacts(RepositorySystemSession session, MavenProject project) throws IOException {
if (project.getFile() == null) {
// If there is no build POM there is no reason to inject artifacts for the consumer POM.
return;
}
if (Features.buildConsumer(session.getUserProperties())) {
Path buildDir =
project.getBuild() != null ? Paths.get(project.getBuild().getDirectory()) : null;
if (buildDir != null) {
Files.createDirectories(buildDir);
}
Path consumer = buildDir != null
? Files.createTempFile(buildDir, CONSUMER_POM_CLASSIFIER + "-", ".pom")
: Files.createTempFile(CONSUMER_POM_CLASSIFIER + "-", ".pom");
deferDeleteFile(consumer);
project.addAttachedArtifact(createConsumerPomArtifact(project, consumer, session));
} else if (project.getModel().getDelegate().isRoot()) {
throw new IllegalStateException(
"The use of the root attribute on the model requires the buildconsumer feature to be active");
}
}
TransformedArtifact createConsumerPomArtifact(
MavenProject project, Path consumer, RepositorySystemSession session) {
return new TransformedArtifact(
this,
project,
consumer,
session,
new ProjectArtifact(project),
() -> project.getFile().toPath(),
CONSUMER_POM_CLASSIFIER,
"pom");
}
void transform(MavenProject project, RepositorySystemSession session, Path src, Path tgt)
throws ModelBuildingException, XMLStreamException, IOException {
Model model = builder.build(session, project, src);
write(model, tgt);
}
private void deferDeleteFile(Path generatedFile) {
toDelete.add(generatedFile.toAbsolutePath());
}
@PreDestroy
private void doDeleteFiles() {
for (Path file : toDelete) {
try {
Files.delete(file);
} catch (IOException e) {
// ignore, we did our best...
}
}
}
public InstallRequest remapInstallArtifacts(RepositorySystemSession session, InstallRequest request) {
if (Features.buildConsumer(session.getUserProperties()) && consumerPomPresent(request.getArtifacts())) {
request.setArtifacts(replacePom(request.getArtifacts()));
}
return request;
}
public DeployRequest remapDeployArtifacts(RepositorySystemSession session, DeployRequest request) {<FILL_FUNCTION_BODY>}
private boolean consumerPomPresent(Collection<Artifact> artifacts) {
return artifacts.stream()
.anyMatch(a -> "pom".equals(a.getExtension()) && CONSUMER_POM_CLASSIFIER.equals(a.getClassifier()));
}
private Collection<Artifact> replacePom(Collection<Artifact> artifacts) {
List<Artifact> consumers = new ArrayList<>();
List<Artifact> mains = new ArrayList<>();
for (Artifact artifact : artifacts) {
if ("pom".equals(artifact.getExtension()) || artifact.getExtension().startsWith("pom.")) {
if (CONSUMER_POM_CLASSIFIER.equals(artifact.getClassifier())) {
consumers.add(artifact);
} else if ("".equals(artifact.getClassifier())) {
mains.add(artifact);
}
}
}
if (!mains.isEmpty() && !consumers.isEmpty()) {
ArrayList<Artifact> result = new ArrayList<>(artifacts);
for (Artifact main : mains) {
result.remove(main);
result.add(new DefaultArtifact(
main.getGroupId(),
main.getArtifactId(),
BUILD_POM_CLASSIFIER,
main.getExtension(),
main.getVersion(),
main.getProperties(),
main.getFile()));
}
for (Artifact consumer : consumers) {
result.remove(consumer);
result.add(new DefaultArtifact(
consumer.getGroupId(),
consumer.getArtifactId(),
"",
consumer.getExtension(),
consumer.getVersion(),
consumer.getProperties(),
consumer.getFile()));
}
artifacts = result;
}
return artifacts;
}
void write(Model model, Path dest) throws IOException, XMLStreamException {
String version = model.getModelVersion();
Files.createDirectories(dest.getParent());
try (Writer w = Files.newBufferedWriter(dest)) {
MavenStaxWriter writer = new MavenStaxWriter();
writer.setNamespace(String.format(NAMESPACE_FORMAT, version));
writer.setSchemaLocation(String.format(SCHEMA_LOCATION_FORMAT, version));
writer.setAddLocationInformation(false);
writer.write(w, model);
}
}
}
|
if (Features.buildConsumer(session.getUserProperties()) && consumerPomPresent(request.getArtifacts())) {
request.setArtifacts(replacePom(request.getArtifacts()));
}
return request;
| 1,493
| 60
| 1,553
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/transformation/impl/DefaultConsumerPomBuilder.java
|
DefaultConsumerPomBuilder
|
prune
|
class DefaultConsumerPomBuilder implements ConsumerPomBuilder {
private static final String BOM_PACKAGING = "bom";
public static final String POM_PACKAGING = "pom";
@Inject
private ProfileInjector profileInjector;
@Inject
private InheritanceAssembler inheritanceAssembler;
@Inject
private DependencyManagementImporter dependencyManagementImporter;
@Inject
private DependencyManagementInjector dependencyManagementInjector;
@Inject
private LifecycleBindingsInjector lifecycleBindingsInjector;
@Inject
private ModelInterpolator modelInterpolator;
@Inject
private ModelNormalizer modelNormalizer;
@Inject
private ModelPathTranslator modelPathTranslator;
@Inject
private ModelProcessor modelProcessor;
@Inject
private ModelUrlNormalizer modelUrlNormalizer;
@Inject
private ModelValidator modelValidator;
@Inject
private PluginConfigurationExpander pluginConfigurationExpander;
@Inject
private PluginManagementInjector pluginManagementInjector;
@Inject
private SuperPomProvider superPomProvider;
@Inject
private ModelVersionParser versionParser;
@Inject
private ModelTransformer modelTransformer;
// To break circular dependency
@Inject
private Provider<RepositorySystem> repositorySystem;
@Inject
private RemoteRepositoryManager remoteRepositoryManager;
@Override
public Model build(RepositorySystemSession session, MavenProject project, Path src) throws ModelBuilderException {
Model model = project.getModel().getDelegate();
String packaging = model.getPackaging();
String originalPackaging = project.getOriginalModel().getPackaging();
if (POM_PACKAGING.equals(packaging) && !BOM_PACKAGING.equals(originalPackaging)) {
return buildPom(session, project, src);
} else {
return buildNonPom(session, project, src);
}
}
protected Model buildPom(RepositorySystemSession session, MavenProject project, Path src)
throws ModelBuilderException {
ModelBuilderResult result = buildModel(session, project, src);
Model model = result.getRawModel();
return transform(model, project);
}
protected Model buildNonPom(RepositorySystemSession session, MavenProject project, Path src)
throws ModelBuilderException {
ModelBuilderResult result = buildModel(session, project, src);
Model model = result.getEffectiveModel();
return transform(model, project);
}
private ModelBuilderResult buildModel(RepositorySystemSession session, MavenProject project, Path src)
throws ModelBuilderException {
ProfileSelector customSelector = new DefaultProfileSelector() {
@Override
public List<Profile> getActiveProfiles(
Collection<Profile> profiles, ProfileActivationContext context, ModelProblemCollector problems) {
return new ArrayList<>();
}
};
DefaultModelBuilder modelBuilder = new DefaultModelBuilder(
modelProcessor,
modelValidator,
modelNormalizer,
modelInterpolator,
modelPathTranslator,
modelUrlNormalizer,
superPomProvider,
inheritanceAssembler,
customSelector,
profileInjector,
pluginManagementInjector,
dependencyManagementInjector,
dependencyManagementImporter,
lifecycleBindingsInjector,
pluginConfigurationExpander,
null,
modelTransformer,
versionParser,
remoteRepositoryManager);
ModelBuilderRequest.ModelBuilderRequestBuilder request = ModelBuilderRequest.builder();
request.projectBuild(true);
request.session(InternalSession.from(session));
request.source(ModelSource.fromPath(src));
request.validationLevel(ModelBuilderRequest.VALIDATION_LEVEL_MINIMAL);
request.locationTracking(false);
request.modelResolver(
new DefaultModelResolver(remoteRepositoryManager, project.getRemoteProjectRepositories()));
request.transformerContextBuilder(modelBuilder.newTransformerContextBuilder());
request.systemProperties(session.getSystemProperties());
request.userProperties(session.getUserProperties());
return modelBuilder.build(request.build());
}
static Model transform(Model model, MavenProject project) {
String packaging = model.getPackaging();
if (POM_PACKAGING.equals(packaging)) {
// raw to consumer transform
model = model.withRoot(false).withModules(null);
if (model.getParent() != null) {
model = model.withParent(model.getParent().withRelativePath(null));
}
if (!model.isPreserveModelVersion()) {
model = model.withPreserveModelVersion(false);
String modelVersion = new MavenModelVersion().getModelVersion(model);
model = model.withModelVersion(modelVersion);
}
} else if (BOM_PACKAGING.equals(packaging)) {
DependencyManagement dependencyManagement =
project.getOriginalModel().getDependencyManagement().getDelegate();
List<Dependency> dependencies = new ArrayList<>();
String version = model.getVersion();
dependencyManagement
.getDependencies()
.forEach((dependency) -> dependencies.add(dependency.withVersion(version)));
Model.Builder builder = prune(
Model.newBuilder(model, true)
.preserveModelVersion(false)
.root(false)
.parent(null)
.dependencyManagement(dependencyManagement.withDependencies(dependencies))
.build(null),
model);
builder.packaging(POM_PACKAGING);
builder.profiles(model.getProfiles().stream()
.map(p -> prune(Profile.newBuilder(p, true), p).build())
.collect(Collectors.toList()));
model = builder.build();
String modelVersion = new MavenModelVersion().getModelVersion(model);
model = model.withModelVersion(modelVersion);
} else {
Model.Builder builder = prune(
Model.newBuilder(model, true)
.preserveModelVersion(false)
.root(false)
.parent(null)
.build(null),
model);
builder.profiles(model.getProfiles().stream()
.map(p -> prune(Profile.newBuilder(p, true), p).build())
.collect(Collectors.toList()));
model = builder.build();
String modelVersion = new MavenModelVersion().getModelVersion(model);
model = model.withModelVersion(modelVersion);
}
return model;
}
private static <T extends ModelBase.Builder> T prune(T builder, ModelBase model) {<FILL_FUNCTION_BODY>}
private static List<Repository> pruneRepositories(List<Repository> repositories) {
return repositories.stream()
.filter(r -> !org.apache.maven.api.Repository.CENTRAL_ID.equals(r.getId()))
.collect(Collectors.toList());
}
}
|
builder.properties(null).reporting(null);
if (model.getDistributionManagement() != null
&& model.getDistributionManagement().getRelocation() != null) {
// keep relocation only
builder.distributionManagement(DistributionManagement.newBuilder()
.relocation(model.getDistributionManagement().getRelocation())
.build());
}
// only keep repositories other than 'central'
builder.pluginRepositories(pruneRepositories(model.getPluginRepositories()));
builder.repositories(pruneRepositories(model.getRepositories()));
return builder;
| 1,797
| 162
| 1,959
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/internal/transformation/impl/TransformedArtifact.java
|
TransformedArtifact
|
mayUpdate
|
class TransformedArtifact extends DefaultArtifact {
private static final int SHA1_BUFFER_SIZE = 8192;
private final DefaultConsumerPomArtifactTransformer defaultConsumerPomArtifactTransformer;
private final MavenProject project;
private final Supplier<Path> sourcePathProvider;
private final Path target;
private final RepositorySystemSession session;
private final AtomicReference<String> sourceState;
TransformedArtifact(
DefaultConsumerPomArtifactTransformer defaultConsumerPomArtifactTransformer,
MavenProject project,
Path target,
RepositorySystemSession session,
org.apache.maven.artifact.Artifact source,
Supplier<Path> sourcePathProvider,
String classifier,
String extension) {
super(
source.getGroupId(),
source.getArtifactId(),
source.getVersionRange(),
source.getScope(),
extension,
classifier,
new TransformedArtifactHandler(
classifier, extension, source.getArtifactHandler().getPackaging()));
this.defaultConsumerPomArtifactTransformer = defaultConsumerPomArtifactTransformer;
this.project = project;
this.target = target;
this.session = session;
this.sourcePathProvider = sourcePathProvider;
this.sourceState = new AtomicReference<>(null);
}
@Override
public boolean isResolved() {
return getFile() != null;
}
@Override
public void setFile(File file) {
throw new UnsupportedOperationException("transformed artifact file cannot be set");
}
@Override
public synchronized File getFile() {
try {
String state = mayUpdate();
if (state == null) {
return null;
}
return target.toFile();
} catch (IOException | NoSuchAlgorithmException | XMLStreamException | ModelBuildingException e) {
throw new TransformationFailedException(e);
}
}
private String mayUpdate()
throws IOException, NoSuchAlgorithmException, XMLStreamException, ModelBuildingException {<FILL_FUNCTION_BODY>}
static String sha1(Path path) throws NoSuchAlgorithmException, IOException {
MessageDigest md = MessageDigest.getInstance("SHA-1");
try (InputStream fis = Files.newInputStream(path)) {
byte[] buffer = new byte[SHA1_BUFFER_SIZE];
int read;
while ((read = fis.read(buffer)) != -1) {
md.update(buffer, 0, read);
}
}
StringBuilder result = new StringBuilder();
for (byte b : md.digest()) {
result.append(String.format("%02x", b));
}
return result.toString();
}
}
|
String result;
Path src = sourcePathProvider.get();
if (src == null) {
Files.deleteIfExists(target);
result = null;
} else if (!Files.exists(src)) {
Files.deleteIfExists(target);
result = "";
} else {
String current = sha1(src);
String existing = sourceState.get();
if (!Objects.equals(current, existing)) {
defaultConsumerPomArtifactTransformer.transform(project, session, src, target);
Files.setLastModifiedTime(target, Files.getLastModifiedTime(src));
}
result = current;
}
sourceState.set(result);
return result;
| 698
| 179
| 877
|
<methods>public void <init>(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, org.apache.maven.artifact.handler.ArtifactHandler) ,public void <init>(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, org.apache.maven.artifact.handler.ArtifactHandler, boolean) ,public void <init>(java.lang.String, java.lang.String, org.apache.maven.artifact.versioning.VersionRange, java.lang.String, java.lang.String, java.lang.String, org.apache.maven.artifact.handler.ArtifactHandler) ,public void <init>(java.lang.String, java.lang.String, org.apache.maven.artifact.versioning.VersionRange, java.lang.String, java.lang.String, java.lang.String, org.apache.maven.artifact.handler.ArtifactHandler, boolean) ,public void addMetadata(org.apache.maven.artifact.metadata.ArtifactMetadata) ,public int compareTo(org.apache.maven.artifact.Artifact) ,public boolean equals(java.lang.Object) ,public org.apache.maven.artifact.handler.ArtifactHandler getArtifactHandler() ,public java.lang.String getArtifactId() ,public List<org.apache.maven.artifact.versioning.ArtifactVersion> getAvailableVersions() ,public java.lang.String getBaseVersion() ,public java.lang.String getClassifier() ,public java.lang.String getDependencyConflictId() ,public org.apache.maven.artifact.resolver.filter.ArtifactFilter getDependencyFilter() ,public List<java.lang.String> getDependencyTrail() ,public java.lang.String getDownloadUrl() ,public java.io.File getFile() ,public java.lang.String getGroupId() ,public java.lang.String getId() ,public Collection<org.apache.maven.artifact.metadata.ArtifactMetadata> getMetadataList() ,public org.apache.maven.artifact.repository.ArtifactRepository getRepository() ,public java.lang.String getScope() ,public org.apache.maven.artifact.versioning.ArtifactVersion getSelectedVersion() throws org.apache.maven.artifact.versioning.OverConstrainedVersionException,public java.lang.String getType() ,public java.lang.String getVersion() ,public org.apache.maven.artifact.versioning.VersionRange getVersionRange() ,public boolean hasClassifier() ,public int hashCode() ,public boolean isOptional() ,public boolean isRelease() ,public boolean isResolved() ,public boolean isSelectedVersionKnown() throws org.apache.maven.artifact.versioning.OverConstrainedVersionException,public boolean isSnapshot() ,public void selectVersion(java.lang.String) ,public void setArtifactHandler(org.apache.maven.artifact.handler.ArtifactHandler) ,public void setArtifactId(java.lang.String) ,public void setAvailableVersions(List<org.apache.maven.artifact.versioning.ArtifactVersion>) ,public void setBaseVersion(java.lang.String) ,public void setDependencyFilter(org.apache.maven.artifact.resolver.filter.ArtifactFilter) ,public void setDependencyTrail(List<java.lang.String>) ,public void setDownloadUrl(java.lang.String) ,public void setFile(java.io.File) ,public void setGroupId(java.lang.String) ,public void setOptional(boolean) ,public void setRelease(boolean) ,public void setRepository(org.apache.maven.artifact.repository.ArtifactRepository) ,public void setResolved(boolean) ,public void setResolvedVersion(java.lang.String) ,public void setScope(java.lang.String) ,public void setVersion(java.lang.String) ,public void setVersionRange(org.apache.maven.artifact.versioning.VersionRange) ,public java.lang.String toString() ,public void updateVersion(java.lang.String, org.apache.maven.artifact.repository.ArtifactRepository) <variables>private org.apache.maven.artifact.handler.ArtifactHandler artifactHandler,private java.lang.String artifactId,private List<org.apache.maven.artifact.versioning.ArtifactVersion> availableVersions,private java.lang.String baseVersion,private final non-sealed java.lang.String classifier,private org.apache.maven.artifact.resolver.filter.ArtifactFilter dependencyFilter,private List<java.lang.String> dependencyTrail,private java.lang.String downloadUrl,private volatile java.io.File file,private java.lang.String groupId,private Map<java.lang.Object,org.apache.maven.artifact.metadata.ArtifactMetadata> metadataMap,private boolean optional,private boolean release,private org.apache.maven.artifact.repository.ArtifactRepository repository,private volatile boolean resolved,private volatile java.lang.String scope,private final non-sealed java.lang.String type,private volatile java.lang.String version,private org.apache.maven.artifact.versioning.VersionRange versionRange
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycleExecutor.java
|
DefaultLifecycleExecutor
|
calculateExecutionPlan
|
class DefaultLifecycleExecutor implements LifecycleExecutor {
private final LifeCyclePluginAnalyzer lifeCyclePluginAnalyzer;
private final DefaultLifecycles defaultLifeCycles;
private final LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator;
private final LifecycleExecutionPlanCalculator lifecycleExecutionPlanCalculator;
private final MojoExecutor mojoExecutor;
private final LifecycleStarter lifecycleStarter;
@Inject
public DefaultLifecycleExecutor(
LifeCyclePluginAnalyzer lifeCyclePluginAnalyzer,
DefaultLifecycles defaultLifeCycles,
LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator,
LifecycleExecutionPlanCalculator lifecycleExecutionPlanCalculator,
MojoExecutor mojoExecutor,
LifecycleStarter lifecycleStarter) {
this.lifeCyclePluginAnalyzer = lifeCyclePluginAnalyzer;
this.defaultLifeCycles = defaultLifeCycles;
this.lifecycleTaskSegmentCalculator = lifecycleTaskSegmentCalculator;
this.lifecycleExecutionPlanCalculator = lifecycleExecutionPlanCalculator;
this.mojoExecutor = mojoExecutor;
this.lifecycleStarter = lifecycleStarter;
}
public void execute(MavenSession session) {
lifecycleStarter.execute(session);
}
// These methods deal with construction intact Plugin object that look like they come from a standard
// <plugin/> block in a Maven POM. We have to do some wiggling to pull the sources of information
// together and this really shows the problem of constructing a sensible default configuration but
// it's all encapsulated here so it appears normalized to the POM builder.
// We are going to take the project packaging and find all plugin in the default lifecycle and create
// fully populated Plugin objects, including executions with goals and default configuration taken
// from the plugin.xml inside a plugin.
//
// TODO This whole method could probably removed by injecting lifeCyclePluginAnalyzer straight into client site.
// TODO But for some reason the whole plexus appcontext refuses to start when I try this.
public Set<Plugin> getPluginsBoundByDefaultToAllLifecycles(String packaging) {
return lifeCyclePluginAnalyzer.getPluginsBoundByDefaultToAllLifecycles(packaging);
}
// USED BY MAVEN HELP PLUGIN
@Deprecated
public Map<String, Lifecycle> getPhaseToLifecycleMap() {
return defaultLifeCycles.getPhaseToLifecycleMap();
}
// Used by m2eclipse
@SuppressWarnings({"UnusedDeclaration"})
public MavenExecutionPlan calculateExecutionPlan(MavenSession session, boolean setup, String... tasks)
throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
MojoNotFoundException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,
PluginManagerException, LifecyclePhaseNotFoundException, LifecycleNotFoundException,
PluginVersionResolutionException {<FILL_FUNCTION_BODY>}
public MavenExecutionPlan calculateExecutionPlan(MavenSession session, String... tasks)
throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
MojoNotFoundException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,
PluginManagerException, LifecyclePhaseNotFoundException, LifecycleNotFoundException,
PluginVersionResolutionException {
return calculateExecutionPlan(session, true, tasks);
}
// Site 3.x
public void calculateForkedExecutions(MojoExecution mojoExecution, MavenSession session)
throws MojoNotFoundException, PluginNotFoundException, PluginResolutionException,
PluginDescriptorParsingException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,
LifecyclePhaseNotFoundException, LifecycleNotFoundException, PluginVersionResolutionException {
lifecycleExecutionPlanCalculator.calculateForkedExecutions(mojoExecution, session);
}
// Site 3.x
public List<MavenProject> executeForkedExecutions(MojoExecution mojoExecution, MavenSession session)
throws LifecycleExecutionException {
return mojoExecutor.executeForkedExecutions(mojoExecution, session);
}
}
|
List<TaskSegment> taskSegments =
lifecycleTaskSegmentCalculator.calculateTaskSegments(session, Arrays.asList(tasks));
TaskSegment mergedSegment = new TaskSegment(false);
for (TaskSegment taskSegment : taskSegments) {
mergedSegment.getTasks().addAll(taskSegment.getTasks());
}
return lifecycleExecutionPlanCalculator.calculateExecutionPlan(
session, session.getCurrentProject(), mergedSegment.getTasks(), setup);
| 1,118
| 125
| 1,243
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycles.java
|
DefaultLifecycles
|
getLifeCycles
|
class DefaultLifecycles {
public static final String[] STANDARD_LIFECYCLES = {"clean", "default", "site", "wrapper"};
private final Logger logger = LoggerFactory.getLogger(getClass());
// @Configuration(source="org/apache/maven/lifecycle/lifecycles.xml")
private final Lookup lookup;
private final LifecycleRegistry registry;
private Map<String, Lifecycle> customLifecycles;
public DefaultLifecycles() {
this.lookup = null;
this.registry = null;
}
/**
* @deprecated Use {@link #DefaultLifecycles(LifecycleRegistry,Lookup)} instead
*/
@Deprecated
public DefaultLifecycles(Map<String, Lifecycle> lifecycles, org.codehaus.plexus.logging.Logger logger) {
this.customLifecycles = lifecycles;
this.lookup = null;
this.registry = null;
}
@Inject
public DefaultLifecycles(LifecycleRegistry registry, Lookup lookup) {
this.lookup = lookup;
this.registry = registry;
}
/**
* Get lifecycle based on phase
*
* @param phase
* @return
*/
public Lifecycle get(String phase) {
return getPhaseToLifecycleMap().get(phase);
}
/**
* We use this to map all phases to the lifecycle that contains it. This is used so that a user can specify the
* phase they want to execute and we can easily determine what lifecycle we need to run.
*
* @return A map of lifecycles, indexed on id
*/
public Map<String, Lifecycle> getPhaseToLifecycleMap() {
// If people are going to make their own lifecycles then we need to tell people how to namespace them correctly
// so that they don't interfere with internally defined lifecycles.
Map<String, Lifecycle> phaseToLifecycleMap = new HashMap<>();
for (Lifecycle lifecycle : getLifeCycles()) {
logger.debug("Lifecycle {}", lifecycle);
for (String phase : lifecycle.getPhases()) {
// The first definition wins.
if (!phaseToLifecycleMap.containsKey(phase)) {
phaseToLifecycleMap.put(phase, lifecycle);
} else if (logger.isWarnEnabled()) {
Lifecycle original = phaseToLifecycleMap.get(phase);
logger.warn(
"Duplicated lifecycle phase {}. Defined in {} but also in {}",
phase,
original.getId(),
lifecycle.getId());
}
}
}
return phaseToLifecycleMap;
}
/**
* Returns an ordered list of lifecycles
*/
public List<Lifecycle> getLifeCycles() {<FILL_FUNCTION_BODY>}
private Map<String, Lifecycle> lookupLifecycles() {
// TODO: Remove the following code when maven-compat is gone
// This code is here to ensure maven-compat's EmptyLifecycleExecutor keeps on working.
if (lookup == null) {
return customLifecycles != null ? customLifecycles : new HashMap<>();
}
// Lifecycles cannot be cached as extensions might add custom lifecycles later in the execution.
try {
Map<String, Lifecycle> lifecycles = new HashMap<>(lookup.lookupMap(Lifecycle.class));
for (org.apache.maven.api.Lifecycle lf : registry) {
lifecycles.put(lf.id(), new Lifecycle(registry, lf));
}
return lifecycles;
} catch (LookupException e) {
throw new IllegalStateException("Unable to lookup lifecycles from the plexus container", e);
}
}
public String getLifecyclePhaseList() {
return getLifeCycles().stream().flatMap(l -> l.getPhases().stream()).collect(Collectors.joining(", "));
}
}
|
List<String> lifecycleIds = Arrays.asList(STANDARD_LIFECYCLES);
Comparator<String> comparator = (l, r) -> {
int lx = lifecycleIds.indexOf(l);
int rx = lifecycleIds.indexOf(r);
if (lx < 0 || rx < 0) {
return rx - lx;
} else {
return lx - rx;
}
};
Map<String, Lifecycle> lifecyclesMap = lookupLifecycles();
// ensure canonical order of standard lifecycles
return lifecyclesMap.values().stream()
.peek(l -> Objects.requireNonNull(l.getId(), "A lifecycle must have an id."))
.sorted(Comparator.comparing(Lifecycle::getId, comparator))
.collect(Collectors.toList());
| 1,130
| 242
| 1,372
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/Lifecycle.java
|
Lifecycle
|
getDefaultPhases
|
class Lifecycle {
public Lifecycle() {}
public Lifecycle(String id, List<String> phases, Map<String, LifecyclePhase> defaultPhases) {
this.id = id;
this.phases = phases;
this.defaultPhases = defaultPhases;
}
public Lifecycle(
org.apache.maven.api.services.LifecycleRegistry registry, org.apache.maven.api.Lifecycle lifecycle) {
this.lifecycle = lifecycle;
this.id = lifecycle.id();
this.phases = registry.computePhases(lifecycle);
this.defaultPhases = getDefaultPhases(lifecycle);
}
// <lifecycle>
// <id>clean</id>
// <phases>
// <phase>pre-clean</phase>
// <phase>clean</phase>
// <phase>post-clean</phase>
// </phases>
// <default-phases>
// <clean>org.apache.maven.plugins:maven-clean-plugin:clean</clean>
// </default-phases>
// </lifecycle>
private String id;
private List<String> phases;
private Map<String, LifecyclePhase> defaultPhases;
private org.apache.maven.api.Lifecycle lifecycle;
public String getId() {
return id;
}
public List<String> getPhases() {
return phases;
}
static Map<String, LifecyclePhase> getDefaultPhases(org.apache.maven.api.Lifecycle lifecycle) {<FILL_FUNCTION_BODY>}
public Map<String, LifecyclePhase> getDefaultLifecyclePhases() {
return defaultPhases;
}
@Deprecated
public Map<String, String> getDefaultPhases() {
return LifecyclePhase.toLegacyMap(getDefaultLifecyclePhases());
}
@Override
public String toString() {
return id + " -> " + phases;
}
}
|
Map<String, List<String>> goals = new HashMap<>();
lifecycle.phases().forEach(phase -> phase.plugins()
.forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
.forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())
.add(plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion()
+ ":" + goal)))));
return goals.entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getKey, e -> new LifecyclePhase(String.join(",", e.getValue()))));
| 574
| 180
| 754
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/LifecycleExecutionException.java
|
LifecycleExecutionException
|
createMessage
|
class LifecycleExecutionException extends Exception {
private MavenProject project;
public LifecycleExecutionException(String message) {
super(message);
}
public LifecycleExecutionException(Throwable cause) {
super(cause);
}
public LifecycleExecutionException(String message, Throwable cause) {
super(message, cause);
}
public LifecycleExecutionException(String message, MavenProject project) {
super(message);
this.project = project;
}
public LifecycleExecutionException(String message, MojoExecution execution, MavenProject project) {
super(message);
this.project = project;
}
public LifecycleExecutionException(String message, MojoExecution execution, MavenProject project, Throwable cause) {
super(message, cause);
this.project = project;
}
public LifecycleExecutionException(MojoExecution execution, MavenProject project, Throwable cause) {
this(new DefaultMessageBuilderFactory(), execution, project, cause);
}
public LifecycleExecutionException(
MessageBuilderFactory messageBuilderFactory,
MojoExecution execution,
MavenProject project,
Throwable cause) {
this(createMessage(messageBuilderFactory, execution, project, cause), execution, project, cause);
}
public MavenProject getProject() {
return project;
}
private static String createMessage(
MessageBuilderFactory messageBuilderFactory,
MojoExecution execution,
MavenProject project,
Throwable cause) {<FILL_FUNCTION_BODY>}
}
|
MessageBuilder buffer = messageBuilderFactory.builder(256);
buffer.a("Failed to execute goal");
if (execution != null) {
buffer.a(' ');
buffer.mojo(execution.getGroupId()
+ ':'
+ execution.getArtifactId()
+ ':'
+ execution.getVersion()
+ ':'
+ execution.getGoal());
buffer.a(' ').strong('(' + execution.getExecutionId() + ')');
}
if (project != null) {
buffer.a(" on project ");
buffer.project(project.getArtifactId());
}
if (cause != null) {
buffer.a(": ").failure(cause.getMessage());
}
return buffer.toString();
| 414
| 204
| 618
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.Throwable) <variables>static final long serialVersionUID
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/MavenExecutionPlan.java
|
MavenExecutionPlan
|
getNonThreadSafeMojos
|
class MavenExecutionPlan implements Iterable<ExecutionPlanItem> {
/*
At the moment, this class is totally immutable, and this is in line with thoughts about the
pre-calculated execution plan that stays the same during the execution.
If deciding to add mutable state to this class, it should be at least considered to
separate this into a separate mutable structure.
*/
private final List<ExecutionPlanItem> planItem;
private final Map<String, ExecutionPlanItem> lastMojoExecutionForAllPhases;
final List<String> phasesInExecutionPlan;
public MavenExecutionPlan(List<ExecutionPlanItem> planItem, DefaultLifecycles defaultLifecycles) {
this.planItem = planItem;
lastMojoExecutionForAllPhases = new LinkedHashMap<>();
LinkedHashSet<String> totalPhaseSet = new LinkedHashSet<>();
if (defaultLifecycles != null) {
for (String phase : getDistinctPhasesInOrderOfExecutionPlanAppearance(planItem)) {
final Lifecycle lifecycle = defaultLifecycles.get(phase);
if (lifecycle != null) {
totalPhaseSet.addAll(lifecycle.getPhases());
}
}
}
this.phasesInExecutionPlan = new ArrayList<>(totalPhaseSet);
Map<String, ExecutionPlanItem> lastInExistingPhases = new HashMap<>();
for (ExecutionPlanItem executionPlanItem : getExecutionPlanItems()) {
lastInExistingPhases.put(executionPlanItem.getLifecyclePhase(), executionPlanItem);
}
ExecutionPlanItem lastSeenExecutionPlanItem = null;
for (String phase : totalPhaseSet) {
ExecutionPlanItem forThisPhase = lastInExistingPhases.get(phase);
if (forThisPhase != null) {
lastSeenExecutionPlanItem = forThisPhase;
}
lastMojoExecutionForAllPhases.put(phase, lastSeenExecutionPlanItem);
}
}
public Iterator<ExecutionPlanItem> iterator() {
return getExecutionPlanItems().iterator();
}
/**
* Returns the last ExecutionPlanItem in the supplied phase. If no items are in the specified phase,
* the closest executionPlanItem from an earlier phase item will be returned.
*
* @param requestedPhase the requested phase
* The execution plan item
* @return The ExecutionPlanItem or null if none can be found
*/
public ExecutionPlanItem findLastInPhase(String requestedPhase) {
return lastMojoExecutionForAllPhases.get(requestedPhase);
}
private List<ExecutionPlanItem> getExecutionPlanItems() {
return planItem;
}
private static Iterable<String> getDistinctPhasesInOrderOfExecutionPlanAppearance(
List<ExecutionPlanItem> planItems) {
LinkedHashSet<String> result = new LinkedHashSet<>();
for (ExecutionPlanItem executionPlanItem : planItems) {
result.add(executionPlanItem.getLifecyclePhase());
}
return result;
}
public List<MojoExecution> getMojoExecutions() {
List<MojoExecution> result = new ArrayList<>();
for (ExecutionPlanItem executionPlanItem : planItem) {
result.add(executionPlanItem.getMojoExecution());
}
return result;
}
/**
* Get set of plugins having a goal/mojo used but not marked @threadSafe
*
* @return the set of plugins (without info on which goal is concerned)
*/
public Set<Plugin> getNonThreadSafePlugins() {
Set<Plugin> plugins = new HashSet<>();
for (ExecutionPlanItem executionPlanItem : planItem) {
final MojoExecution mojoExecution = executionPlanItem.getMojoExecution();
if (!mojoExecution.getMojoDescriptor().isThreadSafe()) {
plugins.add(mojoExecution.getPlugin());
}
}
return plugins;
}
/**
* Get set of mojos used but not marked @threadSafe
*
* @return the set of mojo descriptors
*/
public Set<MojoDescriptor> getNonThreadSafeMojos() {<FILL_FUNCTION_BODY>}
// Used by m2e but will be removed, really.
@Deprecated
public List<MojoExecution> getExecutions() {
return getMojoExecutions();
}
public int size() {
return planItem.size();
}
}
|
Set<MojoDescriptor> mojos = new HashSet<>();
for (ExecutionPlanItem executionPlanItem : planItem) {
final MojoExecution mojoExecution = executionPlanItem.getMojoExecution();
if (!mojoExecution.getMojoDescriptor().isThreadSafe()) {
mojos.add(mojoExecution.getMojoDescriptor());
}
}
return mojos;
| 1,166
| 99
| 1,265
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/BuildListCalculator.java
|
BuildListCalculator
|
calculateProjectBuilds
|
class BuildListCalculator {
public ProjectBuildList calculateProjectBuilds(MavenSession session, List<TaskSegment> taskSegments) {<FILL_FUNCTION_BODY>}
}
|
List<ProjectSegment> projectBuilds = new ArrayList<>();
MavenProject rootProject = session.getTopLevelProject();
for (TaskSegment taskSegment : taskSegments) {
List<MavenProject> projects;
if (taskSegment.isAggregating()) {
projects = Collections.singletonList(rootProject);
} else {
projects = session.getProjects();
}
for (MavenProject project : projects) {
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
MavenProject currentProject = session.getCurrentProject();
try {
BuilderCommon.attachToThread(project); // Not totally sure if this is needed for anything
session.setCurrentProject(project);
projectBuilds.add(new ProjectSegment(project, taskSegment, session));
} finally {
session.setCurrentProject(currentProject);
Thread.currentThread().setContextClassLoader(tccl);
}
}
}
return new ProjectBuildList(projectBuilds);
| 47
| 255
| 302
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultExecutionEventCatapult.java
|
DefaultExecutionEventCatapult
|
fire
|
class DefaultExecutionEventCatapult implements ExecutionEventCatapult {
@Override
public void fire(ExecutionEvent.Type eventType, MavenSession session, MojoExecution mojoExecution) {
fire(eventType, session, mojoExecution, null);
}
@Override
public void fire(
ExecutionEvent.Type eventType, MavenSession session, MojoExecution mojoExecution, Exception exception) {<FILL_FUNCTION_BODY>}
}
|
ExecutionListener listener = session.getRequest().getExecutionListener();
if (listener != null) {
ExecutionEvent event = new DefaultExecutionEvent(eventType, session, mojoExecution, exception);
switch (eventType) {
case ProjectDiscoveryStarted:
listener.projectDiscoveryStarted(event);
break;
case SessionStarted:
listener.sessionStarted(event);
break;
case SessionEnded:
listener.sessionEnded(event);
break;
case ProjectSkipped:
listener.projectSkipped(event);
break;
case ProjectStarted:
listener.projectStarted(event);
break;
case ProjectSucceeded:
listener.projectSucceeded(event);
break;
case ProjectFailed:
listener.projectFailed(event);
break;
case MojoSkipped:
listener.mojoSkipped(event);
break;
case MojoStarted:
listener.mojoStarted(event);
break;
case MojoSucceeded:
listener.mojoSucceeded(event);
break;
case MojoFailed:
listener.mojoFailed(event);
break;
case ForkStarted:
listener.forkStarted(event);
break;
case ForkSucceeded:
listener.forkSucceeded(event);
break;
case ForkFailed:
listener.forkFailed(event);
break;
case ForkedProjectStarted:
listener.forkedProjectStarted(event);
break;
case ForkedProjectSucceeded:
listener.forkedProjectSucceeded(event);
break;
case ForkedProjectFailed:
listener.forkedProjectFailed(event);
break;
default:
throw new IllegalStateException("Unknown execution event type " + eventType);
}
}
| 116
| 497
| 613
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleMappingDelegate.java
|
DefaultLifecycleMappingDelegate
|
calculateLifecycleMappings
|
class DefaultLifecycleMappingDelegate implements LifecycleMappingDelegate {
public static final String HINT = "default";
private final BuildPluginManager pluginManager;
@Inject
public DefaultLifecycleMappingDelegate(BuildPluginManager pluginManager) {
this.pluginManager = pluginManager;
}
@Override
public Map<String, List<MojoExecution>> calculateLifecycleMappings(
MavenSession session, MavenProject project, Lifecycle lifecycle, String lifecyclePhase)
throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
MojoNotFoundException, InvalidPluginDescriptorException {<FILL_FUNCTION_BODY>}
private void addMojoExecution(
Map<Integer, List<MojoExecution>> phaseBindings, MojoExecution mojoExecution, int priority) {
List<MojoExecution> mojoExecutions = phaseBindings.computeIfAbsent(priority, k -> new ArrayList<>());
mojoExecutions.add(mojoExecution);
}
}
|
/*
* Initialize mapping from lifecycle phase to bound mojos. The key set of this map denotes the phases the caller
* is interested in, i.e. all phases up to and including the specified phase.
*/
Map<String, Map<Integer, List<MojoExecution>>> mappings = new LinkedHashMap<>();
for (String phase : lifecycle.getPhases()) {
Map<Integer, List<MojoExecution>> phaseBindings = new TreeMap<>();
mappings.put(phase, phaseBindings);
if (phase.equals(lifecyclePhase)) {
break;
}
}
/*
* Grab plugin executions that are bound to the selected lifecycle phases from project. The effective model of
* the project already contains the plugin executions induced by the project's packaging type. Remember, all
* phases of interest and only those are in the lifecycle mapping, if a phase has no value in the map, we are
* not interested in any of the executions bound to it.
*/
for (Plugin plugin : project.getBuild().getPlugins()) {
for (PluginExecution execution : plugin.getExecutions()) {
// if the phase is specified then I don't have to go fetch the plugin yet and pull it down
// to examine the phase it is associated to.
if (execution.getPhase() != null) {
Map<Integer, List<MojoExecution>> phaseBindings = mappings.get(execution.getPhase());
if (phaseBindings != null) {
for (String goal : execution.getGoals()) {
MojoExecution mojoExecution = new MojoExecution(plugin, goal, execution.getId());
mojoExecution.setLifecyclePhase(execution.getPhase());
addMojoExecution(phaseBindings, mojoExecution, execution.getPriority());
}
}
}
// if not then I need to grab the mojo descriptor and look at the phase that is specified
else {
for (String goal : execution.getGoals()) {
MojoDescriptor mojoDescriptor = pluginManager.getMojoDescriptor(
plugin, goal, project.getRemotePluginRepositories(), session.getRepositorySession());
Map<Integer, List<MojoExecution>> phaseBindings = mappings.get(mojoDescriptor.getPhase());
if (phaseBindings != null) {
MojoExecution mojoExecution = new MojoExecution(mojoDescriptor, execution.getId());
mojoExecution.setLifecyclePhase(mojoDescriptor.getPhase());
addMojoExecution(phaseBindings, mojoExecution, execution.getPriority());
}
}
}
}
}
Map<String, List<MojoExecution>> lifecycleMappings = new LinkedHashMap<>();
for (Map.Entry<String, Map<Integer, List<MojoExecution>>> entry : mappings.entrySet()) {
List<MojoExecution> mojoExecutions = new ArrayList<>();
for (List<MojoExecution> executions : entry.getValue().values()) {
mojoExecutions.addAll(executions);
}
lifecycleMappings.put(entry.getKey(), mojoExecutions);
}
return lifecycleMappings;
| 264
| 814
| 1,078
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecyclePluginAnalyzer.java
|
DefaultLifecyclePluginAnalyzer
|
getExecutionId
|
class DefaultLifecyclePluginAnalyzer implements LifeCyclePluginAnalyzer {
public static final String DEFAULTLIFECYCLEBINDINGS_MODELID = "org.apache.maven:maven-core:"
+ DefaultLifecyclePluginAnalyzer.class.getPackage().getImplementationVersion()
+ ":default-lifecycle-bindings";
private final Logger logger = LoggerFactory.getLogger(getClass());
private final Lookup lookup;
private final DefaultLifecycles defaultLifeCycles;
@Inject
public DefaultLifecyclePluginAnalyzer(Lookup lookup, DefaultLifecycles defaultLifeCycles) {
this.lookup = requireNonNull(lookup);
this.defaultLifeCycles = requireNonNull(defaultLifeCycles);
}
// These methods deal with construction intact Plugin object that look like they come from a standard
// <plugin/> block in a Maven POM. We have to do some wiggling to pull the sources of information
// together and this really shows the problem of constructing a sensible default configuration but
// it's all encapsulated here so it appears normalized to the POM builder.
// We are going to take the project packaging and find all plugins in the default lifecycle and create
// fully populated Plugin objects, including executions with goals and default configuration taken
// from the plugin.xml inside a plugin.
//
@Override
public Set<Plugin> getPluginsBoundByDefaultToAllLifecycles(String packaging) {
if (logger.isDebugEnabled()) {
logger.debug("Looking up lifecycle mappings for packaging " + packaging + " from "
+ Thread.currentThread().getContextClassLoader());
}
LifecycleMapping lifecycleMappingForPackaging = lookupLifecycleMapping(packaging);
if (lifecycleMappingForPackaging == null) {
return null;
}
Map<Plugin, Plugin> plugins = new LinkedHashMap<>();
for (Lifecycle lifecycle : defaultLifeCycles.getLifeCycles()) {
org.apache.maven.lifecycle.mapping.Lifecycle lifecycleConfiguration =
lifecycleMappingForPackaging.getLifecycles().get(lifecycle.getId());
Map<String, LifecyclePhase> phaseToGoalMapping = null;
if (lifecycleConfiguration != null) {
phaseToGoalMapping = lifecycleConfiguration.getLifecyclePhases();
} else if (lifecycle.getDefaultLifecyclePhases() != null) {
phaseToGoalMapping = lifecycle.getDefaultLifecyclePhases();
}
if (phaseToGoalMapping != null) {
for (Map.Entry<String, LifecyclePhase> goalsForLifecyclePhase : phaseToGoalMapping.entrySet()) {
String phase = goalsForLifecyclePhase.getKey();
LifecyclePhase goals = goalsForLifecyclePhase.getValue();
if (goals != null) {
parseLifecyclePhaseDefinitions(plugins, phase, goals);
}
}
}
}
return plugins.keySet();
}
/**
* Performs a lookup using Plexus API to make sure we can look up only "visible" (see Maven classloading) components
* from current module and for example not extensions coming from other modules.
*/
private LifecycleMapping lookupLifecycleMapping(final String packaging) {
return lookup.lookupOptional(LifecycleMapping.class, packaging).orElse(null);
}
private void parseLifecyclePhaseDefinitions(Map<Plugin, Plugin> plugins, String phase, LifecyclePhase goals) {
InputSource inputSource = new InputSource();
inputSource.setModelId(DEFAULTLIFECYCLEBINDINGS_MODELID);
InputLocation location = new InputLocation(-1, -1, inputSource);
location.setLocation(0, location);
List<LifecycleMojo> mojos = goals.getMojos();
if (mojos != null) {
for (int i = 0; i < mojos.size(); i++) {
LifecycleMojo mojo = mojos.get(i);
GoalSpec gs = parseGoalSpec(mojo.getGoal());
if (gs == null) {
logger.warn(
"Ignored invalid goal specification '{}' from lifecycle mapping for phase {}",
mojo.getGoal(),
phase);
continue;
}
Plugin plugin = new Plugin();
plugin.setGroupId(gs.groupId);
plugin.setArtifactId(gs.artifactId);
plugin.setVersion(gs.version);
plugin.setLocation("", location);
plugin.setLocation("groupId", location);
plugin.setLocation("artifactId", location);
plugin.setLocation("version", location);
Plugin existing = plugins.get(plugin);
if (existing != null) {
if (existing.getVersion() == null) {
existing.setVersion(plugin.getVersion());
existing.setLocation("version", location);
}
plugin = existing;
} else {
plugins.put(plugin, plugin);
}
PluginExecution execution = new PluginExecution();
execution.setId(getExecutionId(plugin, gs.goal));
execution.setPhase(phase);
execution.setPriority(i - mojos.size());
execution.getGoals().add(gs.goal);
execution.setLocation("", location);
execution.setLocation("id", location);
execution.setLocation("phase", location);
execution.setLocation("goals", location);
XmlNode lifecycleConfiguration = mojo.getConfiguration();
if (lifecycleConfiguration != null) {
execution.setConfiguration(new Xpp3Dom(lifecycleConfiguration));
}
if (mojo.getDependencies() != null) {
plugin.setDependencies(mojo.getDependencies());
}
plugin.getExecutions().add(execution);
}
}
}
private GoalSpec parseGoalSpec(String goalSpec) {
GoalSpec gs = new GoalSpec();
String[] p = goalSpec.trim().split(":");
if (p.length == 3) {
// <groupId>:<artifactId>:<goal>
gs.groupId = p[0];
gs.artifactId = p[1];
gs.goal = p[2];
} else if (p.length == 4) {
// <groupId>:<artifactId>:<version>:<goal>
gs.groupId = p[0];
gs.artifactId = p[1];
gs.version = p[2];
gs.goal = p[3];
} else {
// invalid
gs = null;
}
return gs;
}
private String getExecutionId(Plugin plugin, String goal) {<FILL_FUNCTION_BODY>}
static class GoalSpec {
String groupId;
String artifactId;
String version;
String goal;
}
}
|
Set<String> existingIds = new HashSet<>();
for (PluginExecution execution : plugin.getExecutions()) {
existingIds.add(execution.getId());
}
String base = "default-" + goal;
String id = base;
for (int index = 1; existingIds.contains(id); index++) {
id = base + '-' + index;
}
return id;
| 1,863
| 106
| 1,969
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleStarter.java
|
DefaultLifecycleStarter
|
execute
|
class DefaultLifecycleStarter implements LifecycleStarter {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final ExecutionEventCatapult eventCatapult;
private final DefaultLifecycles defaultLifeCycles;
private final BuildListCalculator buildListCalculator;
private final LifecycleDebugLogger lifecycleDebugLogger;
private final LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator;
private final Map<String, Builder> builders;
@Inject
public DefaultLifecycleStarter(
ExecutionEventCatapult eventCatapult,
DefaultLifecycles defaultLifeCycles,
BuildListCalculator buildListCalculator,
LifecycleDebugLogger lifecycleDebugLogger,
LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator,
Map<String, Builder> builders) {
this.eventCatapult = eventCatapult;
this.defaultLifeCycles = defaultLifeCycles;
this.buildListCalculator = buildListCalculator;
this.lifecycleDebugLogger = lifecycleDebugLogger;
this.lifecycleTaskSegmentCalculator = lifecycleTaskSegmentCalculator;
this.builders = builders;
}
@Override
public void execute(MavenSession session) {<FILL_FUNCTION_BODY>}
private boolean buildExecutionRequiresProject(MavenSession session) {
return lifecycleTaskSegmentCalculator.requiresProject(session);
}
private boolean projectIsNotPresent(MavenSession session) {
return !session.getRequest().isProjectPresent();
}
}
|
eventCatapult.fire(ExecutionEvent.Type.SessionStarted, session, null);
ReactorContext reactorContext = null;
ProjectBuildList projectBuilds = null;
MavenExecutionResult result = session.getResult();
try {
if (buildExecutionRequiresProject(session) && projectIsNotPresent(session)) {
throw new MissingProjectException("The goal you specified requires a project to execute"
+ " but there is no POM in this directory (" + session.getExecutionRootDirectory() + ")."
+ " Please verify you invoked Maven from the correct directory.");
}
List<TaskSegment> taskSegments = lifecycleTaskSegmentCalculator.calculateTaskSegments(session);
projectBuilds = buildListCalculator.calculateProjectBuilds(session, taskSegments);
if (projectBuilds.isEmpty()) {
throw new NoGoalSpecifiedException("No goals have been specified for this build."
+ " You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or"
+ " <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>."
+ " Available lifecycle phases are: " + defaultLifeCycles.getLifecyclePhaseList() + ".");
}
if (logger.isDebugEnabled()) {
lifecycleDebugLogger.debugReactorPlan(projectBuilds);
}
ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();
ReactorBuildStatus reactorBuildStatus = new ReactorBuildStatus(session.getProjectDependencyGraph());
reactorContext = new ReactorContext(result, oldContextClassLoader, reactorBuildStatus);
String builderId = session.getRequest().getBuilderId();
Builder builder = builders.get(builderId);
if (builder == null) {
throw new BuilderNotFoundException(
String.format("The builder requested using id = %s cannot be" + " found", builderId));
}
int degreeOfConcurrency = session.getRequest().getDegreeOfConcurrency();
if (degreeOfConcurrency > 1) {
logger.info("");
logger.info(String.format(
"Using the %s implementation with a thread count of %d",
builder.getClass().getSimpleName(), degreeOfConcurrency));
}
builder.build(session, reactorContext, projectBuilds, taskSegments, reactorBuildStatus);
} catch (Exception e) {
result.addException(e);
} finally {
eventCatapult.fire(ExecutionEvent.Type.SessionEnded, session, null);
}
| 428
| 662
| 1,090
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleTaskSegmentCalculator.java
|
DefaultLifecycleTaskSegmentCalculator
|
calculateTaskSegments
|
class DefaultLifecycleTaskSegmentCalculator implements LifecycleTaskSegmentCalculator {
private final MojoDescriptorCreator mojoDescriptorCreator;
private final LifecyclePluginResolver lifecyclePluginResolver;
@Inject
public DefaultLifecycleTaskSegmentCalculator(
MojoDescriptorCreator mojoDescriptorCreator, LifecyclePluginResolver lifecyclePluginResolver) {
this.mojoDescriptorCreator = mojoDescriptorCreator;
this.lifecyclePluginResolver = lifecyclePluginResolver;
}
@Override
public List<TaskSegment> calculateTaskSegments(MavenSession session)
throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
MojoNotFoundException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,
PluginVersionResolutionException, LifecyclePhaseNotFoundException, LifecycleNotFoundException {
MavenProject rootProject = session.getTopLevelProject();
List<String> tasks = requireNonNull(session.getGoals()); // session never returns null, but empty list
if (tasks.isEmpty()
&& (rootProject.getDefaultGoal() != null
&& !rootProject.getDefaultGoal().isEmpty())) {
tasks = Stream.of(rootProject.getDefaultGoal().split("\\s+"))
.filter(g -> !g.isEmpty())
.collect(Collectors.toList());
}
return calculateTaskSegments(session, tasks);
}
@Override
public List<TaskSegment> calculateTaskSegments(MavenSession session, List<String> tasks)
throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
MojoNotFoundException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,
PluginVersionResolutionException {<FILL_FUNCTION_BODY>}
@Override
public boolean requiresProject(MavenSession session) {
List<String> goals = session.getGoals();
if (goals != null) {
for (String goal : goals) {
if (!isGoalSpecification(goal)) {
return true;
}
}
}
return false;
}
private boolean isGoalSpecification(String task) {
return task.indexOf(':') >= 0;
}
}
|
List<TaskSegment> taskSegments = new ArrayList<>(tasks.size());
TaskSegment currentSegment = null;
for (String task : tasks) {
if (isGoalSpecification(task)) {
// "pluginPrefix[:version]:goal" or "groupId:artifactId[:version]:goal"
lifecyclePluginResolver.resolveMissingPluginVersions(session.getTopLevelProject(), session);
MojoDescriptor mojoDescriptor =
mojoDescriptorCreator.getMojoDescriptor(task, session, session.getTopLevelProject());
boolean aggregating = mojoDescriptor.isAggregator() || !mojoDescriptor.isProjectRequired();
if (currentSegment == null || currentSegment.isAggregating() != aggregating) {
currentSegment = new TaskSegment(aggregating);
taskSegments.add(currentSegment);
}
currentSegment.getTasks().add(new GoalTask(task));
} else {
// lifecycle phase
if (currentSegment == null || currentSegment.isAggregating()) {
currentSegment = new TaskSegment(false);
taskSegments.add(currentSegment);
}
currentSegment.getTasks().add(new LifecycleTask(task));
}
}
return taskSegments;
| 584
| 320
| 904
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultMojoExecutionConfigurator.java
|
DefaultMojoExecutionConfigurator
|
configure
|
class DefaultMojoExecutionConfigurator implements MojoExecutionConfigurator {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final MessageBuilderFactory messageBuilderFactory;
/**
* Default ctor is used in IT and most probably some 3rd party code. For those cases, we do provide sane defaults
* but given this is a component, injection should be used, replacing direct instantiation.
*
* @deprecated Do not use this ctor directly, inject this component instead.
*/
@Deprecated
public DefaultMojoExecutionConfigurator() {
this.messageBuilderFactory = new DefaultMessageBuilderFactory();
}
@Inject
public DefaultMojoExecutionConfigurator(MessageBuilderFactory messageBuilderFactory) {
this.messageBuilderFactory = requireNonNull(messageBuilderFactory);
}
@Override
public void configure(MavenProject project, MojoExecution mojoExecution, boolean allowPluginLevelConfig) {<FILL_FUNCTION_BODY>}
private Plugin findPlugin(String groupId, String artifactId, Collection<Plugin> plugins) {
for (Plugin plugin : plugins) {
if (artifactId.equals(plugin.getArtifactId()) && groupId.equals(plugin.getGroupId())) {
return plugin;
}
}
return null;
}
private PluginExecution findPluginExecution(String executionId, Collection<PluginExecution> executions) {
if (executionId != null && !executionId.isEmpty()) {
for (PluginExecution execution : executions) {
if (executionId.equals(execution.getId())) {
return execution;
}
}
}
return null;
}
private void checkUnknownMojoConfigurationParameters(MojoExecution mojoExecution) {
if (mojoExecution.getConfiguration() == null
|| mojoExecution.getConfiguration().getChildCount() == 0) {
return;
}
MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
// in first step get parameter names of current goal
Set<String> parametersNamesGoal = mojoDescriptor.getParameters().stream()
.flatMap(this::getParameterNames)
.collect(Collectors.toSet());
Set<String> unknownParameters = getUnknownParameters(mojoExecution, parametersNamesGoal);
if (unknownParameters.isEmpty()) {
return;
}
// second step get parameter names of all plugin goals
Set<String> parametersNamesAll = mojoDescriptor.getPluginDescriptor().getMojos().stream()
.flatMap(m -> m.getParameters().stream())
.flatMap(this::getParameterNames)
.collect(Collectors.toSet());
unknownParameters = getUnknownParameters(mojoExecution, parametersNamesAll);
unknownParameters.forEach(name -> {
MessageBuilder messageBuilder = messageBuilderFactory
.builder()
.warning("Parameter '")
.warning(name)
.warning("' is unknown for plugin '")
.warning(mojoExecution.getArtifactId())
.warning(":")
.warning(mojoExecution.getVersion())
.warning(":")
.warning(mojoExecution.getGoal());
if (mojoExecution.getExecutionId() != null) {
messageBuilder.warning(" (");
messageBuilder.warning(mojoExecution.getExecutionId());
messageBuilder.warning(")");
}
messageBuilder.warning("'");
logger.warn(messageBuilder.toString());
});
}
private Stream<String> getParameterNames(Parameter parameter) {
if (parameter.getAlias() != null) {
return Stream.of(parameter.getName(), parameter.getAlias());
} else {
return Stream.of(parameter.getName());
}
}
private Set<String> getUnknownParameters(MojoExecution mojoExecution, Set<String> parameters) {
return stream(mojoExecution.getConfiguration().getChildren())
.map(Xpp3Dom::getName)
.filter(name -> !parameters.contains(name))
.collect(Collectors.toSet());
}
}
|
String g = mojoExecution.getPlugin().getGroupId();
String a = mojoExecution.getPlugin().getArtifactId();
Plugin plugin = findPlugin(g, a, project.getBuildPlugins());
if (plugin == null && project.getPluginManagement() != null) {
plugin = findPlugin(g, a, project.getPluginManagement().getPlugins());
}
if (plugin != null) {
PluginExecution pluginExecution =
findPluginExecution(mojoExecution.getExecutionId(), plugin.getExecutions());
XmlNode pomConfiguration = null;
if (pluginExecution != null) {
pomConfiguration = pluginExecution.getDelegate().getConfiguration();
} else if (allowPluginLevelConfig) {
pomConfiguration = plugin.getDelegate().getConfiguration();
}
XmlNode mojoConfiguration = mojoExecution.getConfiguration() != null
? mojoExecution.getConfiguration().getDom()
: null;
XmlNode mergedConfiguration = XmlNodeImpl.merge(mojoConfiguration, pomConfiguration);
mojoExecution.setConfiguration(mergedConfiguration);
checkUnknownMojoConfigurationParameters(mojoExecution);
}
| 1,028
| 304
| 1,332
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultProjectArtifactFactory.java
|
DefaultProjectArtifactFactory
|
getEffectiveScope
|
class DefaultProjectArtifactFactory implements ProjectArtifactFactory {
private final ArtifactFactory artifactFactory;
@Inject
public DefaultProjectArtifactFactory(ArtifactFactory artifactFactory) {
this.artifactFactory = artifactFactory;
}
@Override
public Set<Artifact> createArtifacts(MavenProject project) throws InvalidDependencyVersionException {
return createArtifacts(artifactFactory, project.getDependencies(), null, null, project);
}
public static Set<Artifact> createArtifacts(
ArtifactFactory artifactFactory,
List<Dependency> dependencies,
String inheritedScope,
ArtifactFilter dependencyFilter,
MavenProject project)
throws InvalidDependencyVersionException {
Set<Artifact> artifacts = new LinkedHashSet<>();
for (Dependency d : dependencies) {
Artifact dependencyArtifact;
try {
dependencyArtifact = createDependencyArtifact(artifactFactory, d, inheritedScope, dependencyFilter);
} catch (InvalidVersionSpecificationException e) {
throw new InvalidDependencyVersionException(project.getId(), d, project.getFile(), e);
}
if (dependencyArtifact != null) {
artifacts.add(dependencyArtifact);
}
}
return artifacts;
}
private static Artifact createDependencyArtifact(
ArtifactFactory factory, Dependency dependency, String inheritedScope, ArtifactFilter inheritedFilter)
throws InvalidVersionSpecificationException {
String effectiveScope = getEffectiveScope(dependency.getScope(), inheritedScope);
if (effectiveScope == null) {
return null;
}
VersionRange versionRange = VersionRange.createFromVersionSpec(dependency.getVersion());
Artifact dependencyArtifact = factory.createDependencyArtifact(
dependency.getGroupId(),
dependency.getArtifactId(),
versionRange,
dependency.getType(),
dependency.getClassifier(),
effectiveScope,
dependency.isOptional());
if (inheritedFilter != null && !inheritedFilter.include(dependencyArtifact)) {
return null;
}
if (Artifact.SCOPE_SYSTEM.equals(effectiveScope)) {
dependencyArtifact.setFile(new File(dependency.getSystemPath()));
}
dependencyArtifact.setDependencyFilter(createDependencyFilter(dependency, inheritedFilter));
return dependencyArtifact;
}
private static String getEffectiveScope(String originalScope, String inheritedScope) {<FILL_FUNCTION_BODY>}
private static ArtifactFilter createDependencyFilter(Dependency dependency, ArtifactFilter inheritedFilter) {
ArtifactFilter effectiveFilter = inheritedFilter;
if (!dependency.getExclusions().isEmpty()) {
effectiveFilter = new ExclusionArtifactFilter(dependency.getExclusions());
if (inheritedFilter != null) {
effectiveFilter = new AndArtifactFilter(Arrays.asList(inheritedFilter, effectiveFilter));
}
}
return effectiveFilter;
}
}
|
String effectiveScope = Artifact.SCOPE_RUNTIME;
if (originalScope == null) {
originalScope = Artifact.SCOPE_COMPILE;
}
if (inheritedScope == null) {
// direct dependency retains its scope
effectiveScope = originalScope;
} else if (Artifact.SCOPE_TEST.equals(originalScope) || Artifact.SCOPE_PROVIDED.equals(originalScope)) {
// test and provided are not transitive, so exclude them
effectiveScope = null;
} else if (Artifact.SCOPE_SYSTEM.equals(originalScope)) {
// system scope come through unchanged...
effectiveScope = Artifact.SCOPE_SYSTEM;
} else if (Artifact.SCOPE_COMPILE.equals(originalScope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
// added to retain compile scope. Remove if you want compile inherited as runtime
effectiveScope = Artifact.SCOPE_COMPILE;
} else if (Artifact.SCOPE_TEST.equals(inheritedScope)) {
effectiveScope = Artifact.SCOPE_TEST;
} else if (Artifact.SCOPE_PROVIDED.equals(inheritedScope)) {
effectiveScope = Artifact.SCOPE_PROVIDED;
}
return effectiveScope;
| 736
| 344
| 1,080
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DependencyContext.java
|
DependencyContext
|
isResolutionRequiredForCurrentProject
|
class DependencyContext {
private final MavenProject project;
private final Collection<String> scopesToCollectForCurrentProject;
private final Collection<String> scopesToResolveForCurrentProject;
private final Collection<String> scopesToCollectForAggregatedProjects;
private final Collection<String> scopesToResolveForAggregatedProjects;
private volatile Collection<?> lastDependencyArtifacts = Collections.emptyList();
private volatile int lastDependencyArtifactCount = -1;
public DependencyContext(
MavenProject project, Collection<String> scopesToCollect, Collection<String> scopesToResolve) {
this.project = project;
scopesToCollectForCurrentProject = scopesToCollect;
scopesToResolveForCurrentProject = scopesToResolve;
scopesToCollectForAggregatedProjects = Collections.synchronizedSet(new TreeSet<>());
scopesToResolveForAggregatedProjects = Collections.synchronizedSet(new TreeSet<>());
}
public MavenProject getProject() {
return project;
}
public Collection<String> getScopesToCollectForCurrentProject() {
return scopesToCollectForCurrentProject;
}
public Collection<String> getScopesToResolveForCurrentProject() {
return scopesToResolveForCurrentProject;
}
public Collection<String> getScopesToCollectForAggregatedProjects() {
return scopesToCollectForAggregatedProjects;
}
public Collection<String> getScopesToResolveForAggregatedProjects() {
return scopesToResolveForAggregatedProjects;
}
public boolean isResolutionRequiredForCurrentProject() {<FILL_FUNCTION_BODY>}
public boolean isResolutionRequiredForAggregatedProjects(
Collection<String> scopesToCollect, Collection<String> scopesToResolve) {
return scopesToCollectForAggregatedProjects.addAll(scopesToCollect)
|| scopesToResolveForAggregatedProjects.addAll(scopesToResolve);
}
public void synchronizeWithProjectState() {
lastDependencyArtifacts = project.getDependencyArtifacts();
lastDependencyArtifactCount = (lastDependencyArtifacts != null) ? lastDependencyArtifacts.size() : 0;
}
}
|
return lastDependencyArtifacts != project.getDependencyArtifacts()
|| (lastDependencyArtifacts != null && lastDependencyArtifactCount != lastDependencyArtifacts.size());
| 590
| 49
| 639
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/ExecutionPlanItem.java
|
ExecutionPlanItem
|
createExecutionPlanItems
|
class ExecutionPlanItem {
private final MojoExecution mojoExecution;
public ExecutionPlanItem(MojoExecution mojoExecution) {
this.mojoExecution = mojoExecution;
}
public static List<ExecutionPlanItem> createExecutionPlanItems(
MavenProject mavenProject, List<MojoExecution> executions) {<FILL_FUNCTION_BODY>}
public MojoExecution getMojoExecution() {
return mojoExecution;
}
public String getLifecyclePhase() {
return mojoExecution.getLifecyclePhase();
}
public Plugin getPlugin() {
final MojoDescriptor mojoDescriptor = getMojoExecution().getMojoDescriptor();
return mojoDescriptor.getPluginDescriptor().getPlugin();
}
@Override
public String toString() {
return "ExecutionPlanItem{" + ", mojoExecution=" + mojoExecution + '}' + super.toString();
}
}
|
BuilderCommon.attachToThread(mavenProject);
List<ExecutionPlanItem> result = new ArrayList<>();
for (MojoExecution mojoExecution : executions) {
result.add(new ExecutionPlanItem(mojoExecution));
}
return result;
| 244
| 70
| 314
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDebugLogger.java
|
LifecycleDebugLogger
|
debugProjectPlan
|
class LifecycleDebugLogger {
private final Logger logger = LoggerFactory.getLogger(getClass());
public void debug(String s) {
logger.debug(s);
}
public void info(String s) {
logger.info(s);
}
public void debugReactorPlan(ProjectBuildList projectBuilds) {
if (!logger.isDebugEnabled()) {
return;
}
logger.debug("=== REACTOR BUILD PLAN ================================================");
for (Iterator<ProjectSegment> it = projectBuilds.iterator(); it.hasNext(); ) {
ProjectSegment projectBuild = it.next();
logger.debug("Project: " + projectBuild.getProject().getId());
logger.debug("Tasks: " + projectBuild.getTaskSegment().getTasks());
logger.debug("Style: " + (projectBuild.getTaskSegment().isAggregating() ? "Aggregating" : "Regular"));
if (it.hasNext()) {
logger.debug("-----------------------------------------------------------------------");
}
}
logger.debug("=======================================================================");
}
public void debugProjectPlan(MavenProject currentProject, MavenExecutionPlan executionPlan) {<FILL_FUNCTION_BODY>}
private void debugMojoExecution(MojoExecution mojoExecution) {
String mojoExecId =
mojoExecution.getGroupId() + ':' + mojoExecution.getArtifactId() + ':' + mojoExecution.getVersion()
+ ':' + mojoExecution.getGoal() + " (" + mojoExecution.getExecutionId() + ')';
Map<String, List<MojoExecution>> forkedExecutions = mojoExecution.getForkedExecutions();
if (!forkedExecutions.isEmpty()) {
for (Map.Entry<String, List<MojoExecution>> fork : forkedExecutions.entrySet()) {
logger.debug("--- init fork of " + fork.getKey() + " for " + mojoExecId + " ---");
debugDependencyRequirements(fork.getValue());
for (MojoExecution forkedExecution : fork.getValue()) {
debugMojoExecution(forkedExecution);
}
logger.debug("--- exit fork of " + fork.getKey() + " for " + mojoExecId + " ---");
}
}
logger.debug("-----------------------------------------------------------------------");
logger.debug("Goal: " + mojoExecId);
logger.debug(
"Style: " + (mojoExecution.getMojoDescriptor().isAggregator() ? "Aggregating" : "Regular"));
logger.debug("Configuration: " + mojoExecution.getConfiguration());
}
private void debugDependencyRequirements(List<MojoExecution> mojoExecutions) {
Set<String> scopesToCollect = new TreeSet<>();
Set<String> scopesToResolve = new TreeSet<>();
for (MojoExecution mojoExecution : mojoExecutions) {
MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
String scopeToCollect = mojoDescriptor.getDependencyCollectionRequired();
if (scopeToCollect != null && !scopeToCollect.isEmpty()) {
scopesToCollect.add(scopeToCollect);
}
String scopeToResolve = mojoDescriptor.getDependencyResolutionRequired();
if (scopeToResolve != null && !scopeToResolve.isEmpty()) {
scopesToResolve.add(scopeToResolve);
}
}
logger.debug("Dependencies (collect): " + scopesToCollect);
logger.debug("Dependencies (resolve): " + scopesToResolve);
}
}
|
if (!logger.isDebugEnabled()) {
return;
}
logger.debug("=== PROJECT BUILD PLAN ================================================");
logger.debug("Project: " + BuilderCommon.getKey(currentProject));
debugDependencyRequirements(executionPlan.getMojoExecutions());
logger.debug("Repositories (dependencies): " + currentProject.getRemoteProjectRepositories());
logger.debug("Repositories (plugins) : " + currentProject.getRemotePluginRepositories());
for (ExecutionPlanItem mojoExecution : executionPlan) {
debugMojoExecution(mojoExecution.getMojoExecution());
}
logger.debug("=======================================================================");
| 915
| 180
| 1,095
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java
|
LifecycleModuleBuilder
|
buildProject
|
class LifecycleModuleBuilder {
private final MojoExecutor mojoExecutor;
private final BuilderCommon builderCommon;
private final ExecutionEventCatapult eventCatapult;
private final ProjectExecutionListener projectExecutionListener;
private final ConsumerPomArtifactTransformer consumerPomArtifactTransformer;
@Inject
public LifecycleModuleBuilder(
MojoExecutor mojoExecutor,
BuilderCommon builderCommon,
ExecutionEventCatapult eventCatapult,
List<ProjectExecutionListener> listeners,
ConsumerPomArtifactTransformer consumerPomArtifactTransformer) {
this.mojoExecutor = mojoExecutor;
this.builderCommon = builderCommon;
this.eventCatapult = eventCatapult;
this.projectExecutionListener = new CompoundProjectExecutionListener(listeners);
this.consumerPomArtifactTransformer = consumerPomArtifactTransformer;
}
public void buildProject(
MavenSession session, ReactorContext reactorContext, MavenProject currentProject, TaskSegment taskSegment) {
buildProject(session, session, reactorContext, currentProject, taskSegment);
}
public void buildProject(
MavenSession session,
MavenSession rootSession,
ReactorContext reactorContext,
MavenProject currentProject,
TaskSegment taskSegment) {<FILL_FUNCTION_BODY>}
}
|
session.setCurrentProject(currentProject);
long buildStartTime = System.currentTimeMillis();
try {
if (reactorContext.getReactorBuildStatus().isHaltedOrBlacklisted(currentProject)) {
eventCatapult.fire(ExecutionEvent.Type.ProjectSkipped, session, null);
return;
}
consumerPomArtifactTransformer.injectTransformedArtifacts(session.getRepositorySession(), currentProject);
BuilderCommon.attachToThread(currentProject);
projectExecutionListener.beforeProjectExecution(new ProjectExecutionEvent(session, currentProject));
eventCatapult.fire(ExecutionEvent.Type.ProjectStarted, session, null);
MavenExecutionPlan executionPlan =
builderCommon.resolveBuildPlan(session, currentProject, taskSegment, new HashSet<>());
List<MojoExecution> mojoExecutions = executionPlan.getMojoExecutions();
projectExecutionListener.beforeProjectLifecycleExecution(
new ProjectExecutionEvent(session, currentProject, mojoExecutions));
mojoExecutor.execute(session, mojoExecutions);
long buildEndTime = System.currentTimeMillis();
projectExecutionListener.afterProjectExecutionSuccess(
new ProjectExecutionEvent(session, currentProject, mojoExecutions));
reactorContext.getResult().addBuildSummary(new BuildSuccess(currentProject, buildEndTime - buildStartTime));
eventCatapult.fire(ExecutionEvent.Type.ProjectSucceeded, session, null);
} catch (Throwable t) {
builderCommon.handleBuildError(reactorContext, rootSession, session, currentProject, t, buildStartTime);
projectExecutionListener.afterProjectExecutionFailure(
new ProjectExecutionEvent(session, currentProject, t));
// rethrow original errors and runtime exceptions
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
}
if (t instanceof Error) {
throw (Error) t;
}
} finally {
session.setCurrentProject(null);
Thread.currentThread().setContextClassLoader(reactorContext.getOriginalContextClassLoader());
}
| 346
| 532
| 878
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecyclePluginResolver.java
|
LifecyclePluginResolver
|
resolveMissingPluginVersions
|
class LifecyclePluginResolver {
private final PluginVersionResolver pluginVersionResolver;
@Inject
public LifecyclePluginResolver(PluginVersionResolver pluginVersionResolver) {
this.pluginVersionResolver = pluginVersionResolver;
}
public void resolveMissingPluginVersions(MavenProject project, MavenSession session)
throws PluginVersionResolutionException {<FILL_FUNCTION_BODY>}
}
|
Map<String, String> versions = new HashMap<>(64);
for (Plugin plugin : project.getBuildPlugins()) {
if (plugin.getVersion() == null) {
PluginVersionRequest request = new DefaultPluginVersionRequest(
plugin, session.getRepositorySession(), project.getRemotePluginRepositories());
plugin.setVersion(pluginVersionResolver.resolve(request).getVersion());
}
versions.put(plugin.getKey(), plugin.getVersion());
}
PluginManagement pluginManagement = project.getPluginManagement();
if (pluginManagement != null) {
for (Plugin plugin : pluginManagement.getPlugins()) {
if (plugin.getVersion() == null) {
plugin.setVersion(versions.get(plugin.getKey()));
if (plugin.getVersion() == null) {
PluginVersionRequest request = new DefaultPluginVersionRequest(
plugin, session.getRepositorySession(), project.getRemotePluginRepositories());
plugin.setVersion(pluginVersionResolver.resolve(request).getVersion());
}
}
}
}
| 105
| 273
| 378
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java
|
ProjectLock
|
getProjectLock
|
class ProjectLock implements AutoCloseable {
final Lock acquiredAggregatorLock;
final OwnerReentrantLock acquiredProjectLock;
ProjectLock(MavenSession session, MojoDescriptor mojoDescriptor) {
mojos.put(Thread.currentThread(), mojoDescriptor);
if (session.getRequest().getDegreeOfConcurrency() > 1) {
boolean aggregator = mojoDescriptor.isAggregator();
acquiredAggregatorLock = aggregator ? aggregatorLock.writeLock() : aggregatorLock.readLock();
acquiredProjectLock = getProjectLock(session);
if (!acquiredAggregatorLock.tryLock()) {
Thread owner = aggregatorLock.getOwner();
MojoDescriptor ownerMojo = owner != null ? mojos.get(owner) : null;
String str = ownerMojo != null ? " The " + ownerMojo.getId() : "An";
String msg = str + " aggregator mojo is already being executed "
+ "in this parallel build, those kind of mojos require exclusive access to "
+ "reactor to prevent race conditions. This mojo execution will be blocked "
+ "until the aggregator mojo is done.";
warn(msg);
acquiredAggregatorLock.lock();
}
if (!acquiredProjectLock.tryLock()) {
Thread owner = acquiredProjectLock.getOwner();
MojoDescriptor ownerMojo = owner != null ? mojos.get(owner) : null;
String str = ownerMojo != null ? " The " + ownerMojo.getId() : "A";
String msg = str + " mojo is already being executed "
+ "on the project " + session.getCurrentProject().getGroupId()
+ ":" + session.getCurrentProject().getArtifactId() + ". "
+ "This mojo execution will be blocked "
+ "until the mojo is done.";
warn(msg);
acquiredProjectLock.lock();
}
} else {
acquiredAggregatorLock = null;
acquiredProjectLock = null;
}
}
@Override
public void close() {
// release the lock in the reverse order of the acquisition
if (acquiredProjectLock != null) {
acquiredProjectLock.unlock();
}
if (acquiredAggregatorLock != null) {
acquiredAggregatorLock.unlock();
}
mojos.remove(Thread.currentThread());
}
private OwnerReentrantLock getProjectLock(MavenSession session) {<FILL_FUNCTION_BODY>}
}
|
SessionData data = session.getSession().getData();
Map<MavenProject, OwnerReentrantLock> locks = data.computeIfAbsent(PROJECT_LOCKS, ConcurrentHashMap::new);
return locks.computeIfAbsent(session.getCurrentProject(), p -> new OwnerReentrantLock());
| 624
| 80
| 704
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/PhaseRecorder.java
|
PhaseRecorder
|
observeExecution
|
class PhaseRecorder {
private String lastLifecyclePhase;
private final MavenProject project;
public PhaseRecorder(MavenProject project) {
this.project = project;
}
public void observeExecution(MojoExecution mojoExecution) {<FILL_FUNCTION_BODY>}
public boolean isDifferentPhase(MojoExecution nextMojoExecution) {
String lifecyclePhase = nextMojoExecution.getLifecyclePhase();
if (lifecyclePhase == null) {
return lastLifecyclePhase != null;
}
return !lifecyclePhase.equals(lastLifecyclePhase);
}
}
|
String lifecyclePhase = mojoExecution.getLifecyclePhase();
if (lifecyclePhase != null) {
if (lastLifecyclePhase == null) {
lastLifecyclePhase = lifecyclePhase;
} else if (!lifecyclePhase.equals(lastLifecyclePhase)) {
project.addLifecyclePhase(lastLifecyclePhase);
lastLifecyclePhase = lifecyclePhase;
}
}
if (lastLifecyclePhase != null) {
project.addLifecyclePhase(lastLifecyclePhase);
}
| 182
| 177
| 359
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/ProjectBuildList.java
|
ProjectBuildList
|
getReactorProjectKeys
|
class ProjectBuildList implements Iterable<ProjectSegment> {
private final List<ProjectSegment> items;
public ProjectBuildList(List<ProjectSegment> items) {
this.items = Collections.unmodifiableList(items);
}
// TODO Optimize; or maybe just rewrite the whole way aggregating mojos are being run.
/**
* Returns aProjectBuildList that contains only items for the specified taskSegment
* @param taskSegment the requested task segment
* @return a project build list for the supplied task segment
*/
public ProjectBuildList getByTaskSegment(TaskSegment taskSegment) {
return new ProjectBuildList(
items.stream().filter(pb -> taskSegment == pb.getTaskSegment()).collect(Collectors.toList()));
}
public Map<MavenProject, ProjectSegment> selectSegment(TaskSegment taskSegment) {
return items.stream()
.filter(pb -> taskSegment == pb.getTaskSegment())
.collect(Collectors.toMap(ProjectSegment::getProject, Function.identity()));
}
/**
* Finds the first ProjectSegment matching the supplied project
* @param mavenProject the requested project
* @return The projectSegment or null.
*/
public ProjectSegment findByMavenProject(MavenProject mavenProject) {
return items.stream()
.filter(pb -> mavenProject.equals(pb.getProject()))
.findFirst()
.orElse(null);
}
@Override
public Iterator<ProjectSegment> iterator() {
return items.iterator();
}
public void closeAll() {
for (ProjectSegment item : items) {
MavenSession sessionForThisModule = item.getSession();
sessionForThisModule.setCurrentProject(null);
}
}
public int size() {
return items.size();
}
public ProjectSegment get(int index) {
return items.get(index);
}
public Set<String> getReactorProjectKeys() {<FILL_FUNCTION_BODY>}
public boolean isEmpty() {
return items.isEmpty();
}
/**
* @return a set of all the projects managed by the build
*/
public Set<MavenProject> getProjects() {
return items.stream().map(ProjectSegment::getProject).collect(Collectors.toSet());
}
}
|
Set<String> projectKeys = new HashSet<>(items.size() * 2);
for (ProjectSegment projectBuild : items) {
MavenProject project = projectBuild.getProject();
String key = ArtifactUtils.key(project.getGroupId(), project.getArtifactId(), project.getVersion());
projectKeys.add(key);
}
return projectKeys;
| 597
| 97
| 694
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/ReactorBuildStatus.java
|
ReactorBuildStatus
|
blackList
|
class ReactorBuildStatus {
private final ProjectDependencyGraph projectDependencyGraph;
private final Collection<String> blackListedProjects = Collections.synchronizedSet(new HashSet<>());
private volatile boolean halted = false;
public ReactorBuildStatus(ProjectDependencyGraph projectDependencyGraph) {
this.projectDependencyGraph = projectDependencyGraph;
}
public boolean isBlackListed(MavenProject project) {
return blackListedProjects.contains(BuilderCommon.getKey(project));
}
public void blackList(MavenProject project) {<FILL_FUNCTION_BODY>}
public void halt() {
halted = true;
}
public boolean isHalted() {
return halted;
}
public boolean isHaltedOrBlacklisted(MavenProject mavenProject) {
return isBlackListed(mavenProject) || isHalted();
}
}
|
if (blackListedProjects.add(BuilderCommon.getKey(project)) && projectDependencyGraph != null) {
for (MavenProject downstreamProject : projectDependencyGraph.getDownstreamProjects(project, true)) {
blackListedProjects.add(BuilderCommon.getKey(downstreamProject));
}
}
| 234
| 84
| 318
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/Task.java
|
Task
|
equals
|
class Task {
private final String value;
public Task(String value) {
this.value = Objects.requireNonNull(value, "value");
}
public String getValue() {
return value;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(getClass(), value);
}
@Override
public String toString() {
return value;
}
}
|
if (this == o) {
return true;
}
if (!(o instanceof Task)) {
return false;
}
Task task = (Task) o;
return Objects.equals(getClass(), task.getClass()) && Objects.equals(value, task.value);
| 139
| 76
| 215
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/builder/BuilderCommon.java
|
BuilderCommon
|
resolveBuildPlan
|
class BuilderCommon {
private final Logger logger;
private final LifecycleDebugLogger lifecycleDebugLogger;
private final LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator;
private final ExecutionEventCatapult eventCatapult;
@Inject
public BuilderCommon(
LifecycleDebugLogger lifecycleDebugLogger,
LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator,
ExecutionEventCatapult eventCatapult) {
this.logger = LoggerFactory.getLogger(getClass());
this.lifecycleDebugLogger = lifecycleDebugLogger;
this.lifeCycleExecutionPlanCalculator = lifeCycleExecutionPlanCalculator;
this.eventCatapult = eventCatapult;
}
/**
* Ctor needed for UT.
*/
BuilderCommon(
LifecycleDebugLogger lifecycleDebugLogger,
LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator,
ExecutionEventCatapult eventCatapult,
Logger logger) {
this.lifecycleDebugLogger = lifecycleDebugLogger;
this.lifeCycleExecutionPlanCalculator = lifeCycleExecutionPlanCalculator;
this.eventCatapult = eventCatapult;
this.logger = logger;
}
public MavenExecutionPlan resolveBuildPlan(
MavenSession session, MavenProject project, TaskSegment taskSegment, Set<Artifact> projectArtifacts)
throws PluginNotFoundException, PluginResolutionException, LifecyclePhaseNotFoundException,
PluginDescriptorParsingException, MojoNotFoundException, InvalidPluginDescriptorException,
NoPluginFoundForPrefixException, LifecycleNotFoundException, PluginVersionResolutionException,
LifecycleExecutionException {<FILL_FUNCTION_BODY>}
public void handleBuildError(
final ReactorContext buildContext,
final MavenSession rootSession,
final MavenSession currentSession,
final MavenProject mavenProject,
Throwable t,
final long buildStartTime) {
// record the error and mark the project as failed
long buildEndTime = System.currentTimeMillis();
buildContext.getResult().addException(t);
buildContext.getResult().addBuildSummary(new BuildFailure(mavenProject, buildEndTime - buildStartTime, t));
// notify listeners about "soft" project build failures only
if (t instanceof Exception && !(t instanceof RuntimeException)) {
eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, currentSession, null, (Exception) t);
}
// reactor failure modes
if (t instanceof RuntimeException || !(t instanceof Exception)) {
// fail fast on RuntimeExceptions, Errors and "other" Throwables
// assume these are system errors and further build is meaningless
buildContext.getReactorBuildStatus().halt();
} else if (MavenExecutionRequest.REACTOR_FAIL_NEVER.equals(rootSession.getReactorFailureBehavior())) {
// continue the build
} else if (MavenExecutionRequest.REACTOR_FAIL_AT_END.equals(rootSession.getReactorFailureBehavior())) {
// continue the build but ban all projects that depend on the failed one
buildContext.getReactorBuildStatus().blackList(mavenProject);
} else if (MavenExecutionRequest.REACTOR_FAIL_FAST.equals(rootSession.getReactorFailureBehavior())) {
buildContext.getReactorBuildStatus().halt();
} else {
logger.error("invalid reactor failure behavior " + rootSession.getReactorFailureBehavior());
buildContext.getReactorBuildStatus().halt();
}
}
public static void attachToThread(MavenProject currentProject) {
ClassRealm projectRealm = currentProject.getClassRealm();
if (projectRealm != null) {
Thread.currentThread().setContextClassLoader(projectRealm);
}
}
// TODO I'm really wondering where this method belongs; smells like it should be on MavenProject, but for some
// reason it isn't ? This localization is kind-of a code smell.
public static String getKey(MavenProject project) {
return project.getGroupId() + ':' + project.getArtifactId() + ':' + project.getVersion();
}
}
|
MavenExecutionPlan executionPlan =
lifeCycleExecutionPlanCalculator.calculateExecutionPlan(session, project, taskSegment.getTasks());
lifecycleDebugLogger.debugProjectPlan(project, executionPlan);
if (session.getRequest().getDegreeOfConcurrency() > 1
&& session.getProjects().size() > 1) {
final Set<Plugin> unsafePlugins = executionPlan.getNonThreadSafePlugins();
if (!unsafePlugins.isEmpty()) {
for (String s : MultilineMessageHelper.format(
"Your build is requesting parallel execution, but this project contains the following "
+ "plugin(s) that have goals not marked as thread-safe to support parallel execution.",
"While this /may/ work fine, please look for plugin updates and/or "
+ "request plugins be made thread-safe.",
"If reporting an issue, report it against the plugin in question, not against Apache Maven.")) {
logger.warn(s);
}
if (logger.isDebugEnabled()) {
final Set<MojoDescriptor> unsafeGoals = executionPlan.getNonThreadSafeMojos();
logger.warn("The following goals are not marked as thread-safe in " + project.getName() + ":");
for (MojoDescriptor unsafeGoal : unsafeGoals) {
logger.warn(" " + unsafeGoal.getId());
}
} else {
logger.warn("The following plugins are not marked as thread-safe in " + project.getName() + ":");
for (Plugin unsafePlugin : unsafePlugins) {
logger.warn(" " + unsafePlugin.getId());
}
logger.warn("");
logger.warn("Enable verbose output (-X) to see precisely which goals are not marked as"
+ " thread-safe.");
}
logger.warn(MultilineMessageHelper.separatorLine());
}
}
final String defaulModelId = DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID;
List<String> unversionedPlugins = executionPlan.getMojoExecutions().stream()
.map(MojoExecution::getPlugin)
.filter(p -> p.getLocation("version") != null
&& p.getLocation("version").getSource() != null
&& defaulModelId.equals(
p.getLocation("version").getSource().getModelId()))
.distinct()
.map(Plugin::getArtifactId) // managed by us, groupId is always o.a.m.plugins
.collect(Collectors.toList());
if (!unversionedPlugins.isEmpty()) {
logger.warn("Version not locked for default bindings plugins " + unversionedPlugins
+ ", you should define versions in pluginManagement section of your " + "pom.xml or parent");
}
return executionPlan;
| 1,085
| 724
| 1,809
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/builder/multithreaded/ConcurrencyDependencyGraph.java
|
ConcurrencyDependencyGraph
|
getSchedulableNewProcesses
|
class ConcurrencyDependencyGraph {
private final ProjectBuildList projectBuilds;
private final ProjectDependencyGraph projectDependencyGraph;
private final Set<MavenProject> finishedProjects = new HashSet<>();
public ConcurrencyDependencyGraph(ProjectBuildList projectBuilds, ProjectDependencyGraph projectDependencyGraph) {
this.projectDependencyGraph = projectDependencyGraph;
this.projectBuilds = projectBuilds;
}
public int getNumberOfBuilds() {
return projectBuilds.size();
}
/**
* Gets all the builds that have no reactor-dependencies
*
* @return A set of all the initial builds
*/
public List<MavenProject> getRootSchedulableBuilds() {
Set<MavenProject> result = new LinkedHashSet<>();
for (ProjectSegment projectBuild : projectBuilds) {
if (projectDependencyGraph
.getUpstreamProjects(projectBuild.getProject(), false)
.isEmpty()) {
result.add(projectBuild.getProject());
}
}
if (result.isEmpty() && projectBuilds.size() > 0) {
// Must return at least one project
result.add(projectBuilds.get(0).getProject());
}
return new ArrayList<>(result);
}
/**
* Marks the provided project as finished. Returns a list of
*
* @param mavenProject The project
* @return The list of builds that are eligible for starting now that the provided project is done
*/
public List<MavenProject> markAsFinished(MavenProject mavenProject) {
finishedProjects.add(mavenProject);
return getSchedulableNewProcesses(mavenProject);
}
private List<MavenProject> getSchedulableNewProcesses(MavenProject finishedProject) {<FILL_FUNCTION_BODY>}
/**
* @return set of projects that have yet to be processed successfully by the build.
*/
public Set<MavenProject> getUnfinishedProjects() {
Set<MavenProject> unfinished = new HashSet<>(projectBuilds.getProjects());
unfinished.removeAll(finishedProjects);
return unfinished;
}
/**
* @return set of projects that have been successfully processed by the build.
*/
protected Set<MavenProject> getFinishedProjects() {
return finishedProjects;
}
protected ProjectBuildList getProjectBuilds() {
return projectBuilds;
}
/**
* For the given {@link MavenProject} {@code p}, return all of {@code p}'s dependencies.
*
* @param p
* @return List of prerequisite projects
*/
protected List<MavenProject> getDependencies(MavenProject p) {
return projectDependencyGraph.getUpstreamProjects(p, false);
}
/**
* For the given {@link MavenProject} {@code p} return {@code p}'s uncompleted dependencies.
*
* @param p
* @return List of uncompleted prerequisite projects
*/
public List<MavenProject> getActiveDependencies(MavenProject p) {
List<MavenProject> activeDependencies = projectDependencyGraph.getUpstreamProjects(p, false);
activeDependencies.removeAll(finishedProjects);
return activeDependencies;
}
}
|
List<MavenProject> result = new ArrayList<>();
// schedule dependent projects, if all of their requirements are met
for (MavenProject dependentProject : projectDependencyGraph.getDownstreamProjects(finishedProject, false)) {
final List<MavenProject> upstreamProjects =
projectDependencyGraph.getUpstreamProjects(dependentProject, false);
if (finishedProjects.containsAll(upstreamProjects)) {
result.add(dependentProject);
}
}
return result;
| 844
| 125
| 969
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/builder/multithreaded/MultiThreadedBuilder.java
|
MultiThreadedBuilder
|
build
|
class MultiThreadedBuilder implements Builder {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final LifecycleModuleBuilder lifecycleModuleBuilder;
@Inject
public MultiThreadedBuilder(LifecycleModuleBuilder lifecycleModuleBuilder) {
this.lifecycleModuleBuilder = lifecycleModuleBuilder;
}
@Override
public void build(
MavenSession session,
ReactorContext reactorContext,
ProjectBuildList projectBuilds,
List<TaskSegment> taskSegments,
ReactorBuildStatus reactorBuildStatus)
throws ExecutionException, InterruptedException {<FILL_FUNCTION_BODY>}
private void multiThreadedProjectTaskSegmentBuild(
ConcurrencyDependencyGraph analyzer,
ReactorContext reactorContext,
MavenSession rootSession,
CompletionService<ProjectSegment> service,
TaskSegment taskSegment,
Map<MavenProject, ProjectSegment> projectBuildList,
ThreadOutputMuxer muxer) {
// gather artifactIds which are not unique so that the respective thread names can be extended with the groupId
Set<String> duplicateArtifactIds = projectBuildList.keySet().stream()
.map(MavenProject::getArtifactId)
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
.entrySet()
.stream()
.filter(p -> p.getValue() > 1)
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
// schedule independent projects
for (MavenProject mavenProject : analyzer.getRootSchedulableBuilds()) {
ProjectSegment projectSegment = projectBuildList.get(mavenProject);
logger.debug("Scheduling: {}", projectSegment.getProject());
Callable<ProjectSegment> cb = createBuildCallable(
rootSession, projectSegment, reactorContext, taskSegment, muxer, duplicateArtifactIds);
service.submit(cb);
}
// for each finished project
for (int i = 0; i < analyzer.getNumberOfBuilds(); i++) {
try {
ProjectSegment projectBuild = service.take().get();
if (reactorContext.getReactorBuildStatus().isHalted()) {
break;
}
// MNG-6170: Only schedule other modules from reactor if we have more modules to build than one.
if (analyzer.getNumberOfBuilds() > 1) {
final List<MavenProject> newItemsThatCanBeBuilt =
analyzer.markAsFinished(projectBuild.getProject());
for (MavenProject mavenProject : newItemsThatCanBeBuilt) {
ProjectSegment scheduledDependent = projectBuildList.get(mavenProject);
logger.debug("Scheduling: {}", scheduledDependent);
Callable<ProjectSegment> cb = createBuildCallable(
rootSession,
scheduledDependent,
reactorContext,
taskSegment,
muxer,
duplicateArtifactIds);
service.submit(cb);
}
}
} catch (InterruptedException e) {
rootSession.getResult().addException(e);
break;
} catch (ExecutionException e) {
// TODO MNG-5766 changes likely made this redundant
rootSession.getResult().addException(e);
break;
}
}
}
private Callable<ProjectSegment> createBuildCallable(
final MavenSession rootSession,
final ProjectSegment projectBuild,
final ReactorContext reactorContext,
final TaskSegment taskSegment,
final ThreadOutputMuxer muxer,
final Set<String> duplicateArtifactIds) {
return () -> {
final Thread currentThread = Thread.currentThread();
final String originalThreadName = currentThread.getName();
final MavenProject project = projectBuild.getProject();
final String threadNameSuffix = duplicateArtifactIds.contains(project.getArtifactId())
? project.getGroupId() + ":" + project.getArtifactId()
: project.getArtifactId();
currentThread.setName("mvn-builder-" + threadNameSuffix);
try {
// muxer.associateThreadWithProjectSegment( projectBuild );
lifecycleModuleBuilder.buildProject(
projectBuild.getSession(), rootSession, reactorContext, project, taskSegment);
// muxer.setThisModuleComplete( projectBuild );
return projectBuild;
} finally {
currentThread.setName(originalThreadName);
}
};
}
}
|
int nThreads = Math.min(
session.getRequest().getDegreeOfConcurrency(),
session.getProjects().size());
boolean parallel = nThreads > 1;
// Propagate the parallel flag to the root session and all of the cloned sessions in each project segment
session.setParallel(parallel);
for (ProjectSegment segment : projectBuilds) {
segment.getSession().setParallel(parallel);
}
ExecutorService executor = Executors.newFixedThreadPool(nThreads, new BuildThreadFactory());
CompletionService<ProjectSegment> service = new ExecutorCompletionService<>(executor);
// Currently disabled
ThreadOutputMuxer muxer = null; // new ThreadOutputMuxer( analyzer.getProjectBuilds(), System.out );
for (TaskSegment taskSegment : taskSegments) {
ProjectBuildList segmentProjectBuilds = projectBuilds.getByTaskSegment(taskSegment);
Map<MavenProject, ProjectSegment> projectBuildMap = projectBuilds.selectSegment(taskSegment);
try {
ConcurrencyDependencyGraph analyzer =
new ConcurrencyDependencyGraph(segmentProjectBuilds, session.getProjectDependencyGraph());
multiThreadedProjectTaskSegmentBuild(
analyzer, reactorContext, session, service, taskSegment, projectBuildMap, muxer);
if (reactorContext.getReactorBuildStatus().isHalted()) {
break;
}
} catch (Exception e) {
session.getResult().addException(e);
break;
}
}
executor.shutdown();
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
| 1,148
| 421
| 1,569
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/builder/multithreaded/ThreadOutputMuxer.java
|
ThreadBoundPrintStream
|
println
|
class ThreadBoundPrintStream extends PrintStream {
ThreadBoundPrintStream(PrintStream systemOutStream) {
super(systemOutStream);
}
private PrintStream getOutputStreamForCurrentThread() {
return getThreadBoundPrintStream();
}
@Override
public void println() {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println();
currentStream.notifyAll();
}
}
@Override
public void print(char c) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(c);
currentStream.notifyAll();
}
}
@Override
public void println(char x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println(x);
currentStream.notifyAll();
}
}
@Override
public void print(double d) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(d);
currentStream.notifyAll();
}
}
@Override
public void println(double x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println(x);
currentStream.notifyAll();
}
}
@Override
public void print(float f) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(f);
currentStream.notifyAll();
}
}
@Override
public void println(float x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println(x);
currentStream.notifyAll();
}
}
@Override
public void print(int i) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(i);
currentStream.notifyAll();
}
}
@Override
public void println(int x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println(x);
currentStream.notifyAll();
}
}
@Override
public void print(long l) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(l);
currentStream.notifyAll();
}
}
@Override
public void println(long x) {<FILL_FUNCTION_BODY>}
@Override
public void print(boolean b) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(b);
currentStream.notifyAll();
}
}
@Override
public void println(boolean x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(x);
currentStream.notifyAll();
}
}
@Override
public void print(char s[]) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(s);
currentStream.notifyAll();
}
}
@Override
public void println(char x[]) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(x);
currentStream.notifyAll();
}
}
@Override
public void print(Object obj) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(obj);
currentStream.notifyAll();
}
}
@Override
public void println(Object x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println(x);
currentStream.notifyAll();
}
}
@Override
public void print(String s) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(s);
currentStream.notifyAll();
}
}
@Override
public void println(String x) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.println(x);
currentStream.notifyAll();
}
}
@Override
public void write(byte b[], int off, int len) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.write(b, off, len);
currentStream.notifyAll();
}
}
@Override
public void close() {
getOutputStreamForCurrentThread().close();
}
@Override
public void flush() {
getOutputStreamForCurrentThread().flush();
}
@Override
public void write(int b) {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.write(b);
currentStream.notifyAll();
}
}
@Override
public void write(byte b[]) throws IOException {
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.write(b);
currentStream.notifyAll();
}
}
}
|
final PrintStream currentStream = getOutputStreamForCurrentThread();
synchronized (currentStream) {
currentStream.print(x);
currentStream.notifyAll();
}
| 1,443
| 46
| 1,489
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/internal/builder/singlethreaded/SingleThreadedBuilder.java
|
SingleThreadedBuilder
|
build
|
class SingleThreadedBuilder implements Builder {
private final LifecycleModuleBuilder lifecycleModuleBuilder;
@Inject
public SingleThreadedBuilder(LifecycleModuleBuilder lifecycleModuleBuilder) {
this.lifecycleModuleBuilder = lifecycleModuleBuilder;
}
public void build(
MavenSession session,
ReactorContext reactorContext,
ProjectBuildList projectBuilds,
List<TaskSegment> taskSegments,
ReactorBuildStatus reactorBuildStatus) {<FILL_FUNCTION_BODY>}
}
|
for (TaskSegment taskSegment : taskSegments) {
for (ProjectSegment projectBuild : projectBuilds.getByTaskSegment(taskSegment)) {
try {
lifecycleModuleBuilder.buildProject(
session, reactorContext, projectBuild.getProject(), taskSegment);
if (reactorBuildStatus.isHalted()) {
break;
}
} catch (Exception e) {
break; // Why are we just ignoring this exception? Are exceptions are being used for flow control
}
}
}
| 141
| 133
| 274
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/mapping/DefaultLifecycleMapping.java
|
DefaultLifecycleMapping
|
initLifecycleMap
|
class DefaultLifecycleMapping implements LifecycleMapping {
private List<Lifecycle> lifecycles;
private Map<String, Lifecycle> lifecycleMap;
/** @deprecated use lifecycles instead */
@Deprecated
private Map<String, LifecyclePhase> phases;
/**
* Default ctor for plexus compatibility: lifecycles are most commonly defined in Plexus XML, that does field
* injection. Still, for Plexus to be able to instantiate this class, default ctor is needed.
*
* @deprecated Should not be used in Java code.
*/
@Deprecated
public DefaultLifecycleMapping() {}
/**
* Ctor to be used in Java code/providers.
*/
public DefaultLifecycleMapping(final List<Lifecycle> lifecycles) {
this.lifecycleMap =
Collections.unmodifiableMap(lifecycles.stream().collect(toMap(Lifecycle::getId, identity())));
}
/**
* Plexus: Populates the lifecycle map from the injected list of lifecycle mappings (if not already done).
*/
private synchronized void initLifecycleMap() {<FILL_FUNCTION_BODY>}
@Override
public Map<String, Lifecycle> getLifecycles() {
initLifecycleMap();
return lifecycleMap;
}
@Deprecated
@Override
public List<String> getOptionalMojos(String lifecycle) {
return null;
}
private Map<String, LifecyclePhase> getLifecyclePhases(String lifecycle) {
initLifecycleMap();
Lifecycle lifecycleMapping = lifecycleMap.get(lifecycle);
if (lifecycleMapping != null) {
return lifecycleMapping.getLifecyclePhases();
} else if ("default".equals(lifecycle)) {
return phases;
} else {
return null;
}
}
@Deprecated
@Override
public Map<String, String> getPhases(String lifecycle) {
return LifecyclePhase.toLegacyMap(getLifecyclePhases(lifecycle));
}
}
|
if (lifecycleMap == null) {
lifecycleMap = new HashMap<>();
if (lifecycles != null) {
for (Lifecycle lifecycle : lifecycles) {
lifecycleMap.put(lifecycle.getId(), lifecycle);
}
} else {
/*
* NOTE: This is to provide a migration path for implementors of the legacy API which did not know about
* getLifecycles().
*/
String[] lifecycleIds = {"default", "clean", "site"};
for (String lifecycleId : lifecycleIds) {
Map<String, LifecyclePhase> phases = getLifecyclePhases(lifecycleId);
if (phases != null) {
Lifecycle lifecycle = new Lifecycle();
lifecycle.setId(lifecycleId);
lifecycle.setLifecyclePhases(phases);
lifecycleMap.put(lifecycleId, lifecycle);
}
}
}
}
| 607
| 288
| 895
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/mapping/Lifecycle.java
|
Lifecycle
|
getPhases
|
class Lifecycle {
/**
* Field id
*/
private String id;
/**
* Field phases
*/
private Map<String, LifecyclePhase> lifecyclePhases;
/**
* Method getId
*/
public String getId() {
return this.id;
}
/**
* Method getLifecyclePhases
*/
public Map<String, LifecyclePhase> getLifecyclePhases() {
return this.lifecyclePhases;
}
/**
* Method setId
*
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* Method setLifecyclePhases
*
* @param lifecyclePhases
*/
public void setLifecyclePhases(Map<String, LifecyclePhase> lifecyclePhases) {
this.lifecyclePhases = lifecyclePhases;
}
@Deprecated
public Map<String, String> getPhases() {<FILL_FUNCTION_BODY>}
@Deprecated
public void setPhases(Map<String, String> phases) {
Map<String, LifecyclePhase> lphases = new LinkedHashMap<>();
for (Map.Entry<String, String> e : phases.entrySet()) {
lphases.put(e.getKey(), new LifecyclePhase(e.getValue()));
}
setLifecyclePhases(lphases);
}
}
|
Map<String, LifecyclePhase> lphases = getLifecyclePhases();
if (lphases == null) {
return null;
}
if (lphases.isEmpty()) {
return Collections.emptyMap();
}
Map<String, String> phases = new LinkedHashMap<>();
for (Map.Entry<String, LifecyclePhase> e : lphases.entrySet()) {
phases.put(e.getKey(), e.getValue().toString());
}
return phases;
| 413
| 140
| 553
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/lifecycle/mapping/LifecyclePhase.java
|
LifecyclePhase
|
toLegacyMap
|
class LifecyclePhase {
private List<LifecycleMojo> mojos;
public LifecyclePhase() {}
public LifecyclePhase(String goals) {
set(goals);
}
public List<LifecycleMojo> getMojos() {
return mojos;
}
public void setMojos(List<LifecycleMojo> mojos) {
this.mojos = mojos;
}
public void set(String goals) {
mojos = new ArrayList<>();
if (goals != null && !goals.isEmpty()) {
String[] mojoGoals = goals.split(",");
mojos = Arrays.stream(mojoGoals).map(fromGoalIntoLifecycleMojo).collect(Collectors.toList());
}
}
private final Function<String, LifecycleMojo> fromGoalIntoLifecycleMojo = s -> {
LifecycleMojo lifecycleMojo = new LifecycleMojo();
lifecycleMojo.setGoal(s.trim());
return lifecycleMojo;
};
@Override
public String toString() {
return Optional.ofNullable(getMojos()).orElse(Collections.emptyList()).stream()
.map(LifecycleMojo::getGoal)
.collect(Collectors.joining(","));
}
@Deprecated
public static Map<String, String> toLegacyMap(Map<String, LifecyclePhase> lifecyclePhases) {<FILL_FUNCTION_BODY>}
}
|
if (lifecyclePhases == null) {
return null;
}
if (lifecyclePhases.isEmpty()) {
return Collections.emptyMap();
}
Map<String, String> phases = new LinkedHashMap<>();
for (Map.Entry<String, LifecyclePhase> e : lifecyclePhases.entrySet()) {
phases.put(e.getKey(), e.getValue().toString());
}
return phases;
| 423
| 123
| 546
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/model/plugin/DefaultLifecycleBindingsInjector.java
|
LifecycleBindingsMerger
|
mergePluginContainer_Plugins
|
class LifecycleBindingsMerger extends MavenModelMerger {
private static final String PLUGIN_MANAGEMENT = "plugin-management";
public Model merge(Model target, Model source) {
Build targetBuild = target.getBuild();
if (targetBuild == null) {
targetBuild = Build.newInstance();
}
Map<Object, Object> context =
Collections.singletonMap(PLUGIN_MANAGEMENT, targetBuild.getPluginManagement());
Build.Builder builder = Build.newBuilder(targetBuild);
mergePluginContainer_Plugins(builder, targetBuild, source.getBuild(), false, context);
return target.withBuild(builder.build());
}
@SuppressWarnings({"checkstyle:methodname"})
@Override
protected void mergePluginContainer_Plugins(
PluginContainer.Builder builder,
PluginContainer target,
PluginContainer source,
boolean sourceDominant,
Map<Object, Object> context) {<FILL_FUNCTION_BODY>}
@Override
protected void mergePluginExecution_Priority(
PluginExecution.Builder builder,
PluginExecution target,
PluginExecution source,
boolean sourceDominant,
Map<Object, Object> context) {
if (target.getPriority() > source.getPriority()) {
builder.priority(source.getPriority());
builder.location("priority", source.getLocation("priority"));
}
}
// mergePluginExecution_Priority( builder, target, source, sourceDominant, context );
}
|
List<Plugin> src = source.getPlugins();
if (!src.isEmpty()) {
List<Plugin> tgt = target.getPlugins();
Map<Object, Plugin> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);
for (Plugin element : tgt) {
Object key = getPluginKey().apply(element);
merged.put(key, element);
}
Map<Object, Plugin> added = new LinkedHashMap<>();
for (Plugin element : src) {
Object key = getPluginKey().apply(element);
Plugin existing = merged.get(key);
if (existing != null) {
element = mergePlugin(existing, element, sourceDominant, context);
} else {
added.put(key, element);
}
merged.put(key, element);
}
if (!added.isEmpty()) {
PluginManagement pluginMgmt = (PluginManagement) context.get(PLUGIN_MANAGEMENT);
if (pluginMgmt != null) {
for (Plugin managedPlugin : pluginMgmt.getPlugins()) {
Object key = getPluginKey().apply(managedPlugin);
Plugin addedPlugin = added.get(key);
if (addedPlugin != null) {
Plugin plugin =
mergePlugin(managedPlugin, addedPlugin, sourceDominant, Collections.emptyMap());
merged.put(key, plugin);
}
}
}
}
List<Plugin> result = new ArrayList<>(merged.values());
builder.plugins(result);
}
| 402
| 417
| 819
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/plugin/CacheUtils.java
|
CacheUtils
|
dependenciesEquals
|
class CacheUtils {
/**
* @deprecated Use {@link Objects#equals(Object)}
*/
@Deprecated
public static <T> boolean eq(T s1, T s2) {
return Objects.equals(s1, s2);
}
/**
* @deprecated Use {@link Objects#hashCode(Object)}
*/
@Deprecated
public static int hash(Object obj) {
return obj != null ? obj.hashCode() : 0;
}
public static int pluginHashCode(Plugin plugin) {
int hash = 17;
hash = hash * 31 + Objects.hashCode(plugin.getGroupId());
hash = hash * 31 + Objects.hashCode(plugin.getArtifactId());
hash = hash * 31 + Objects.hashCode(plugin.getVersion());
hash = hash * 31 + (plugin.isExtensions() ? 1 : 0);
for (Dependency dependency : plugin.getDependencies()) {
hash = hash * 31 + Objects.hashCode(dependency.getGroupId());
hash = hash * 31 + Objects.hashCode(dependency.getArtifactId());
hash = hash * 31 + Objects.hashCode(dependency.getVersion());
hash = hash * 31 + Objects.hashCode(dependency.getType());
hash = hash * 31 + Objects.hashCode(dependency.getClassifier());
hash = hash * 31 + Objects.hashCode(dependency.getScope());
for (Exclusion exclusion : dependency.getExclusions()) {
hash = hash * 31 + Objects.hashCode(exclusion.getGroupId());
hash = hash * 31 + Objects.hashCode(exclusion.getArtifactId());
}
}
return hash;
}
public static boolean pluginEquals(Plugin a, Plugin b) {
return Objects.equals(a.getArtifactId(), b.getArtifactId()) //
&& Objects.equals(a.getGroupId(), b.getGroupId()) //
&& Objects.equals(a.getVersion(), b.getVersion()) //
&& a.isExtensions() == b.isExtensions() //
&& dependenciesEquals(a.getDependencies(), b.getDependencies());
}
private static boolean dependenciesEquals(List<Dependency> a, List<Dependency> b) {<FILL_FUNCTION_BODY>}
private static boolean exclusionsEquals(List<Exclusion> a, List<Exclusion> b) {
if (a.size() != b.size()) {
return false;
}
Iterator<Exclusion> aI = a.iterator();
Iterator<Exclusion> bI = b.iterator();
while (aI.hasNext()) {
Exclusion aD = aI.next();
Exclusion bD = bI.next();
boolean r = Objects.equals(aD.getGroupId(), bD.getGroupId()) //
&& Objects.equals(aD.getArtifactId(), bD.getArtifactId());
if (!r) {
return false;
}
}
return true;
}
}
|
if (a.size() != b.size()) {
return false;
}
Iterator<Dependency> aI = a.iterator();
Iterator<Dependency> bI = b.iterator();
while (aI.hasNext()) {
Dependency aD = aI.next();
Dependency bD = bI.next();
boolean r = Objects.equals(aD.getGroupId(), bD.getGroupId()) //
&& Objects.equals(aD.getArtifactId(), bD.getArtifactId()) //
&& Objects.equals(aD.getVersion(), bD.getVersion()) //
&& Objects.equals(aD.getType(), bD.getType()) //
&& Objects.equals(aD.getClassifier(), bD.getClassifier()) //
&& Objects.equals(aD.getScope(), bD.getScope());
r &= exclusionsEquals(aD.getExclusions(), bD.getExclusions());
if (!r) {
return false;
}
}
return true;
| 812
| 278
| 1,090
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/plugin/DebugConfigurationListener.java
|
DebugConfigurationListener
|
notifyFieldChangeUsingReflection
|
class DebugConfigurationListener implements ConfigurationListener {
private final Logger logger;
/**
* @deprecated Use {@link #DebugConfigurationListener(Logger)} instead.
*/
@Deprecated
public DebugConfigurationListener(org.codehaus.plexus.logging.Logger logger) {
this(LoggerFactory.getLogger(logger.getName()));
}
public DebugConfigurationListener(Logger logger) {
this.logger = logger;
}
public void notifyFieldChangeUsingSetter(String fieldName, Object value, Object target) {
if (logger.isDebugEnabled()) {
logger.debug(" (s) " + fieldName + " = " + toString(value));
}
}
public void notifyFieldChangeUsingReflection(String fieldName, Object value, Object target) {<FILL_FUNCTION_BODY>}
/**
* Creates a human-friendly string representation of the specified object.
*
* @param obj The object to create a string representation for, may be <code>null</code>.
* @return The string representation, never <code>null</code>.
*/
private String toString(Object obj) {
String str;
if (obj != null && obj.getClass().isArray()) {
int n = Array.getLength(obj);
StringBuilder buf = new StringBuilder(256);
buf.append('[');
for (int i = 0; i < n; i++) {
if (i > 0) {
buf.append(", ");
}
buf.append(String.valueOf(Array.get(obj, i)));
}
buf.append(']');
str = buf.toString();
} else {
str = String.valueOf(obj);
}
return str;
}
}
|
if (logger.isDebugEnabled()) {
logger.debug(" (f) " + fieldName + " = " + toString(value));
}
| 449
| 41
| 490
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/plugin/DefaultExtensionRealmCache.java
|
CacheKey
|
flush
|
class CacheKey implements Key {
private final List<File> files;
private final List<Long> timestamps;
private final List<Long> sizes;
private final List<String> ids;
private final int hashCode;
public CacheKey(List<Artifact> extensionArtifacts) {
this.files = new ArrayList<>(extensionArtifacts.size());
this.timestamps = new ArrayList<>(extensionArtifacts.size());
this.sizes = new ArrayList<>(extensionArtifacts.size());
this.ids = new ArrayList<>(extensionArtifacts.size());
for (Artifact artifact : extensionArtifacts) {
File file = artifact.getFile();
files.add(file);
timestamps.add((file != null) ? Long.valueOf(file.lastModified()) : Long.valueOf(0));
sizes.add((file != null) ? Long.valueOf(file.length()) : Long.valueOf(0));
ids.add(artifact.getVersion());
}
this.hashCode =
31 * files.hashCode() + 31 * ids.hashCode() + 31 * timestamps.hashCode() + 31 * sizes.hashCode();
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof CacheKey)) {
return false;
}
CacheKey other = (CacheKey) o;
return ids.equals(other.ids)
&& files.equals(other.files)
&& timestamps.equals(other.timestamps)
&& sizes.equals(other.sizes);
}
@Override
public String toString() {
return files.toString();
}
}
protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();
@Override
public Key createKey(List<Artifact> extensionArtifacts) {
return new CacheKey(extensionArtifacts);
}
public CacheRecord get(Key key) {
return cache.get(key);
}
public CacheRecord put(
Key key, ClassRealm extensionRealm, ExtensionDescriptor extensionDescriptor, List<Artifact> artifacts) {
Objects.requireNonNull(extensionRealm, "extensionRealm cannot be null");
if (cache.containsKey(key)) {
throw new IllegalStateException("Duplicate extension realm for extension " + key);
}
CacheRecord record = new CacheRecord(extensionRealm, extensionDescriptor, artifacts);
cache.put(key, record);
return record;
}
public void flush() {<FILL_FUNCTION_BODY>
|
for (CacheRecord record : cache.values()) {
ClassRealm realm = record.getRealm();
try {
realm.getWorld().disposeRealm(realm.getId());
} catch (NoSuchRealmException e) {
// ignore
}
}
cache.clear();
| 712
| 79
| 791
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/plugin/DefaultPluginArtifactsCache.java
|
CacheKey
|
assertUniqueKey
|
class CacheKey implements Key {
private final Plugin plugin;
private final WorkspaceRepository workspace;
private final LocalRepository localRepo;
private final List<RemoteRepository> repositories;
private final DependencyFilter filter;
private final int hashCode;
public CacheKey(
Plugin plugin,
DependencyFilter extensionFilter,
List<RemoteRepository> repositories,
RepositorySystemSession session) {
this.plugin = plugin.clone();
workspace = RepositoryUtils.getWorkspace(session);
this.localRepo = session.getLocalRepository();
this.repositories = new ArrayList<>(repositories.size());
for (RemoteRepository repository : repositories) {
if (repository.isRepositoryManager()) {
this.repositories.addAll(repository.getMirroredRepositories());
} else {
this.repositories.add(repository);
}
}
this.filter = extensionFilter;
int hash = 17;
hash = hash * 31 + CacheUtils.pluginHashCode(plugin);
hash = hash * 31 + Objects.hashCode(workspace);
hash = hash * 31 + Objects.hashCode(localRepo);
hash = hash * 31 + RepositoryUtils.repositoriesHashCode(repositories);
hash = hash * 31 + Objects.hashCode(extensionFilter);
this.hashCode = hash;
}
@Override
public String toString() {
return plugin.getId();
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof CacheKey)) {
return false;
}
CacheKey that = (CacheKey) o;
return CacheUtils.pluginEquals(plugin, that.plugin)
&& Objects.equals(workspace, that.workspace)
&& Objects.equals(localRepo, that.localRepo)
&& RepositoryUtils.repositoriesEquals(repositories, that.repositories)
&& Objects.equals(filter, that.filter);
}
}
protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();
public Key createKey(
Plugin plugin,
DependencyFilter extensionFilter,
List<RemoteRepository> repositories,
RepositorySystemSession session) {
return new CacheKey(plugin, extensionFilter, repositories, session);
}
public CacheRecord get(Key key) throws PluginResolutionException {
CacheRecord cacheRecord = cache.get(key);
if (cacheRecord != null && cacheRecord.getException() != null) {
throw cacheRecord.getException();
}
return cacheRecord;
}
public CacheRecord put(Key key, List<Artifact> pluginArtifacts) {
Objects.requireNonNull(pluginArtifacts, "pluginArtifacts cannot be null");
assertUniqueKey(key);
CacheRecord record = new CacheRecord(Collections.unmodifiableList(new ArrayList<>(pluginArtifacts)));
cache.put(key, record);
return record;
}
protected void assertUniqueKey(Key key) {<FILL_FUNCTION_BODY>
|
if (cache.containsKey(key)) {
throw new IllegalStateException("Duplicate artifact resolution result for plugin " + key);
}
| 855
| 37
| 892
|
<no_super_class>
|
apache_maven
|
maven/maven-core/src/main/java/org/apache/maven/plugin/DefaultPluginDescriptorCache.java
|
CacheKey
|
equals
|
class CacheKey implements Key {
private final String groupId;
private final String artifactId;
private final String version;
private final WorkspaceRepository workspace;
private final LocalRepository localRepo;
private final List<RemoteRepository> repositories;
private final int hashCode;
CacheKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
groupId = plugin.getGroupId();
artifactId = plugin.getArtifactId();
version = plugin.getVersion();
workspace = RepositoryUtils.getWorkspace(session);
localRepo = session.getLocalRepository();
this.repositories = new ArrayList<>(repositories.size());
for (RemoteRepository repository : repositories) {
if (repository.isRepositoryManager()) {
this.repositories.addAll(repository.getMirroredRepositories());
} else {
this.repositories.add(repository);
}
}
int hash = 17;
hash = hash * 31 + groupId.hashCode();
hash = hash * 31 + artifactId.hashCode();
hash = hash * 31 + version.hashCode();
hash = hash * 31 + hash(workspace);
hash = hash * 31 + localRepo.hashCode();
hash = hash * 31 + RepositoryUtils.repositoriesHashCode(repositories);
this.hashCode = hash;
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return groupId + ':' + artifactId + ':' + version;
}
private static int hash(Object obj) {
return obj != null ? obj.hashCode() : 0;
}
}
|
if (this == obj) {
return true;
}
if (!(obj instanceof CacheKey)) {
return false;
}
CacheKey that = (CacheKey) obj;
return Objects.equals(this.artifactId, that.artifactId)
&& Objects.equals(this.groupId, that.groupId)
&& Objects.equals(this.version, that.version)
&& Objects.equals(this.localRepo, that.localRepo)
&& Objects.equals(this.workspace, that.workspace)
&& RepositoryUtils.repositoriesEquals(this.repositories, that.repositories);
| 489
| 164
| 653
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.