Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  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.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;
	}
	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) {
	}
	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 count = 0;
		for (Mapping mapping : mappings) {
			String key = mapping.getVersionProperty();
			String value = properties.getProperty(key);
			if (StringUtils.isBlank(value)) {
				if (count++ != 0) {
					sb.append(", ");
				}
				sb.append(key);
			}
		}
		if (sb.length() != 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