/** * Finds the first ProjectSegment matching the supplied project * @param mavenProject the requested project * @return The projectSegment or null. */ public ProjectSegment findByMavenProject( MavenProject mavenProject ) { for ( ProjectSegment projectBuild : items ) { if ( mavenProject.equals( projectBuild.getProject() ) ) { return projectBuild; } } return null; }
private static void resumeFrom( String resumeFrom, List sortedProjects, Map projectMap, MavenProject topLevelProject ) throws MissingProjectException { if ( resumeFrom == null ) return; MavenProject resumeFromProject = findProject( resumeFrom, projectMap, topLevelProject ); for ( Iterator i = sortedProjects.iterator(); i.hasNext(); ) { MavenProject project = (MavenProject) i.next(); if ( resumeFromProject.equals( project ) ) break; i.remove(); } if ( sortedProjects.isEmpty() ) { throw new MissingProjectException( "Couldn't resume, project was not scheduled to run: " + resumeFrom ); } }
/** * A helper method to determine the value to resume the build with {@code -rf} taking into account the * edge case where multiple modules in the reactor have the same artifactId. * <p> * {@code -rf :artifactId} will pick up the first module which matches, but when multiple modules in the * reactor have the same artifactId, effective failed module might be later in build reactor. * This means that developer will either have to type groupId or wait for build execution of all modules * which were fine, but they are still before one which reported errors. * <p>Then the returned value is {@code groupId:artifactId} when there is a name clash and * {@code :artifactId} if there is no conflict. * * @param mavenProjects Maven projects which are part of build execution. * @param failedProject Project which has failed. * @return Value for -rf flag to resume build exactly from place where it failed ({@code :artifactId} in * general and {@code groupId:artifactId} when there is a name clash). */ private String getResumeFrom( List<MavenProject> mavenProjects, MavenProject failedProject ) { for ( MavenProject buildProject : mavenProjects ) { if ( failedProject.getArtifactId().equals( buildProject.getArtifactId() ) && !failedProject.equals( buildProject ) ) { return failedProject.getGroupId() + ":" + failedProject.getArtifactId(); } } return ":" + failedProject.getArtifactId(); }
size = descendants.size(); for (MavenProject p : getReactorProjects()) { if (project.equals(p.getParent()) || descendants.contains(p.getParent())) { if (descendants.add(p) && getLog().isDebugEnabled()) { getLog().debug(String.format("Descendant %s added", p.getName()));
if ( project != null && !project.equals( result.getTopologicallySortedProjects().get( 0 ) ) )
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof DefaultReactorProject)) { return false; } DefaultReactorProject other = (DefaultReactorProject) obj; return project.equals(other.project); }
@Override public boolean sameProject(Object otherProject) { return project.equals(otherProject); }
@Override public boolean equals(Object arg0) { return wrapped.equals(arg0); }
/** * Check whether the element is the last element of the list * * @param project element to check * @param mavenProjectList list of maven project * @return true if project is the last element of mavenProjectList list */ private boolean isLastProject( MavenProject project, List<MavenProject> mavenProjectList ) { return project.equals( mavenProjectList.get( mavenProjectList.size() - 1 ) ); }
private List<MavenProject> getProjectsWithoutRoot() { List<MavenProject> result = new ArrayList<>(); for ( MavenProject subProject : reactorProjects ) { if ( !project.equals( subProject ) ) { result.add( subProject ); } } return result; }
private List<MavenProject> getProjectsWithoutRoot() { List<MavenProject> result = new ArrayList<MavenProject>(); for ( MavenProject subProject : reactorProjects ) { if ( !project.equals( subProject ) ) { result.add( subProject ); } } return result; }
/** * Check whether the element is the last element of the list * * @param project element to check * @param mavenProjectList list of maven project * @return true if project is the last element of mavenProjectList list */ private boolean isLastProject( MavenProject project, List<MavenProject> mavenProjectList ) { return project.equals( mavenProjectList.get( mavenProjectList.size() - 1 ) ); }
/** * A helper method to determine the value to resume the build with {@code -rf} taking into account the * edge case where multiple modules in the reactor have the same artifactId. * <p> * {@code -rf :artifactId} will pick up the first module which matches, but when multiple modules in the * reactor have the same artifactId, effective failed module might be later in build reactor. * This means that developer will either have to type groupId or wait for build execution of all modules * which were fine, but they are still before one which reported errors. * <p>Then the returned value is {@code groupId:artifactId} when there is a name clash and * {@code :artifactId} if there is no conflict. * * @param mavenProjects Maven projects which are part of build execution. * @param failedProject Project which has failed. * @return Value for -rf flag to resume build exactly from place where it failed ({@code :artifactId} in * general and {@code groupId:artifactId} when there is a name clash). */ private String getResumeFrom( List<MavenProject> mavenProjects, MavenProject failedProject ) { for ( MavenProject buildProject : mavenProjects ) { if ( failedProject.getArtifactId().equals( buildProject.getArtifactId() ) && !failedProject.equals( buildProject ) ) { return failedProject.getGroupId() + ":" + failedProject.getArtifactId(); } } return ":" + failedProject.getArtifactId(); }
public void removeProject( MavenProject project ) { for ( Map.Entry<String, SortedSet<MavenProject>> entry : entrySet() ) { SortedSet<MavenProject> projects = entry.getValue(); for ( MavenProject mavenProject : projects ) { if ( project.equals( mavenProject ) ) { get( entry.getKey() ).remove( project ); return; } } } } }
@SuppressWarnings("unchecked") protected void tryAggregateUpper(MavenProject prj) throws Exception { if (prj != null && prj.hasParent() && canAggregate()) { MavenProject parent = prj.getParent(); List<MavenProject> modules = parent.getCollectedProjects(); if ((modules.size() > 1) && prj.equals(modules.get(modules.size() - 1))) { aggregate(parent); } } }
/** * <p>Determines whether Mojo should be executed. By default it won't affect execution but it can be influenced by * {@link com.atlassian.maven.plugins.amps.RunMojo#runLastProject} and {@link com.atlassian.maven.plugins.amps.RunMojo#runProject} properties</p> * * @see com.atlassian.maven.plugins.amps.RunMojo#runLastProject * @see com.atlassian.maven.plugins.amps.RunMojo#runProject * * @return <code>true</code> when this execution not should be skipped, <code>false</code> otherwise */ protected boolean shouldExecute() { final MavenContext mavenContext = getMavenContext(); final MavenProject currentProject = mavenContext.getProject(); getLog().debug(String.format("Current project ID: %s, runLastProject=%b, runProject=%s", currentProject.getArtifactId(), runLastProject, runProject)); //check explicit runProject setup if (StringUtils.isNotBlank(runProject)) { return StringUtils.equalsIgnoreCase(runProject, currentProject.getArtifactId()); } //otherwise respect runLastProject if (!runLastProject) { return true; } final List<MavenProject> reactor = mavenContext.getReactor(); return reactor == null || Iterables.getLast(reactor, currentProject).equals(currentProject); }
/** * Checks the value of the project against the one given in the defining ancestor project. * * @param project * @param parent * @param helper * @param propValue * @throws EnforcerRuleException */ void checkAgainstParentValue( final MavenProject project, final MavenProject parent, EnforcerRuleHelper helper, Object propValue ) throws EnforcerRuleException { final StringBuilder parentHierarchy = new StringBuilder( "project." ); MavenProject needle = project; while ( !needle.equals( parent ) ) { parentHierarchy.append( "parent." ); needle = needle.getParent(); } final String propertyNameInParent = property.replace( "project.", parentHierarchy.toString() ); Object parentValue = getPropertyValue( helper, propertyNameInParent ); if ( propValue.equals( parentValue ) ) { final String errorMessage = createResultingErrorMessage( String.format( "Property '%s' evaluates to '%s'. This does match '%s' from parent %s", property, propValue, parentValue, parent ) ); throw new EnforcerRuleException( errorMessage ); } }
/** * Is this project the last project in the reactor? * * @return true if last project (including only project) */ private boolean isLastProjectInReactor() { List<MavenProject> sortedProjects = session.getProjectDependencyGraph().getSortedProjects(); MavenProject lastProject = sortedProjects.isEmpty() ? session.getCurrentProject() : sortedProjects.get( sortedProjects.size() - 1 ); if ( getLog().isDebugEnabled() ) { getLog().debug( "Current project: '" + session.getCurrentProject().getName() + "', Last project to execute based on dependency graph: '" + lastProject.getName() + "'" ); } return session.getCurrentProject().equals( lastProject ); }
private void populatePackages(JangarooApp jangarooApp, MavenProject project) throws MojoExecutionException { List<Dependency> dependencies = project.getDependencies(); JangarooAppOverlay jangarooAppOverlay = jangarooApp instanceof JangarooAppOverlay ? (JangarooAppOverlay) jangarooApp : null; for (Dependency dependency : dependencies) { if (isRequiredSenchaDependency(dependency, false) || Type.POM_PACKAGING.equals(dependency.getType()) || (Type.JAR_EXTENSION.equals(dependency.getType()) && Artifact.SCOPE_RUNTIME.equals(dependency.getScope()))) { MavenProject mavenProject = getProjectFromDependency(project, dependency); if (jangarooAppOverlay != null && jangarooAppOverlay.baseApp.mavenProject.equals(mavenProject)) { populatePackages(jangarooAppOverlay.baseApp, mavenProject); } else { if (!SenchaUtils.isSenchaDependency(dependency.getType()) || jangarooApp.packages.add(getArtifact(dependency))) { populatePackages(jangarooApp, mavenProject); } } } } }
private void buildModuleTree(MavenProject parentProject, GraphBuilder<DependencyNode> graphBuilder) { Collection<MavenProject> collectedProjects = parentProject.getCollectedProjects(); for (MavenProject collectedProject : collectedProjects) { MavenProject child = collectedProject; MavenProject parent = collectedProject.getParent(); while (parent != null) { DependencyNode parentNode = filterProject(parent); DependencyNode childNode = filterProject(child); graphBuilder.addEdge(parentNode, childNode); // Stop if we reached the original parent project! if (parent.equals(parentProject)) { break; } child = parent; parent = parent.getParent(); } } }