Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright 2011-2012 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.List;
 import java.util.Map;
 
 
 
 public class MojoHelper {
 	private static final Logger logger = LoggerFactory.getLogger(MojoHelper.class);
 	private static final String MAVEN_SNAPSHOT_TOKEN = "SNAPSHOT";
 	SVNUtils svnUtils = SVNUtils.getInstance();
 	POMUtils pomUtils = new POMUtils();
 	NumberFormat nf = NumberFormat.getInstance();
 
 	protected static MojoHelper instance;
 
 	protected MojoHelper() {
 		super();
 	}
 
 	public synchronized static MojoHelper getInstance() {
 		if ( == null) {
 			 = new MojoHelper();
 		}
 		return ;
 	}
 
 	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();
		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();
		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();
	}
	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;
	}
	}
	}
	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) {
		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 commitTagChanges(File tagDirList<SVNExternalexternalsString msg) {
		List<FileworkingCopyPaths = new ArrayList<File>();
		workingCopyPaths.add(tagDir);
		for (SVNExternal external : externals) {
			String path = tagDir.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 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();
			childProject.getParent().setVersion(getVersion(node));
			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;
	}
		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) {
	}
		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);
		}
	}
		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;
	}
	public String getNewVersion(String versionint buildNumberlong revisionTagStyle tagStyle) {
		String trimmed = trimSnapshot(version);
		switch (tagStyle) {
		case :
			return trimmed + "-r" + revision;
			return trimmed + "-build-" + buildNumber;
		default:
			throw new IllegalArgumentException(tagStyle + " is unknown");
		}
	}
	public String getTag(String urlString versionString artifactIdint buildNumberlong revisionTagStyle tagStyle) {
		switch (tagStyle) {
		case :
			return getRevisionTag(urlversionartifactIdrevision);
			return getBuildNumberTag(urlversionartifactIdbuildNumber);
		default:
			throw new IllegalArgumentException(tagStyle + " is unknown");
		}
	}
	public int getBuildNumber(MavenProject projectString buildNumberProperty) {
		String buildNumber = properties.getProperty(buildNumberProperty);
		if (StringUtils.isBlank(buildNumber)) {
			.warn(buildNumberProperty + " is blank");
			return 0;
else {
			return new Integer(buildNumber);
		}
	}
	public String getBuildNumberTag(String urlString versionString artifactIdint buildNumber) {
		sb.append(getBaseTag(urlversionartifactId));
		sb.append("/");
		sb.append("build-" + buildNumber);
		return sb.toString();
	}
	public String getRevisionTag(String urlString versionString artifactIdlong revision) {
		sb.append(getBaseTag(urlversionartifactId));
		sb.append("/");
		sb.append("r" + revision);
		return sb.toString();
	}
	protected String getBaseTag(String urlString versionString artifactId) {
		String tagBase = .getTagBase(url);
		if (StringUtils.isBlank(tagBase)) {
			throw new IllegalArgumentException("Unable to calculate tag base from [" + url + "]");
		}
		Version v = parseVersion(version);
		String trimmed = trimSnapshot(version);
		sb.append(tagBase);
		sb.append("/");
		sb.append("builds");
		sb.append("/");
		sb.append(artifactId);
		sb.append("-");
		sb.append(".");
		sb.append("/");
		sb.append(trimmed);
		return sb.toString();
	}
	public void validate(MavenProject projectList<SVNExternalexternalsList<Mappingmappings) {
		validate(externalsmappings);
		validate(projectmappings);
		validateProjectModules(projectexternals);
	}
	public void validateProjectModules(MavenProject projectList<SVNExternalexternals) {
		List<Stringmodules = project.getModules();
		if (isEmpty(modules) && isEmpty(externals)) {
			return;
else if (isEmpty(externals) && !isEmpty(modules)) {
			throw new IllegalArgumentException("No externals detected but " + modules.size() + " modules were detected");
else if (!isEmpty(externals) && isEmpty(modules)) {
			throw new IllegalArgumentException(externals.size() + " externals were detected but no modules were detected");
else if (externals.size() != modules.size()) {
			throw new IllegalArgumentException("Mismatch. " + externals.size() + " externals were detected. " + modules.size() + " modules were detected");
		}
		Collections.sort(modules);
		Collections.sort(externals);
		for (int i = 0; i < modules.size(); i++) {
			String module1 = modules.get(i);
			String module2 = externals.get(i).getPath();
			if (!module1.equals(module2)) {
				throw new IllegalArgumentException("Mismatch. " + module1 + " <> " + module2);
			}
		}
	}
	public void validate(List<SVNExternalexternalsList<Mappingmappings) {
		if (isEmpty(externals) && isEmpty(mappings)) {
			return;
else if (isEmpty(externals) && !isEmpty(mappings)) {
			throw new IllegalArgumentException("No externals detected but " + mappings.size() + " mappings were supplied");
else if (!isEmpty(externals) && isEmpty(mappings)) {
			throw new IllegalArgumentException(externals.size() + " externals were detected but no mappings were supplied");
else if (externals.size() != mappings.size()) {
			throw new IllegalArgumentException("Mismatch. " + externals.size() + " externals were detected. " + mappings.size() + " mappings were supplied");
		}
		for (SVNExternal external : externals) {
			File workingCopy = external.getWorkingCopyPath();
			if (!workingCopy.exists()) {
				throw new IllegalArgumentException(workingCopy.getAbsolutePath() + " does not exist");
			}
		}
	}
	public void validate(MavenProject projectList<Mappingmappings) {
		validate(project.getProperties(), mappings);
		validateModules(project.getModules(), mappings);
	}
	public void validateModules(List<StringmodulesList<Mappingmappings) {
		Collections.sort(mappings);
		Collections.sort(modules);
		if (isEmpty(modules) && isEmpty(mappings)) {
			return;
else if (isEmpty(modules) && !isEmpty(mappings)) {
			throw new IllegalArgumentException("No modules detected but " + mappings.size() + " mappings were supplied");
else if (!isEmpty(modules) && isEmpty(mappings)) {
			throw new IllegalArgumentException(modules.size() + " modules were detected but no mappings were supplied");
else if (modules.size() != mappings.size()) {
			throw new IllegalArgumentException("Mismatch. " + modules.size() + " modules were detected. " + mappings.size() + " mappings were supplied");
		}
		for (int i = 0; i < modules.size(); i++) {
			String module1 = modules.get(i);
			String module2 = mappings.get(i).getModule();
			if (!module1.equals(module2)) {
				throw new IllegalArgumentException("Mismatch. " + module1 + " <> " + module2);
			}
		}
	}
	public void validate(Properties propertiesList<Mappingmappings) {
		if (isEmpty(mappings)) {
			return;
		}
		int missingCount = 0;
		for (Mapping mapping : mappings) {
			String key = mapping.getVersionProperty();
			String value = properties.getProperty(key);
			if (StringUtils.isBlank(value)) {
				if (missingCount++ != 0) {
					sb.append(", ");
				}
				sb.append(key);
			}
		}
		if (missingCount != 0) {
			throw new IllegalArgumentException("Missing values for [" + sb.toString() + "]");
		}
	}
	public String trimSnapshot(String version) {
		if (version.toUpperCase().endsWith("-" + )) {
			int length = .length() + 1;
			return StringUtils.left(versionversion.length() - length);
else {
			return version;
		}
	}
	public boolean isEmpty(Collection<?> c) {
		return c == null || c.isEmpty();
	}
	protected Version parseVersion(String s) {
		boolean snapshot = s.toUpperCase().endsWith("-" + );
		Version version = new Version();
		version.setSnapshot(snapshot);
		String[] tokens = StringUtils.split(s".-");
		if (tokens.length > 0) {
			version.setMajor(tokens[0]);
		}
		if (tokens.length > 1) {
			version.setMinor(tokens[1]);
		}
		if (tokens.length > 2) {
			version.setIncremental(tokens[2]);
		}
		String qualifier = getQualifier(tokens);
		version.setQualifier(qualifier);
		return version;
	}
	protected String getQualifier(String[] tokens) {
		if (tokens.length <= 3) {
			return null;
		}
		for (int i = 3; i < tokens.lengthi++) {
				break;
			}
			if (i != 3) {
				sb.append("-");
			}
			sb.append(tokens[i]);
		}
		return sb.toString();
	}
	public void write(File fileString data) {
		try {
			FileUtils.write(filedata);
catch (IOException e) {
			throw new IllegalStateException(e);
		}
	}
	public void deleteDirectory(File dir) {
		try {
			FileUtils.deleteDirectory(dir);
catch (IOException e) {
			throw new IllegalStateException(e);
		}
	}
	public String read(File file) {
		try {
			return FileUtils.readFileToString(file);
catch (IOException e) {
			throw new IllegalStateException(e);
		}
	}
New to GrepCode? Check out our FAQ X