Java tutorial
/******************************************************************************* * (c) Copyright 2016 Hewlett-Packard Development Company, L.P. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Apache License v2.0 which accompany this distribution. * * The Apache License is available at * http://www.apache.org/licenses/LICENSE-2.0 * *******************************************************************************/ package io.cloudslang.lang.enforcer; import org.apache.maven.enforcer.rule.api.EnforcerRule; import org.apache.maven.enforcer.rule.api.EnforcerRuleException; import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; import org.apache.maven.plugin.logging.Log; import org.apache.maven.project.MavenProject; import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException; import java.io.File; import java.io.IOException; import java.util.Iterator; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import static java.lang.String.format; import static java.lang.String.valueOf; import static java.nio.charset.StandardCharsets.UTF_8; import static java.nio.file.Files.isRegularFile; import static java.nio.file.LinkOption.NOFOLLOW_LINKS; import static org.apache.commons.io.FileUtils.iterateFiles; import static org.apache.commons.io.FileUtils.readFileToString; import static org.apache.commons.lang3.StringUtils.countMatches; public class SpringCleansingRule implements EnforcerRule { private static final String JAVA = "java"; private static final String OPTIONAL_SPACER = "(\\s)*"; private static final String REGEX_DOT = "\\."; private static final String OPTIONAL_STATIC = "(static )?"; private static final String ORG = "org"; private static final String SPRINGFRAMEWORK = "springframework"; private static final String SPACER_DOT_SPACER = OPTIONAL_SPACER + REGEX_DOT + OPTIONAL_SPACER; private static final String regexImport = "import " + OPTIONAL_STATIC + OPTIONAL_SPACER + ORG + SPACER_DOT_SPACER + SPRINGFRAMEWORK + "[^;]+" + ";"; private static final Pattern patternImport = Pattern.compile(regexImport); private static final String regexCodeLine = OPTIONAL_SPACER + ORG + OPTIONAL_SPACER + REGEX_DOT + OPTIONAL_SPACER + SPRINGFRAMEWORK + "(.|\\s)+;"; private static final Pattern patternCodeLine = Pattern.compile(regexCodeLine); private static final String STARTED_SCANNING_ORG_SPRINGFRAMEWORK = "Scanning file for org.springframework " + "in file '%s'"; private static final String FINISHED_SCANNING_ORG_SPRINGFRAMEWORK = "Finished scanning for org.springframework " + "in file '%s'"; private static final String FOUND_USAGE_OF_ORG_SPRINGFRAMEWORK_IN_IMPORT_AT_LINE = "Found usage of " + "org.springframework in import at line "; private static final String FOUND_USAGE_OF_ORG_SPRINGFRAMEWORK_IN_CODE_FRAGMENT_AT_LINE = "Found usage of " + "org.springframework in code fragment at line "; private static final String CONTEXT = "context"; private static final String ANNOTATION = "annotation"; private static final String CONFIGURATION = "Configuration"; private static final String SPRING_CONFIGURATION_CLASS = OPTIONAL_SPACER + ORG + SPACER_DOT_SPACER + SPRINGFRAMEWORK + SPACER_DOT_SPACER + CONTEXT + SPACER_DOT_SPACER + ANNOTATION + SPACER_DOT_SPACER + CONFIGURATION; private static final Pattern patternConfigurationClass = Pattern.compile(SPRING_CONFIGURATION_CLASS); private static final String FOUND_UNWANTED_OCCURRENCE_OF_ORG_SPRINGFRAMEWORK = "Found unwanted occurrence of " + "org.springframework at line %d in source '%s'"; private static final String IN_SOURCE = " in source '"; private static final String NEW_LINE = "\n"; /** * Simple param. This rule will fail if the value is true. */ private boolean shouldFail = false; public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException { Log log = helper.getLog(); try { // get the various expressions out of the helper. MavenProject project = (MavenProject) helper.evaluate("${project}"); // MavenSession session = (MavenSession) helper.evaluate("${session}"); // String target = (String) helper.evaluate("${project.build.directory}"); // String artifactId = (String) helper.evaluate("${project.artifactId}"); // ArtifactResolver resolver = (ArtifactResolver) helper.getComponent(ArtifactResolver.class); // RuntimeInfo rti = (RuntimeInfo) helper.getComponent(RuntimeInfo.class); List compileSourceRoots = project.getCompileSourceRoots(); for (Object compileSourceRoot : compileSourceRoots) { String path = (String) compileSourceRoot; applyForJavaSourcesInRoot(path, log); } } catch (ExpressionEvaluationException e) { throw new EnforcerRuleException("Unable to lookup an expression " + e.getLocalizedMessage(), e); } } /** * If your rule is cacheable, you must return a unique id when parameters or conditions * change that would cause the result to be different. Multiple cached results are stored * based on their id. * <p> * The easiest way to do this is to return a hash computed from the values of your parameters. * <p> * If your rule is not cacheable, then the result here is not important, you may return anything. */ public String getCacheId() { //no hash on boolean...only parameter so no hash is needed. return "" + this.shouldFail; } /** * This tells the system if the results are cacheable at all. Keep in mind that during * forked builds and other things, a given rule may be executed more than once for the same * project. This means that even things that change from project to project may still * be cacheable in certain instances. */ public boolean isCacheable() { return false; } /** * If the rule is cacheable and the same id is found in the cache, the stored results * are passed to this method to allow double checking of the results. Most of the time * this can be done by generating unique ids, but sometimes the results of objects returned * by the helper need to be queried. You may for example, store certain objects in your rule * and then query them later. */ public boolean isResultValid(EnforcerRule arg0) { return false; } private boolean isSpringConfigurationAnnotatedClass(final String contents) { Matcher matcher = patternConfigurationClass.matcher(contents); return matcher.find(); } private void applyForJavaSourcesInRoot(final String path, final Log log) throws EnforcerRuleException { Iterator<File> fileIterator = iterateFiles(new File(path), new String[] { JAVA }, true); while (fileIterator.hasNext()) { File source = fileIterator.next(); if (isRegularFile(source.toPath(), NOFOLLOW_LINKS)) { if (log.isDebugEnabled()) { log.debug(format(STARTED_SCANNING_ORG_SPRINGFRAMEWORK, source.getAbsolutePath())); } try { String contents = readFileToString(source, UTF_8.displayName()); if (isSpringConfigurationAnnotatedClass(contents)) { log.info(format("Skipping verification for Spring configuration class in file '%s'", source.getAbsolutePath())); continue; } // At this point it is clear this is a regular Java class that is not a Spring Configuration class // and just validate we don't have org.springframework in it findMatchesUsingPattern(source, log, contents, patternImport, FOUND_USAGE_OF_ORG_SPRINGFRAMEWORK_IN_IMPORT_AT_LINE); findMatchesUsingPattern(source, log, contents, patternCodeLine, FOUND_USAGE_OF_ORG_SPRINGFRAMEWORK_IN_CODE_FRAGMENT_AT_LINE); } catch (IOException ignore) { log.error(format("Could not process file '%s'", source)); } if (log.isDebugEnabled()) { log.debug(format(FINISHED_SCANNING_ORG_SPRINGFRAMEWORK, source.getAbsolutePath())); } } } } private void findMatchesUsingPattern(final File javaFile, final Log log, final String contents, final Pattern pattern, String message) throws EnforcerRuleException { Matcher matcherImportForFile = pattern.matcher(contents); if (matcherImportForFile.find()) { int lineNumber = findLineNumber(contents.substring(0, matcherImportForFile.start())); log.info(format(FOUND_UNWANTED_OCCURRENCE_OF_ORG_SPRINGFRAMEWORK, lineNumber, javaFile.getAbsolutePath())); if (shouldFail) { throw new EnforcerRuleException( message + valueOf(lineNumber) + IN_SOURCE + javaFile.getAbsolutePath() + "'"); } } } private int findLineNumber(String contents) { return countMatches(contents, NEW_LINE) + 1; } }