Java tutorial
/* * Copyright 2011 - Alistair Rutherford - www.netthreads.co.uk * * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0 * * 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 com.netthreads.mavenize; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.LinkedList; import java.util.List; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.Predicate; import org.apache.commons.io.DirectoryWalker; import org.apache.commons.io.FileUtils; import org.apache.commons.io.filefilter.DirectoryFileFilter; import org.apache.commons.io.filefilter.FileFilterUtils; import org.apache.commons.io.filefilter.IOFileFilter; import org.apache.maven.model.Model; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.netthreads.mavenize.model.ProjectFiles; import com.netthreads.mavenize.pom.PomGenerator; import com.netthreads.mavenize.pom.PomGeneratorFactory; import com.netthreads.mavenize.project.NetbeansJavaProjectType; import com.netthreads.mavenize.project.ProjectType; import com.netthreads.mavenize.project.ProjectTypeFactory; /** * Mavenize * * Attempts to convert an existing project into a Maven project by splitting the * source code and resources into the relevant dirs and making a stab at the pom * if you specify a source project type i.e. "netbeans". * * The only specific types currently implemented are: * * - Normal java project "default". - NetBeans java module netbeans. * */ @SuppressWarnings("unchecked") public class Mavenize { private static Logger logger = LoggerFactory.getLogger(ProjectFileFinder.class); private static final String APP_MESSAGE = "Mavenize version 1.0.0\nAlistair Rutherford, www.netthreads.co.uk, 2011.\nLicensed under the Apache License, Version 2.0.\n\n"; private static final String ARGS_MESSAGE = "Arguments: -i<source dir> -o<target dir> -t<project type>[Optional] -v<version>[Optional] -p<packaging>[Optional]"; private static final String TEXT_SRC = "src"; private static final String TEXT_MAIN = "main"; private static final String TEXT_TEST = "test"; private static final String TEXT_JAVA = "java"; private static final String TEXT_RESOURCES = "resources"; private static final String DIR_MAIN_JAVA = "/" + TEXT_MAIN + "/" + TEXT_JAVA; private static final String DIR_MAIN_RESOURCES = "/" + TEXT_MAIN + "/" + TEXT_RESOURCES; private static final String DIR_TEST_JAVA = "/" + TEXT_TEST + "/" + TEXT_JAVA; private static final String DIR_TEST_RESOURCES = "/" + TEXT_TEST + "/" + TEXT_RESOURCES; private static final String ARG_INPUT = "-i"; private static final String ARG_OUTPUT = "-o"; private static final String ARG_TYPE = "-t"; private static final String ARG_VERSION = "-v"; private static final String ARG_PACKAGING = "-p"; private MavenizeListener mavenizeListener; /** * Construct mavenize instance. * * @param mavenizeListener */ public Mavenize(MavenizeListener mavenizeListener) { this.mavenizeListener = mavenizeListener; } /** * Main method. * * @param args */ public static void main(String[] args) { if (args.length > 1) { String sourcePath = ""; String targetPath = ""; String projectTypeName = ProjectType.Types.DEFAULT.toString(); String version = PomGenerator.DEFAULT_VERSION; String packaging = PomGenerator.PACKAGE_TYPES[0]; boolean isInput = false; boolean isOutput = false; for (String arg : args) { try { if (arg.startsWith(ARG_INPUT)) { sourcePath = arg.substring(ARG_INPUT.length()); isInput = true; } else if (arg.startsWith(ARG_OUTPUT)) { targetPath = arg.substring(ARG_OUTPUT.length()); isOutput = true; } else if (arg.startsWith(ARG_TYPE)) { projectTypeName = arg.substring(ARG_TYPE.length()); } else if (arg.startsWith(ARG_VERSION)) { version = arg.substring(ARG_VERSION.length()); } else if (arg.startsWith(ARG_PACKAGING)) { packaging = arg.substring(ARG_PACKAGING.length()); } } catch (Exception e) { logger.error("Can't process argument, " + arg + ", " + e.getMessage()); } } // Project type. ProjectType projectType = ProjectTypeFactory.instance().getProjectType(projectTypeName); // Execute conversion. try { if (isInput && isOutput) { if (!sourcePath.equals(targetPath)) { Mavenize mvnGather = new Mavenize(null); mvnGather.process(sourcePath, targetPath, projectType, version, packaging); } else { throw new MavenizeException("Input and output directories cannot be the same."); } } else { throw new MavenizeException("You must specify input and output directories"); } } catch (MavenizeException e) { logger.error("Application error, " + e); } catch (IOException ioe) { logger.error("Application error, " + ioe); } } else { System.out.println(APP_MESSAGE + ARGS_MESSAGE); } } /** * Main process method. * * @param sourcePath * @param targetPath * @throws IOException */ public void process(String sourcePath, String targetPath, ProjectType projectType, String version, String packaging) throws IOException { // Generate records for all source parent, child and target directories. List<ProjectFiles> sourceFiles = buildProjectFiles(projectType, sourcePath, targetPath); logger.info("Source Files, " + sourceFiles.size()); List<ProjectFiles> resourceFiles = buildResourceFiles(projectType, sourcePath, targetPath); logger.info("Resource Files, " + resourceFiles.size()); logger.info("Generate directory structure, " + sourceFiles.size()); // Generate Maven directory structure makeMavenDirs(projectType, sourceFiles); logger.info("Copy main files."); // Copy over project files. insertMainProjectFiles(projectType, sourceFiles, resourceFiles); logger.info("Copy test files."); // Copy over test files. insertTestProjectFiles(projectType, sourceFiles, resourceFiles); logger.info("Generate pom(s)."); // Generate pom(s). insertProjectPom(projectType, version, packaging, sourceFiles); logger.info("Done."); } /** * Make Maven directory structure. * * @param projectType * The conversion project type. * @param projects * The profile files structure. * * @throws IOException */ private void makeMavenDirs(ProjectType projectType, List<ProjectFiles> projects) throws IOException { logger.info("Creating Maven directory structure."); for (ProjectFiles project : projects) { File targetSrc = project.getTargetSrc(); String targetSrcPath = targetSrc.getAbsolutePath(); if (isValidSourceDir(projectType, targetSrcPath)) { // Create directories createDir(DIR_MAIN_JAVA, targetSrcPath); createDir(DIR_MAIN_RESOURCES, targetSrcPath); createDir(DIR_TEST_JAVA, targetSrcPath); createDir(DIR_TEST_RESOURCES, targetSrcPath); if (mavenizeListener != null) { mavenizeListener.createDirectories(project); } } } } /** * Will copy project files to main area. * * @param projectType * @param sourceFiles * @param resourceFiles */ private void insertMainProjectFiles(ProjectType projectType, List<ProjectFiles> sourceFiles, List<ProjectFiles> resourceFiles) throws IOException { copyMainFiles(projectType, DIR_MAIN_JAVA, sourceFiles); copyMainFiles(projectType, DIR_MAIN_RESOURCES, resourceFiles); } /** * Will copy any test files into test area. * * @param projectType * @param sourceFiles * @param resourceFiles */ private void insertTestProjectFiles(ProjectType projectType, List<ProjectFiles> sourceFiles, List<ProjectFiles> resourceFiles) throws IOException { copyTestFiles(projectType, DIR_TEST_JAVA, sourceFiles); copyTestFiles(projectType, DIR_TEST_RESOURCES, resourceFiles); } /** * Attempt to generate pom. * * We can't do much for a general java project but for specific types it * might be possible to glean something from the project definition files. * * @param projectType * @param projectFiles * * @throws IOException */ private void insertProjectPom(ProjectType projectType, String version, String packaging, List<ProjectFiles> projectFiles) throws IOException { PomGenerator pomGenerator = PomGeneratorFactory.instance().getGenerator(projectType); // For each project generate an appropriate pom file. for (ProjectFiles project : projectFiles) { File targetSrc = project.getTargetSrc(); String targetSrcPath = targetSrc.getAbsolutePath(); // If is a valid source directory according to type. if (isValidSourceDir(projectType, targetSrcPath)) { Model model = pomGenerator.generate(project, version, packaging); if (mavenizeListener != null) { mavenizeListener.generatePom(projectType, project, model); } } } } /** * Copy test files. * * @param projectType * @param subDir * @param projectFiles * * @throws IOException */ private void copyMainFiles(ProjectType projectType, String subDir, List<ProjectFiles> projectFiles) throws IOException { for (ProjectFiles project : projectFiles) { File targetSrc = project.getTargetSrc(); String targetSrcPath = targetSrc.getAbsolutePath(); // If is a valid source direcory according to type. if (isValidSourceDir(projectType, targetSrcPath)) { copyFiles(targetSrcPath, subDir, project); if (mavenizeListener != null) { mavenizeListener.copyFiles(project, subDir); } } } } /** * Copy test files. * * @param projectType * @param subDir * @param projectFiles * * @throws IOException */ private void copyTestFiles(ProjectType projectType, String subDir, List<ProjectFiles> projectFiles) throws IOException { // If not a specific type of project then don't bother. ProjectType.Types type = projectType.getType(); if (type != ProjectType.Types.DEFAULT) { for (ProjectFiles project : projectFiles) { File sourceSrc = project.getSourceSrc(); String sourceSrcPath = sourceSrc.getAbsolutePath(); // If is source of tests according to project type. if (isTestDir(projectType, sourceSrcPath)) { File targetSrc = project.getTargetSrc(); String targetSrcPath = targetSrc.getAbsolutePath(); // Adjust according to target type. String adjustedTestPath = adjustTestDir(projectType, targetSrcPath); copyFiles(adjustedTestPath, subDir, project); if (mavenizeListener != null) { mavenizeListener.copyFiles(project, subDir); } } } } } /** * Adjust the supplied directory to Maven style path. * */ private String adjustTestDir(ProjectType projectType, String sourceDir) { String adjustedDir = sourceDir; switch (projectType.getType()) { // If netbeans then ignore the test/unit directory case NETBEANS: int index = sourceDir.length() - NetbeansJavaProjectType.TEST_DIR.length(); adjustedDir = sourceDir.substring(0, index) + TEXT_SRC; break; default: break; } return adjustedDir; } /** * Copy files to target. * * @param targetPath * @param targetPathType * @param projectFiles */ private void copyFiles(String targetSrcPath, String subDir, ProjectFiles projectFiles) throws IOException { List<File> files = projectFiles.getFiles(); for (File file : files) { String sourceSrcPath = projectFiles.getSourceSrc().getAbsolutePath(); String filePath = file.getAbsolutePath(); String partial = filePath.substring(sourceSrcPath.length()); String targetPath = targetSrcPath + subDir + partial; logger.debug("From : " + filePath + ", To :" + targetPath); FileUtils.copyFile(file, new File(targetPath), true); } } /** * Depending on the project target type test to see if we are interested in * target directory. * * @param projectType * @param sourceDirParent * * @return Directory is valid. */ private boolean isValidSourceDir(ProjectType projectType, String sourceDir) { boolean status = true; switch (projectType.getType()) { // If netbeans then ignore the test/unit directory case NETBEANS: status = !isTestDir(projectType, sourceDir); break; default: break; } return status; } /** * Checks to see if supplied directory is a test directory. * * @param projectType * @param sourceDir * * @return True is test directory for supplied project type. */ private boolean isTestDir(ProjectType projectType, String sourceDir) { boolean status = false; switch (projectType.getType()) { // If netbeans then ignore the test/unit directory case NETBEANS: int index = sourceDir.length() - NetbeansJavaProjectType.TEST_DIR.length(); String partial = sourceDir.substring(index); status = pathEquals(partial, NetbeansJavaProjectType.TEST_DIR); break; default: break; } return status; } /** * Get project source files. * * @param sourcePath * The source directory path. * @param targetPath * The target directory path. * * @return List of parent source directories and child directories. * * @throws IOException */ private List<ProjectFiles> buildProjectFiles(ProjectType projectType, String sourcePath, String targetPath) throws IOException { List<ProjectFiles> results = new LinkedList<ProjectFiles>(); IOFileFilter srcDirFilter = DirectoryFileFilter.DIRECTORY; // Create a filter for Files ending in ".txt" String suffix = projectType.getSuffix(); IOFileFilter srcFileFilter = FileFilterUtils.suffixFileFilter(suffix); // Combine the directory and file filters using an OR condition java.io.FileFilter srcFilter = FileFilterUtils.or(srcDirFilter, srcFileFilter); // Finder for all directories, no depth limit but we will limit on name. ProjectFileFinder projectFileFinder = new ProjectFileFinder(srcFilter, -1); results = projectFileFinder.find(sourcePath, targetPath, TEXT_SRC); return results; } /** * Get project resource files. * * @param sourcePath * The source directory path. * @param targetPath * The target directory path. * * @return List of parent source directories and child directories. * * @throws IOException */ private List<ProjectFiles> buildResourceFiles(ProjectType projectType, String sourcePath, String targetPath) throws IOException { List<ProjectFiles> results = new LinkedList<ProjectFiles>(); IOFileFilter resourceDirFilter = DirectoryFileFilter.DIRECTORY; // Create a filter for Files ending in ".txt" String suffix = projectType.getSuffix(); IOFileFilter resourceFileFilter = FileFilterUtils.notFileFilter(FileFilterUtils.suffixFileFilter(suffix)); // Combine the directory and file filters using an OR condition java.io.FileFilter srcFilter = FileFilterUtils.or(resourceDirFilter, resourceFileFilter); // Finder for all directories, no depth limit but we will limit on name. ProjectFileFinder projectFileFinder = new ProjectFileFinder(srcFilter, -1); results = projectFileFinder.find(sourcePath, targetPath, TEXT_SRC); return results; } /** * Create directory if it doesn't already exist. * * @param name * The directory name. * * @param directory * The parent directory file object. */ private void createDir(String name, String path) throws IOException { String dirPath = path + name; File newDir = new File(dirPath); if (!newDir.exists()) { logger.debug("Creating target directory, " + path); FileUtils.forceMkdir(newDir); } } /** * Helper method to replace the Windows type backslash with a proper path * one. * * @param path * * @return Fixed path string. */ private String fixPath(String path) { return path.replace("\\", "/"); } /** * Compare paths so that the backslashes are removed. * * @param pathA * @param pathB * * @return True if paths are equal. */ private boolean pathEquals(String pathA, String pathB) { return fixPath(pathA).equals(fixPath(pathB)); } /* * Project File Finder class. * * This class takes a target directory name and builds a list of files which * reside under that name. There can be multiple instances i.e multiple * projects. */ @SuppressWarnings("rawtypes") private class ProjectFileFinder extends DirectoryWalker { private String match; private String sourcePath; private String targetPath; private List results; /** * Takes target directory name and filter object. * * @param target * If this is null then * @param fileFilter */ public ProjectFileFinder(FileFilter fileFilter, int depth) { super(fileFilter, depth); } /** * Find instances of named target directory starting at the path * specified. * * @param path * The starting directory. * @param target * The name of the target directory to search for. * * @return List of search results. * * @throws IOException */ public List find(String sourcePath, String targetPath, String match) throws IOException { this.results = new ArrayList(); this.match = match; this.sourcePath = sourcePath; this.targetPath = targetPath; File file = new File(sourcePath); walk(file, results); return results; } /** * Handle hitting a file. We look for owning project in our collection * and if we find one then add it else create a new project entry and * add it. * * @param file * @param depth * @param results * @throws IOException */ @Override protected void handleFile(File file, int depth, Collection results) throws IOException { // Look for existing entry ProjectFiles projectFiles = (ProjectFiles) CollectionUtils.find(results, new FilePredicate(file)); if (projectFiles != null) { logger.debug(projectFiles.getSourceSrc().getAbsolutePath() + ", " + file.getAbsolutePath()); projectFiles.getFiles().add(file); if (mavenizeListener != null) { mavenizeListener.addProjectFile(projectFiles, file); } } } /** * Handle finding a directory. * * @param directory * @param depth * @param results * * @return Returns true because we keep going, */ @Override protected boolean handleDirectory(File directory, int depth, Collection results) { // If we have hit "target" i.e. "src" directory then we look for // existing project, if none found then create one. if (directory.getName().equals(match)) { String name = directory.getParent(); // Look for existing entry ProjectFiles projectFiles = (ProjectFiles) CollectionUtils.find(results, new NamePredicate(name)); if (projectFiles == null) { logger.debug(directory.getAbsolutePath()); // Build target src dir to match source project String partial = directory.getAbsolutePath().substring(sourcePath.length()); String targetSrc = targetPath + "/" + partial; File target = new File(targetSrc); projectFiles = new ProjectFiles(name, directory, target); results.add(projectFiles); if (mavenizeListener != null) { mavenizeListener.addProjectFiles(projectFiles); } } } return true; } } /** * Implements Project file search predicate to find 'named' project from * collection. * */ private class NamePredicate implements Predicate { String name; public NamePredicate(String name) { this.name = name; } @Override public boolean evaluate(Object object) { ProjectFiles projectFiles = (ProjectFiles) object; boolean status = projectFiles.getName().equals(name); return status; } } /** * Implements File predicate. * */ private class FilePredicate implements Predicate { File file; public FilePredicate(File file) { this.file = file; } /** * Find a match for projects files to which the supplied File belongs. * * @param object * * @return True if found. */ @Override public boolean evaluate(Object object) { boolean status = false; ProjectFiles projectFiles = (ProjectFiles) object; String projectSourceSrc = projectFiles.getSourceSrc().getAbsolutePath(); String fileSourceSrc = file.getAbsolutePath(); int projectSourceSrcLen = projectSourceSrc.length(); int fileSourceSrcLen = fileSourceSrc.length(); if (fileSourceSrcLen > projectSourceSrcLen) { // Is file part of project src dir? String partial = fileSourceSrc.substring(0, projectSourceSrcLen); status = projectSourceSrc.equals(partial); } return status; } } }