Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright 2011-2013 The Kuali Foundation Licensed under the Educational Community License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.opensource.org/licenses/ecl2.php Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
  
  package org.kuali.maven.plugins.externals;
  
  import static org.apache.commons.io.filefilter.FileFilterUtils.and;
  import static org.apache.commons.io.filefilter.FileFilterUtils.directoryFileFilter;
  import static org.apache.commons.io.filefilter.FileFilterUtils.nameFileFilter;
  import static org.apache.commons.io.filefilter.FileFilterUtils.notFileFilter;
  
  import java.io.File;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  
  import org.slf4j.Logger;
  
  public class MojoHelper {
  	
  	private static final Logger log = LoggerFactory.getLogger(MojoHelper.class);
  	
  	private static final String QUALIFIER_DELIMETER = "-";
  	private static final Logger logger = LoggerFactory.getLogger(MojoHelper.class);
  	private static final String MAVEN_SNAPSHOT_TOKEN = "SNAPSHOT";
  	private static final char[] DIGITS = new char[] { '0''1''2''3''4''5''6''7''8''9' };
  	
  	private static final String majorQualifierFoundersReleasePrefix = "FR";
  	
  	private static final String minorQualiferMilestonePrefix  = "M";
  	private static final String minorQualiferReleaseCandidatePrefix  = "RC";
  	
  	SVNUtils svnUtils = SVNUtils.getInstance();
  	POMUtils pomUtils = new POMUtils();
  	Extractor extractor = new Extractor();
  	NumberFormat nf = NumberFormat.getInstance();
  
  	protected static MojoHelper instance;
  
  	protected MojoHelper() {
  		super();
  		.setGroupingUsed(false);
  	}
  
  	public synchronized static MojoHelper getInstance() {
  		if ( == null) {
  			 = new MojoHelper();
  		}
  		return ;
  	}
  
  	public void incrementVersions(AbstractTagMojo mojo) {
  		List<Filefiles = getPoms(mojo.getProject().getBasedir(), mojo.getPom(), mojo.getIgnoreDirectories());
  		List<DefaultMutableTreeNodenodes = getNodes(files);
  		DefaultMutableTreeNode node = getTree(mojo.getProject().getBasedir(), nodesmojo.getPom());
  		updateGavs(node);
  		updateProperties(nodemojo.getProject().getProperties(), mojo.getMappings());
  		updateXml(node);
  		writePoms(nodemojo.getProject().getBasedir());
  		.info("Committing pom changes");
 		commitChanges(mojo.getProject().getBasedir(), externals"[externals-maven-plugin] prepare for next development iteration");
 	}
 
 		Enumeration<?> e = node.children();
 		while (e.hasMoreElements()) {
 			children.add(child);
 		}
 		return children;
 	}
 
 	public void incrementVersions(DefaultMutableTreeNode node) {
 		Project project = (Projectnode.getUserObject();
 		GAV gav = project.getGav();
 		String oldVersion = gav.getVersion();
 		if (!StringUtils.isBlank(oldVersion)) {
 			String newVersion = getNextVersion(oldVersion);
 			GAV newGav = new GAV();
 			newGav.setGroupId(gav.getGroupId());
 			newGav.setVersion(newVersion);
 			project.setNewGav(newGav);
 			.info(StringUtils.repeat("  "node.getLevel()) + gav.getArtifactId() + ":" + gav.getArtifactId() + ":" + oldVersion + "->" + newVersion);
 		}
 		List<DefaultMutableTreeNodechildren = getChildren(node);
 		for (DefaultMutableTreeNode child : children) {
 		}
 	}
 
 	public void createAndUpdateTags(AbstractTagMojo mojo) {
 
 		// Extract the Jenkins build number. Defaults to zero if no BUILD_NUMBER is set
 		int buildNumber = getBuildNumber(mojo.getProject(), mojo.getBuildNumberProperty());
 
 		// Create a GAV object from the Maven project
 		GAV gav = getGav(mojo.getProject());
 
 		// Scan the file system for pom.xml files
 		List<Filefiles = getPoms(mojo.getProject().getBasedir(), mojo.getPom(), mojo.getIgnoreDirectories());
 
 		// Convert the list of files into a list of node objects
 		List<DefaultMutableTreeNodenodes = getNodes(files);
 
 		// Build a tree from the list
 		DefaultMutableTreeNode node = getTree(mojo.getProject().getBasedir(), nodesmojo.getPom());
 
 		// Extract svn:externals info from the root of the checkout
 
 		// Make sure the modules listed in the pom match the svn:externals definitions and the mappings provided in the plugin config
 		validate(mojo.getProject(), externalsmojo.getMappings());
 
 		// Calculate the build tag for the root
 		BuildTag rootTag = getBuildTag(mojo.getProject().getBasedir(), gavmojo.getTagStyle(), buildNumber);
 
 		// Update build info for the root node
 		updateBuildInfo(noderootTagmojo.getTagStyle(), buildNumber);
 
 		// Calculate build tags for each module
 		List<BuildTagmoduleTags = getBuildTags(mojo.getProject().getProperties(), externalsmojo.getMappings(), mojo.getTagStyle(), buildNumber);
 
 		// Update build information for nodes that represent an svn:external
 		updateBuildInfo(nodesmoduleTagsmojo.getMappings(), mojo.getTagStyle(), buildNumber);
 
 		// Recursively update the mojo.getProject() gav's and parent gav's
 		updateGavs(node);
 
 		// Recursively update the corresponding Maven pom's
 		updateXml(node);
 
 		// Update the properties in the root pom that hold version info for the modules
 
 		// Update the <scm> info in the root pom
 		updateScm(nodemojo.getScmUrlPrefix());
 
 		// Create new svn:externals definitions based on the newly created tags
 		List<SVNExternalnewExternals = getExternals(moduleTagsmojo.getMappings());
 
 		// Create the module tags
 		createTags(moduleTagsmojo.getCreateTagMessage());
 
 		// Create the root tag
 		createTag(rootTagmojo.getCreateTagMessage());
 
 		// The directory the tag was checked out to
 		File checkoutDir = mojo.getCheckoutDir();
 
 		// Update svn:externals definitions on the root tag so they point to the new module tags
 		SVNCommitInfo info = .setExternals(rootTag.getTagUrl(), newExternalsmojo.getExternalsMessage());
 		.info("Set " + newExternals.size() + " externals @ " + rootTag.getTagUrl());
 		.info("Committed revision " + info.getNewRevision() + ".");
 		.info("Checking out - " + rootTag.getTagUrl());
 		.info("Checkout dir - " + checkoutDir.getAbsolutePath());
 		if (checkoutDir.exists()) {
 			.info("Deleting " + checkoutDir.getAbsolutePath());
 			deleteDirectory(checkoutDir);
 		}
 		long start = System.currentTimeMillis();
 		long revision = .checkout(rootTag.getTagUrl(), checkoutDirnullnull);
 		logTime("Total checkout time: ", System.currentTimeMillis() - start);
 		.info("Checked out revision " + revision + ".");
 
 		// Update the poms in the directory where the tag has been checked out
 		writePoms(nodemojo.getProject().getBasedir(), checkoutDir);
 
 		// Update the svn.externals file in the tag
 		updateExternalsFile(newExternalsmojo.getFile());
 
 		// Commit the changes to the tag
 		commitChanges(checkoutDirnewExternalsmojo.getUpdateTagMessage());
 	}
 
 	public GAV getGav(MavenProject project) {
 		GAV gav = new GAV();
 		gav.setGroupId(project.getGroupId());
 		gav.setArtifactId(project.getArtifactId());
 		gav.setVersion(project.getVersion());
 		return gav;
 	}
 
 	public String toString(GAV gav) {
 		StringBuilder sb = new StringBuilder();
 		sb.append(gav.getGroupId());
 		sb.append(":");
 		sb.append(gav.getArtifactId());
 		sb.append(":");
 		sb.append(gav.getVersion());
 		return sb.toString();
 	}
 
 		List<Projectprojects = getProjectPath(node);
 		for (Project project : projects) {
 			GAV gav = project.getGav();
 			if (!StringUtils.isBlank(gav.getGroupId())) {
 				return gav.getGroupId();
 			}
 		}
 		throw new IllegalStateException("Unable to determine a version");
 	}
 
 		List<Projectprojects = getProjectPath(node);
 		for (Project project : projects) {
 			GAV gav = project.getGav();
 			if (!StringUtils.isBlank(gav.getVersion())) {
 				return gav.getVersion();
 			}
 		}
 		throw new IllegalStateException("Unable to determine a version");
 	}
 
 		Object[] projectObjects = node.getUserObjectPath();
 		List<Projectprojects = new ArrayList<Project>();
 		for (Object projectObject : projectObjects) {
 			projects.add((ProjectprojectObject);
 		}
 		Collections.reverse(projects);
 		return projects;
 	}
 
 		Project project = (Projectnode.getUserObject();
 		GAV gav = project.getGav();
 		GAV parent = project.getParent();
 		int level = node.getLevel();
 		StringBuilder sb = new StringBuilder();
 		sb.append(StringUtils.repeat(" "level));
 		sb.append(toString(parent));
 		sb.append(" -> ");
 		sb.append(toString(gav));
 		sb.append("\n");
 		Enumeration<?> children = node.children();
 		while (children.hasMoreElements()) {
 		}
 		return sb.toString();
 	}
 
 	public String getDisplayString(DefaultMutableTreeNode nodeFile basedirString pomFile) {
 		Project project = (Projectnode.getUserObject();
 		File pom = project.getPom();
 		String pomPath = pom.getAbsolutePath();
 		String displayPath = pomPath.replace(basedir.getAbsolutePath(), "");
 		displayPath = displayPath.replace(pomFile"");
 		if (!node.isRoot()) {
 			displayPath = displayPath.substring(0, displayPath.length() - 1);
 			int pos = displayPath.lastIndexOf(.);
 			displayPath = displayPath.substring(pos);
 			displayPath = displayPath.replace("/""");
 		}
 		int level = node.getLevel();
 		StringBuilder sb = new StringBuilder();
 		sb.append(StringUtils.repeat(" "level));
 		sb.append(displayPath);
 		sb.append("\n");
 		Enumeration<?> children = node.children();
 		while (children.hasMoreElements()) {
 			sb.append(getDisplayString(childbasedirpomFile));
 		}
 		return sb.toString();
 	}

Convert each pom.xml into a Project object and then store each Project as the user object in a DefaultMutableTreeNode
 
 	protected List<DefaultMutableTreeNodegetNodes(List<Filefiles) {
 		for (File file : files) {
 			String pomContents = read(file);
 			GAV parent = .getParentGAV(pomContents);
 			GAV gav = .getGAV(pomContents);
 			Project project = new Project();
 			project.setPom(file);
 			project.setPomContents(pomContents);
 			project.setGav(gav);
 			project.setParent(parent);
 			nodes.add(node);
 		}
 		return nodes;
 	}
 
 		for (DefaultMutableTreeNode node : nodes) {
 			Project project = (Projectnode.getUserObject();
 			File file = project.getPom();
 			map.put(file.getAbsolutePath(), node);
 		}
 		return map;
 	}

Assemble the list of nodes into a tree, based on the directory structure.
 
 	public DefaultMutableTreeNode getTree(File basedirList<DefaultMutableTreeNodenodesString pomFile) {
 		for (DefaultMutableTreeNode child : nodes) {
 			Project project = (Projectchild.getUserObject();
 			File pom = project.getPom();
 			File pomDir = pom.getParentFile();
 			File parentPom = new File(pomDir.getParentFile(), pomFile);
 			String parentPomPath = parentPom.getAbsolutePath();
 			DefaultMutableTreeNode parent = map.get(parentPomPath);
 			if (parent != null) {
 				parent.add(child);
 			}
 		}
 		String rootPom = basedir + . + pomFile;
 		DefaultMutableTreeNode root = map.get(rootPom);
 		
 		return root;
 	}
 
 	}
 
 		return getIgnoreDirectoriesFilter(csv.split(","));
 	}
 
 	protected IOFileFilter getIgnoreDirectoriesFilter(String... directories) {
 		IOFileFilter[] filters = new IOFileFilter[directories.length];
 		for (int i = 0; i < filters.lengthi++) {
 			String dir = directories[i].trim();
 			filters[i] = getIgnoreDirectoryFilter(dir);
 		}
 		return FileFilterUtils.and(filters);
 	}
 
 	public List<FilegetPoms(File basedirString pomFileString ignoreDirectoriesCSV) {
 		IOFileFilter fileFilter = nameFileFilter(pomFile);
 		IOFileFilter dirFilter = getIgnoreDirectoriesFilter(ignoreDirectoriesCSV);
 		List<Filefiles = new ArrayList<File>(FileUtils.listFiles(basedirfileFilterdirFilter));
 		Collections.sort(files);
 		return files;
 	}
 
 	public List<SVNExternalgetExternals(List<BuildTagmoduleTagsList<Mappingmappings) {
 		List<SVNExternalexternals = new ArrayList<SVNExternal>();
 		for (int i = 0; i < mappings.size(); i++) {
 			Mapping mapping = mappings.get(i);
 			BuildTag moduleTag = moduleTags.get(i);
 			SVNExternal external = new SVNExternal();
 			external.setPath(mapping.getModule());
 			external.setUrl(moduleTag.getTagUrl());
 			externals.add(external);
 		}
 		return externals;
 	}
 
 	public boolean exists(String url) {
 		Resource resource = loader.getResource(url);
 		return resource.exists();
 	}
 
 	public void createTag(BuildTag buildTagString message) {
 		createTags(Collections.singletonList(buildTag), message);
 	}
 
 	public void createTags(List<BuildTagbuildTagsString message) {
 		for (BuildTag buildTag : buildTags) {
 			String src = buildTag.getSourceUrl();
 			long revision = buildTag.getSourceRevision();
 			String dst = buildTag.getTagUrl();
 			boolean exists = exists(dst);
 			if (exists) {
 				.info("Skip existing tag [" + dst + "]");
 				buildTag.setSkipped(true);
 			} else {
 				SVNCommitInfo info = .copy(srcrevisiondstmessage);
 				.info("Created [" + dst + "]");
 				.debug("Comitted revision " + info.getNewRevision());
 			}
 		}
 	}
 
 	public void updateExternalsFile(List<SVNExternalexternalsFile externalsFile) {
 		StringBuilder sb = new StringBuilder();
 		for (SVNExternal external : externals) {
 			sb.append(external.getPath());
 			sb.append(" ");
 			sb.append(external.getUrl());
 			sb.append("\n");
 		}
 		write(externalsFilesb.toString());
 		.info("Updated svn:externals control file - " + externalsFile.getAbsolutePath());
 	}
 
 	public void commitChanges(File dirList<SVNExternalexternalsString msg) {
 		List<FileworkingCopyPaths = new ArrayList<File>();
 		workingCopyPaths.add(dir);
 		for (SVNExternal external : externals) {
 			String path = dir.getAbsolutePath() + . + external.getPath();
 			workingCopyPaths.add(new File(path));
 		}
 		File[] commitDirs = workingCopyPaths.toArray(new File[workingCopyPaths.size()]);
 		SVNCommitInfo info = .commit(commitDirsmsgnullnull);
 		.info("Committed revision " + info.getNewRevision() + ".");
 	}
 
 	public void logTime(String msglong elapsed) {
 		double millis = elapsed * 1.0D;
 		double millisPerSecond = 1000;
 		double millisPerMinute = 60 * millisPerSecond;
 		double millisPerHour = 60 * millisPerMinute;
 		if (millis > millisPerHour) {
 			.info(msg + .format(millis / millisPerHour) + "h");
 		} else if (millis > millisPerMinute) {
 			.info(msg + .format(millis / millisPerMinute) + "m");
 		} else {
 			.info(msg + .format(millis / millisPerSecond) + "s");
 		}
 	}
 
 	public void writePoms(DefaultMutableTreeNode nodeFile baseDir) {
 		int count = 0;
 		while (e.hasMoreElements()) {
 			Project project = (Projectelement.getUserObject();
 			File pom = project.getPom();
 			String oldContents = read(pom);
 			String newContents = project.getPomContents();
 			if (!oldContents.equals(newContents)) {
 				.debug("Updating " + pom.getAbsolutePath());
 				write(pomnewContents);
 				count++;
 			}
 		}
 		.info("Updated " + count + " Maven pom's");
 	}
 
 	public void writePoms(DefaultMutableTreeNode nodeFile baseDirFile checkoutDir) {
 		int count = 0;
 		while (e.hasMoreElements()) {
 			Project project = (Projectelement.getUserObject();
 			File pom = project.getPom();
 			String relativePath = getRelativePath(baseDirpom);
 			File newPom = new File(checkoutDir.getAbsolutePath() + . + relativePath);
 			String oldContents = read(pom);
 			String newContents = project.getPomContents();
 			if (!oldContents.equals(newContents)) {
 				.debug("Updating " + newPom.getAbsolutePath());
 				write(newPomnewContents);
 				count++;
 			}
 		}
 		.info("Updated " + count + " Maven pom's");
 	}
 
 	protected String getRelativePath(File dirFile file) {
 		String dirPath = dir.getAbsolutePath();
 		String filePath = file.getAbsolutePath();
 		return filePath.replace(dirPath"");
 	}
 
 	public void updateScm(DefaultMutableTreeNode rootString scmUrlPrefix) {
 		Project project = (Projectroot.getUserObject();
 		BuildTag buildTag = project.getBuildTag();
 		String url = buildTag.getTagUrl();
 		String oldXml = project.getPomContents();
 		String newXml = .updateScm(oldXmlscmUrlPrefixurl);
 		project.setPomContents(newXml);
 	}
 
 	protected String getGroupId(Project project) {
 		GAV gav = project.getGav();
 		GAV parent = project.getParent();
 		String groupId = gav.getGroupId();
 		String parentGroupId = parent.getGroupId();
 		if (!StringUtils.isBlank(groupId)) {
 			return groupId;
 		} else {
 			return parentGroupId;
 		}
 	}
 
 	protected String getVersion(Project project) {
 		GAV gav = project.getGav();
 		GAV parent = project.getParent();
 		String version = gav.getVersion();
 		String parentVersion = parent.getVersion();
 		if (!StringUtils.isBlank(version)) {
 			return version;
 		} else {
 			return parentVersion;
 		}
 	}
 
 	public void updateGavs(DefaultMutableTreeNode node) {
 		Project project = (Projectnode.getUserObject();
 		if (project.getNewGav() != null) {
 			project.setGav(project.getNewGav());
 		}
 		Enumeration<?> children = node.children();
 		while (children.hasMoreElements()) {
 			Project childProject = (Projectchild.getUserObject();
 			String oldParentVersion = childProject.getParent().getVersion();
 			String newParentVersion = getVersion(node);
 			if (!oldParentVersion.equals(newParentVersion)) {
 				childProject.getParent().setVersion(newParentVersion);
 			}
 			updateGavs(child);
 		}
 	}
 
 	public void updateProperties(DefaultMutableTreeNode nodeProperties propertiesList<Mappingmappings) {
 		Project project = (Projectnode.getUserObject();
 		Properties versionProperties = getVersionProperties(propertiesmappingsnode);
 		String oldXml = project.getPomContents();
 		String newXml = .updateProperties(oldXmlversionProperties);
 		project.setPomContents(newXml);
 	}
 
 	public Properties getVersionProperties(Properties propertiesList<MappingmappingsDefaultMutableTreeNode node) {
 		Properties newProperties = new Properties();
 		for (Mapping mapping : mappings) {
 			String artifactId = mapping.getModule();
 			String key = mapping.getVersionProperty();
 			String oldValue = properties.getProperty(key);
 			if (StringUtils.isBlank(oldValue)) {
 				throw new IllegalStateException("No existing value for '" + key + "'");
 			}
 			DefaultMutableTreeNode moduleNode = findNode(nodeartifactId);
 			String newValue = getVersion(moduleNode);
 			newProperties.setProperty(keynewValue);
 		}
 		return newProperties;
 	}
 
 	protected DefaultMutableTreeNode findNode(DefaultMutableTreeNode nodeString artifactId) {
 		while (e.hasMoreElements()) {
 			Project project = (Projectelement.getUserObject();
 			GAV gav = project.getGav();
 			if (gav.getArtifactId().equals(artifactId)) {
 				return element;
 			}
 		}
 		throw new IllegalStateException("Unable to locate " + artifactId);
 	}
 
 	public void updateXml(DefaultMutableTreeNode node) {
 		Project project = (Projectnode.getUserObject();
 		String version = project.getGav().getVersion();
 		if (!StringUtils.isBlank(version)) {
 			String oldXml = project.getPomContents();
 			String newXml = .updateVersion(oldXmlversion);
 			project.setPomContents(newXml);
 		}
 		String parentVersion = project.getParent().getVersion();
 		String oldXml = project.getPomContents();
 		String newXml = .updateParentVersion(oldXmlparentVersion);
 		project.setPomContents(newXml);
 		Enumeration<?> children = node.children();
 		while (children.hasMoreElements()) {
 			updateXml(child);
 		}
 	}
 
 	protected void log(DefaultMutableTreeNode node) {
 		StringBuilder sb = new StringBuilder();
 	}
 
 		while (e.hasMoreElements()) {
 			Project project = (Projectelement.getUserObject();
 			GAV gav = project.getGav();
 			String gavId = toString(gav);
 			map.put(gavIdelement);
 		}
 		return map;
 	}
 
 	public void validateMappings(Properties propertiesList<MappingmappingsDefaultMutableTreeNode node) {
 		for (Mapping mapping : mappings) {
 			boolean valid = isValid(propertiesmappingnode);
 			if (!valid) {
 				throw new IllegalStateException("Version mismatch on " + mapping.getModule());
 			}
 		}
 	}
 
 	public boolean isValid(Properties propertiesMapping mappingDefaultMutableTreeNode node) {
 		DefaultMutableTreeNode match = findNode(nodemapping.getModule());
 		Project project = (Projectmatch.getUserObject();
 		GAV gav = project.getGav();
 		String propertyVersion = properties.getProperty(mapping.getVersionProperty());
 		String gavVersion = gav.getVersion();
 		return propertyVersion.equals(gavVersion);
 	}
 
 		while (e.hasMoreElements()) {
 			if (element.isRoot()) {
 				continue;
 			}
 			Project project = (Projectelement.getUserObject();
 			GAV parentGav = project.getParent();
 			String parentGavId = toString(parentGav);
 			DefaultMutableTreeNode parent = map.get(parentGavId);
 			if (parent == null) {
 				throw new IllegalStateException(parentGavId + " could not be located");
 			}
 		}
 	}
 
 	public void fillInGavs(DefaultMutableTreeNode node) {
 		Project project = (Projectnode.getUserObject();
 		GAV gav = project.getGav();
 		String groupId = getGroupId(node);
 		String version = getVersion(node);
 		if (gav.getGroupId() == null) {
 			gav.setGroupId(groupId);
 			.debug("Update " + gav.getArtifactId() + "->" + groupId);
 		}
 		if (gav.getVersion() == null) {
 			gav.setVersion(version);
 			.debug("Update " + gav.getArtifactId() + "->" + version);
 		}
 		Enumeration<?> e = node.children();
 		while (e.hasMoreElements()) {
 			fillInGavs(child);
 		}
 	}
 
 	public void updateBuildInfo(DefaultMutableTreeNode nodeBuildTag buildTagTagStyle tagStyleint buildNumber) {
 		Project project = (Projectnode.getUserObject();
 		project.setBuildTag(buildTag);
 		GAV oldGav = project.getGav();
 		String newVersion = getNewVersion(oldGav.getVersion(), buildNumberbuildTag.getSourceRevision(), tagStyle);
 		GAV newGav = new GAV();
 		newGav.setGroupId(oldGav.getGroupId());
 		newGav.setArtifactId(oldGav.getArtifactId());
 		newGav.setVersion(newVersion);
 		project.setNewGav(newGav);
 		.info("GAV Update - [" + toString(oldGav) + "->" + newVersion + "]");
 	}
 
 	public void updateBuildInfo(List<DefaultMutableTreeNodenodesList<BuildTagmoduleTagsList<MappingmappingsTagStyle tagStyleint buildNumber) {
 		for (int i = 0; i < mappings.size(); i++) {
 			Mapping mapping = mappings.get(i);
 			BuildTag moduleTag = moduleTags.get(i);
 			DefaultMutableTreeNode node = findNode(nodesmapping.getModule());
 			updateBuildInfo(nodemoduleTagtagStylebuildNumber);
 		}
 	}
 
 	protected DefaultMutableTreeNode findNode(List<DefaultMutableTreeNodenodesString artifactId) {
 		for (DefaultMutableTreeNode node : nodes) {
 			Project project = (Projectnode.getUserObject();
 			if (project.getGav().getArtifactId().equals(artifactId)) {
 				return node;
 			}
 		}
 		throw new IllegalStateException("Unable to locate " + artifactId);
 	}
 
 	public List<BuildTaggetBuildTags(Properties propertiesList<SVNExternalexternalsList<MappingmappingsTagStyle tagStyleint buildNumber) {
 		Collections.sort(externals);
 		Collections.sort(mappings);
 		List<BuildTagbuildTags = new ArrayList<BuildTag>();
 		for (int i = 0; i < externals.size(); i++) {
 			SVNExternal external = externals.get(i);
 			Mapping mapping = mappings.get(i);
 			BuildTag buildTag = getBuildTag(propertiesexternalmappingtagStylebuildNumber);
 			buildTags.add(buildTag);
 		}
 		return buildTags;
 	}
 
 	public BuildTag getBuildTag(File workingCopyGAV gavTagStyle tagStyleint buildNumber) {
 		String sourceUrl = .getUrl(workingCopy);
 		long sourceRevision = .getLastRevision(workingCopy);
 		String version = gav.getVersion();
 
 		String tag = getTag(sourceUrlversiongav.getArtifactId(), buildNumbersourceRevisiontagStyle);
 
 		BuildTag buildTag = new BuildTag();
 		buildTag.setSourceUrl(sourceUrl);
 		buildTag.setSourceRevision(sourceRevision);
 		buildTag.setTagUrl(tag);
 		return buildTag;
 	}
 
 	public BuildTag getBuildTag(Properties propertiesSVNExternal externalMapping mappingTagStyle tagStyleint buildNumber) {
 		File workingCopy = external.getWorkingCopyPath();
 		String sourceUrl = .getUrl(workingCopy);
 		long sourceRevision = .getLastRevision(workingCopy);
 		String version = properties.getProperty(mapping.getVersionProperty());
 		String tag = getTag(sourceUrlversionmapping.getModule(), buildNumbersourceRevisiontagStyle);
 
 		BuildTag buildTag = new BuildTag();
 		buildTag.setSourceUrl(sourceUrl);
 		buildTag.setSourceRevision(sourceRevision);
 		buildTag.setTagUrl(tag);
 		return buildTag;
 	}

Assuming version is in the form 1.0.0-beta-SNAPSHOT, this method returns 1.0.0-beta-r3201 when TagStyle=REVISION, 1.0.0-beta-build-187 when TagStyle=BUILDNUMBER, and 1.0.0-beta when TagStyle=RELEASE
 
 	public String getNewVersion(String versionint buildNumberlong revisionTagStyle tagStyle) {
 		String trimmed = trimSnapshot(version);
 		switch (tagStyle) {
 		case :
 			return trimmed + "-r" + revision;
 		case :
 			return trimmed + "-build-" + buildNumber;
 		case :
 			return trimmed;
 		default:
 			throw new IllegalArgumentException(tagStyle + " is unknown");
 		}
 	}

Assuming version is in the form 1.0.0-beta-SNAPSHOT, this method will increment the 3rd digit by 1, and return 1.0.1-beta-SNAPSHOT
 
 	public String getNextVersion(String version) {
 		if (!version.contains()) {
 			throw new IllegalArgumentException(version + " is not a " + );
 		}
 		Version v = VersionUtils.getVersion(version);
 
 		String qualifier = v.getQualifier();
 		
 		if (qualifier != null && !qualifier.isEmpty()) {
 			String qualifierParts[] = qualifier.split();
 
 			if (qualifierParts.length > 0) {
 
 				StringBuilder nextQualifer = new StringBuilder();
 
 						qualifierParts[0])) {
 
 					// founders release qualifier is present.
 					if (qualifierParts.length == 2) {
 						// founders release - milestone or release candidate
 						nextQualifer.append(qualifierParts[0]);
 						nextQualifer.append();
 
 								qualifierParts[1])) {
 							// milestone
 
 							String nextMilestone = incrementQualifier(
 									qualifierParts[1]);
 
 							nextQualifer.append(nextMilestone);
 								qualifierParts[1])) {
 							// release candidate
 							String nextReleaseCandidate = incrementQualifier(
 									qualifierParts[1]);
 
 							nextQualifer.append(nextReleaseCandidate);
 
 						} else {
 							// invalid minor qualifier
 									"invalid minor qualifier: "
 											+ qualifierParts[1]);
 						}
 
 						v.setQualifier(nextQualifer.toString());
 					} else {
 						// only contains the main qualifier
 
 						String nextMajorQualifer = incrementQualifier(
 								qualifierParts[0]);
 
 						v.setQualifier(nextMajorQualifer);
 					}
 
 				} else {
 
 					// invalid major qualifier
 							"invalid major qualifier: " + qualifierParts[0]);
 				}
 			} 
 
 		}
 		else {
 			Integer oldIncremental = new Integer(v.getIncremental());
 			Integer newIncremental = oldIncremental + 1;
 			v.setIncremental(newIncremental.toString());
 		}
 		
 		StringBuilder sb = new StringBuilder();
 		sb.append(v.getMajor());
 		sb.append(".");
 		sb.append(v.getMinor());
 		sb.append(".");
 		if (!StringUtils.isBlank(v.getQualifier())) {
 		}
 		
 		return sb.toString();
 	}
 
 	private String incrementQualifier(String targetPrefixString qualifier) {
 	
 		// increment this part
 		if (qualifier.startsWith(targetPrefix)) {
 
 			String token = "";
 			try {
 				token = qualifier.substring(targetPrefix.length());
 				Integer oldVersion = new Integer(token);
 				Integer newVersion = oldVersion + 1;
 
 				return targetPrefix + newVersion;
 			} catch (NumberFormatException e) {
 				
 				throw new RuntimeException("failed to convert " + token + " suffix of " + qualifier + "into an Integer"e);
 			}
 
 		} else {
 			throw new IllegalArgumentException("'" + qualifier
 					+ "' does not contain a part starting with '"
 					+ targetPrefix);
 		}
 			
 	}

A main qualifier is a Founders Release FR[0-9]+
 
 	protected boolean isKnownMainQualifier (String qualifier) {
 	}

A sub qualifier is a milestone M[0-9]+ or release candidate RC[0-9]+
 
 	protected boolean isKnownSubQualifier(String qualifier) {
 		
 			return true;
 		else
 			return false;
 		
 	}
 
 
 	private boolean qualifierContainsVersionedPrefix(String targetPrefixString qualifier) {		
 		
 		if (StringUtils.isBlank(qualifier)) {
 			return false;
 		} 
 		else if (qualifier.length() < targetPrefix.length()) {
 			return false;
 		}
 		else {
 			if (qualifier.toLowerCase().startsWith(targetPrefix.toLowerCase())) {
 		
 				try {
 					String suffix = StringUtils.substring(qualifier,
 					targetPrefix.length());
 					Integer.parseInt(suffix);
 				} catch (NumberFormatException e) {
 		
 					.warn("'" + qualifier
 							+ "' does not contain a valid numeric suffix");
 		
 					return false;
 				}
 		
 			}
 			else {
 				return false;
 			}
 		}
 		return true;
 	}
 
 	protected boolean isDigit(char c) {
 		for (char digit : ) {
 			if (c == digit) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	public String getTag(String urlString versionString artifactIdint buildNumberlong revisionTagStyle tagStyle) {
 		switch (tagStyle) {
 		case :
 			return getRevisionTag(urlversionartifactIdrevision);
 		case :
 			return getBuildNumberTag(urlversionartifactIdbuildNumber);
 		case :
 			return getReleaseTag(urlversionartifactId);
 		default:
 			throw new IllegalArgumentException(tagStyle + " is unknown");
 		}
 	}
 
 	public int getBuildNumber(MavenProject projectString buildNumberProperty) {
 		Properties properties = .getMavenProperties(project);
 		String buildNumber = properties.getProperty(buildNumberProperty);
 		if (StringUtils.isBlank(buildNumber)) {
 			.warn(buildNumberProperty + " is blank");
 			return 0;
 		} else {
 			return new Integer(buildNumber);
 		}
 	}