From 9c106d3d340437710b1ff642a5a41b8b7c29a7d7 Mon Sep 17 00:00:00 2001 From: Gabor Bernat Date: Sat, 29 Aug 2015 17:37:02 +0200 Subject: [PATCH 1/2] backport project to java 7, remove java 8 only dependency durian --- build.gradle | 5 +- gradle.properties | 3 - gradle/wrapper/gradle-wrapper.properties | 4 +- .../gradle/spotless/FormatExtension.java | 217 ++++++++++++------ .../diffplug/gradle/spotless/FormatTask.java | 30 ++- .../diffplug/gradle/spotless/Formatter.java | 26 ++- .../gradle/spotless/FormatterStep.java | 49 ++-- .../gradle/spotless/FormattingOperation.java | 7 + .../spotless/FormattingOperationSupplier.java | 22 ++ .../diffplug/gradle/spotless/IndentStep.java | 56 ++--- .../gradle/spotless/LicenseHeaderStep.java | 4 +- .../diffplug/gradle/spotless/LineEnding.java | 2 +- .../gradle/spotless/SpotlessExtension.java | 28 +-- .../gradle/spotless/SpotlessPlugin.java | 41 ++-- .../spotless/java/EclipseFormatterStep.java | 38 +-- .../spotless/java/ImportSorterImpl.java | 82 ++++--- .../spotless/java/ImportSorterStep.java | 32 +-- .../gradle/spotless/java/JavaExtension.java | 60 ++++- .../gradle/spotless/EndWithNewlineTest.java | 7 +- .../gradle/spotless/FormatTaskTest.java | 34 ++- .../gradle/spotless/IndentStepTest.java | 22 +- .../spotless/LicenseHeaderStepTest.java | 22 +- .../gradle/spotless/ResourceTest.java | 57 ++--- .../diffplug/gradle/spotless/SelfTest.java | 110 +++++---- .../gradle/spotless/SimpleConsumer.java | 6 + .../spotless/TrimTrailingWhitespaceTest.java | 6 +- .../java/EclipseFormatterStepTest.java | 24 +- .../spotless/java/ImportSorterStepTest.java | 23 +- 28 files changed, 634 insertions(+), 383 deletions(-) create mode 100644 src/main/java/com/diffplug/gradle/spotless/FormattingOperation.java create mode 100644 src/main/java/com/diffplug/gradle/spotless/FormattingOperationSupplier.java create mode 100644 src/test/java/com/diffplug/gradle/spotless/SimpleConsumer.java diff --git a/build.gradle b/build.gradle index db17f9b4f1..e91fa6a201 100644 --- a/build.gradle +++ b/build.gradle @@ -49,7 +49,6 @@ configurations { dependencies { compile gradleApi() - compile "com.diffplug.durian:durian:${VER_DURIAN}" // The only dependencies we actually use embeddedJars 'p2:org.eclipse.jdt.core:3.11.0.v20150602-1242' @@ -204,3 +203,7 @@ pluginBundle { version = project.version } } + +task wrapper(type: Wrapper) { + distributionUrl = "http://services.gradle.org/distributions/gradle-2.6-all.zip" +} diff --git a/gradle.properties b/gradle.properties index 4a399bc9bf..d1dfbb5c04 100644 --- a/gradle.properties +++ b/gradle.properties @@ -9,8 +9,5 @@ VER_GRADLE=2.4 VER_JAVA=1.8 VER_BINTRAY=1.1 -# Compile -VER_DURIAN=3.1.2 - # Testing VER_JUNIT=4.12 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 7e651c9313..0cfd064e2f 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Tue May 12 11:25:05 PDT 2015 +#Sat Aug 29 16:31:54 CEST 2015 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip diff --git a/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java b/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java index 32b183daf4..242153dda0 100644 --- a/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java +++ b/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java @@ -15,6 +15,12 @@ */ package com.diffplug.gradle.spotless; +import org.gradle.api.GradleException; +import org.gradle.api.Project; +import org.gradle.api.file.FileCollection; +import org.gradle.api.internal.file.UnionFileCollection; + +import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -22,42 +28,36 @@ import java.util.Map; import java.util.regex.Pattern; -import org.gradle.api.GradleException; -import org.gradle.api.Project; -import org.gradle.api.file.FileCollection; -import org.gradle.api.internal.file.UnionFileCollection; - -import com.diffplug.common.base.Throwing; - import groovy.lang.Closure; /** Adds a `spotless{Name}Check` and `spotless{Name}Apply` task. */ public class FormatExtension { - protected final String name; - protected final SpotlessExtension root; + final String name; + private final SpotlessExtension root; + /** The steps that need to be added. */ + private final List steps = new ArrayList<>(); + /** The files that need to be formatted. */ + protected FileCollection target; - public FormatExtension(String name, SpotlessExtension root) { + public FormatExtension(final String name, final SpotlessExtension root) { this.name = name; this.root = root; root.addFormatExtension(this); } - /** The files that need to be formatted. */ - protected FileCollection target; - /** * FileCollections pass through raw. * Strings are treated as the 'include' arg to fileTree, with project.rootDir as the dir. * List are treates as the 'includes' arg to fileTree, with project.rootDir as the dir. - * Anything else gets passed to getProject().files(). + * Anything else gets passed to getProject().files(). */ - public void target(Object... targets) { + public void target(final Object... targets) { if (targets.length == 0) { this.target = getProject().files(); } else if (targets.length == 1) { this.target = parseTarget(targets[0]); } else { - if (Arrays.asList(targets).stream().allMatch(o -> o instanceof String)) { + if (areAllObjectsString(targets)) { this.target = parseTarget(Arrays.asList(targets)); } else { UnionFileCollection union = new UnionFileCollection(); @@ -69,34 +69,50 @@ public void target(Object... targets) { } } + private boolean areAllObjectsString(final Object[] targets) { + for (Object target : targets) { + if (!(target instanceof String)) { + return false; + } + } + return true; + } + @SuppressWarnings("unchecked") - private FileCollection parseTarget(Object target) { + private FileCollection parseTarget(final Object target) { if (target instanceof FileCollection) { return (FileCollection) target; } else if (target instanceof String) { Map args = new HashMap<>(); args.put("dir", getProject().getProjectDir()); - args.put("include", (String) target); + args.put("include", target); return getProject().fileTree(args); - } else if (target instanceof List && ((List) target).stream().allMatch(o -> o instanceof String)) { + } else if (isListOfString(target)) { Map args = new HashMap<>(); args.put("dir", getProject().getProjectDir()); - args.put("includes", (List) target); + args.put("includes", target); return getProject().fileTree(args); } else { return getProject().files(target); } } - /** The steps that need to be added. */ - protected List steps = new ArrayList<>(); + private boolean isListOfString(final Object target) { + if (target instanceof List) + for (Object o : ((List) target)) { + if (!(o instanceof String)) { + return false; + } + } + return true; + } /** * Adds the given custom step, which is constructed lazily for performance reasons. * * The resulting function will receive a string with unix-newlines, and it must return a string unix newlines. */ - public void customLazy(String name, Throwing.Supplier> formatterSupplier) { + protected void customLazy(String name, FormattingOperationSupplier formatterSupplier) { for (FormatterStep step : steps) { if (step.getName().equals(name)) { throw new GradleException("Multiple steps with name '" + name + "' for spotless '" + name + "'"); @@ -106,26 +122,40 @@ public void customLazy(String name, Throwing.Supplier formatter) { - custom(name, formatter::call); + private void custom(final String name, Closure formatter) { + custom(name, formatter); } /** Adds a custom step. Receives a string with unix-newlines, must return a string with unix newlines. */ - public void custom(String name, Throwing.Function formatter) { - customLazy(name, () -> formatter); + private void custom(final String name, final FormattingOperation formatter) { + customLazy(name, new FormattingOperationSupplier(formatter)); } /** Highly efficient find-replace char sequence. */ - public void customReplace(String name, CharSequence original, CharSequence after) { - custom(name, raw -> raw.replace(original, after)); + public void customReplace(final String name, final CharSequence original, final CharSequence after) { + custom(name, new FormattingOperation() { + @Override + public String apply(String raw) { + return raw.replace(original, after); + } + }); } /** Highly efficient find-replace regex. */ - public void customReplaceRegex(String name, String regex, String replacement) { - customLazy(name, () -> { - Pattern pattern = Pattern.compile(regex, Pattern.UNIX_LINES | Pattern.MULTILINE); - return raw -> pattern.matcher(raw).replaceAll(replacement); - }); + private void customReplaceRegex(final String name, final String regex, final String replacement) { + customLazy(name, new FormattingOperationSupplier(new FormattingOperation() { + Pattern pattern; + + @Override + public String apply(String raw) { + return pattern.matcher(raw).replaceAll(replacement); + } + + @Override + public void init() { + pattern = Pattern.compile(regex, Pattern.UNIX_LINES | Pattern.MULTILINE); + } + })); } /** Removes trailing whitespace. */ @@ -135,41 +165,56 @@ public void trimTrailingWhitespace() { /** Ensures that files end with a single newline. */ public void endWithNewline() { - custom("endWithNewline", raw -> { - // simplifies the logic below if we can assume length > 0 - if (raw.isEmpty()) { - return "\n"; - } - - // find the last character which has real content - int lastContentCharacter = raw.length() - 1; - char c; - while (lastContentCharacter >= 0) { - c = raw.charAt(lastContentCharacter); - if (c == '\n' || c == '\t' || c == ' ') { - --lastContentCharacter; - } else { - break; + custom("endWithNewline", new FormattingOperation() { + @Override + public String apply(String raw) { + // simplifies the logic below if we can assume length > 0 + if (raw.isEmpty()) { + return "\n"; } - } - // if it's already clean, no need to create another string - if (lastContentCharacter == -1) { - return "\n"; - } else if (lastContentCharacter == raw.length() - 2 && raw.charAt(raw.length() - 1) == '\n') { - return raw; - } else { - StringBuilder builder = new StringBuilder(lastContentCharacter + 2); - builder.append(raw, 0, lastContentCharacter + 1); - builder.append('\n'); - return builder.toString(); + // find the last character which has real content + int lastContentCharacter = raw.length() - 1; + char c; + while (lastContentCharacter >= 0) { + c = raw.charAt(lastContentCharacter); + if (c == '\n' || c == '\t' || c == ' ') { + --lastContentCharacter; + } else { + break; + } + } + + // if it's already clean, no need to create another string + if (lastContentCharacter == -1) { + return "\n"; + } else if (lastContentCharacter == raw.length() - 2 && raw.charAt(raw.length() - 1) == '\n') { + return raw; + } else { + StringBuilder builder = new StringBuilder(lastContentCharacter + 2); + builder.append(raw, 0, lastContentCharacter + 1); + builder.append('\n'); + return builder.toString(); + } } }); } /** Ensures that the files are indented using spaces. */ - public void indentWithSpaces(int tabToSpaces) { - customLazy("indentWithSpaces", () -> new IndentStep(IndentStep.Type.SPACE, tabToSpaces)::format); + private void indentWithSpaces(final int tabToSpaces) { + customLazy("indentWithSpaces", new FormattingOperationSupplier(new FormattingOperation() { + IndentStep step; + + @Override + public String apply(String raw) { + return step.format(raw); + } + + @Override + public void init() { + step = new IndentStep(IndentStep.Type.SPACE, tabToSpaces); + } + })); } /** Ensures that the files are indented using spaces. */ @@ -178,8 +223,20 @@ public void indentWithSpaces() { } /** Ensures that the files are indented using tabs. */ - public void indentWithTabs(int tabToSpaces) { - customLazy("indentWithTabs", () -> new IndentStep(IndentStep.Type.TAB, tabToSpaces)::format); + private void indentWithTabs(final int tabToSpaces) { + customLazy("indentWithTabs", new FormattingOperationSupplier(new FormattingOperation() { + IndentStep step; + + @Override + public String apply(String raw) { + return step.format(raw); + } + + @Override + public void init() { + step = new IndentStep(IndentStep.Type.TAB, tabToSpaces); + } + })); } /** Ensures that the files are indented using tabs. */ @@ -191,16 +248,40 @@ public void indentWithTabs() { * @param licenseHeader Content that should be at the top of every file * @param delimiter Spotless will look for a line that starts with this to know what the "top" is. */ - public void licenseHeader(String licenseHeader, String delimiter) { - customLazy(LicenseHeaderStep.NAME, () -> new LicenseHeaderStep(licenseHeader, delimiter)::format); + protected void licenseHeader(final String licenseHeader, final String delimiter) { + customLazy(LicenseHeaderStep.NAME, new FormattingOperationSupplier(new FormattingOperation() { + LicenseHeaderStep step; + + @Override + public String apply(String raw) { + return step.format(raw); + } + + @Override + public void init() { + step = new LicenseHeaderStep(licenseHeader, delimiter); + } + })); } /** * @param licenseHeaderFile Content that should be at the top of every file * @param delimiter Spotless will look for a line that starts with this to know what the "top" is. */ - public void licenseHeaderFile(Object licenseHeaderFile, String delimiter) { - customLazy(LicenseHeaderStep.NAME, () -> new LicenseHeaderStep(getProject().file(licenseHeaderFile), delimiter)::format); + protected void licenseHeaderFile(final Object licenseHeaderFile, final String delimiter) { + customLazy(LicenseHeaderStep.NAME, new FormattingOperationSupplier(new FormattingOperation() { + LicenseHeaderStep step; + + @Override + public String apply(String raw) { + return step.format(raw); + } + + @Override + public void init() throws IOException { + step = new LicenseHeaderStep(getProject().file(licenseHeaderFile), delimiter); + } + })); } /** Sets up a FormatTask according to the values in this extension. */ diff --git a/src/main/java/com/diffplug/gradle/spotless/FormatTask.java b/src/main/java/com/diffplug/gradle/spotless/FormatTask.java index ae30a3d2f9..4ba543b68b 100644 --- a/src/main/java/com/diffplug/gradle/spotless/FormatTask.java +++ b/src/main/java/com/diffplug/gradle/spotless/FormatTask.java @@ -15,19 +15,18 @@ */ package com.diffplug.gradle.spotless; -import java.io.File; -import java.io.IOException; -import java.nio.file.Path; -import java.util.ArrayList; -import java.util.List; -import java.util.stream.Collectors; - import org.gradle.api.DefaultTask; import org.gradle.api.GradleException; import org.gradle.api.tasks.Input; import org.gradle.api.tasks.InputFiles; import org.gradle.api.tasks.TaskAction; +import java.io.File; +import java.io.IOException; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; + public class FormatTask extends DefaultTask { @InputFiles public Iterable target; @@ -40,7 +39,9 @@ public class FormatTask extends DefaultTask { @TaskAction public void format() throws Exception { - if (target == null) { throw new GradleException("You must specify 'Iterable toFormat'"); } + if (target == null) { + throw new GradleException("You must specify 'Iterable toFormat'"); + } // combine them into the master formatter Formatter formatter = new Formatter(lineEndings, getProject().getProjectDir().toPath(), steps); @@ -65,9 +66,18 @@ private void formatCheck(Formatter formatter) throws IOException { if (!problemFiles.isEmpty()) { Path rootDir = getProject().getRootDir().toPath(); throw new GradleException("Format violations were found. Run 'gradlew " + SpotlessPlugin.EXTENSION + SpotlessPlugin.APPLY + "' to fix them.\n" - + problemFiles.stream().map(file -> " " + rootDir.relativize(file.toPath()).toString()) - .collect(Collectors.joining("\n"))); + + listOfFilePathsRelativeAsString(problemFiles, rootDir)); + } + } + + private String listOfFilePathsRelativeAsString(List problemFiles, Path rootDir) { + StringBuilder output = new StringBuilder(); + for (File file : problemFiles) { + output.append(" "); + output.append(rootDir.relativize(file.toPath()).toString()); + output.append('\n'); } + return output.toString(); } /** Applies the format. */ diff --git a/src/main/java/com/diffplug/gradle/spotless/Formatter.java b/src/main/java/com/diffplug/gradle/spotless/Formatter.java index 97847d5991..7c6321f865 100644 --- a/src/main/java/com/diffplug/gradle/spotless/Formatter.java +++ b/src/main/java/com/diffplug/gradle/spotless/Formatter.java @@ -15,6 +15,9 @@ */ package com.diffplug.gradle.spotless; +import org.gradle.api.logging.Logger; +import org.gradle.api.logging.Logging; + import java.io.File; import java.io.IOException; import java.nio.charset.StandardCharsets; @@ -24,11 +27,8 @@ import java.util.ArrayList; import java.util.List; -import org.gradle.api.logging.Logger; -import org.gradle.api.logging.Logging; - /** Formatter which performs the full formatting. */ -public class Formatter { +class Formatter { private final LineEnding lineEnding; private final Path projectDirectory; private final List steps; @@ -40,13 +40,24 @@ public Formatter(LineEnding lineEnding, Path projectDirectory, List(steps); } + private static int countOccurrences(String haystack, char needle) { + int count = 0; + for (char c : haystack.toCharArray()) { + if (c == needle) { + ++count; + } + } + return count; + } + /** Returns true iff the given file's formatting is up-to-date. */ public boolean isClean(File file) throws IOException { String raw = new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8); String unix = raw.replaceAll("\r", ""); // check the newlines - int totalNewLines = (int) unix.codePoints().filter(val -> val == '\n').count(); + + int totalNewLines = countOccurrences(unix, '\n'); int windowsNewLines = raw.length() - unix.length(); if (lineEnding.isWin()) { if (windowsNewLines != totalNewLines) { @@ -83,11 +94,12 @@ public void applyFormat(File file) throws IOException { } /** Returns the result of calling all of the FormatterSteps. */ - String applyAll(String unix, File file) { + private String applyAll(String unix, File file) { for (FormatterStep step : steps) { try { unix = step.format(unix); - } catch (Throwable e) { + } + catch (Throwable e) { logger.warn("Unable to apply step " + step.getName() + " to " + projectDirectory.relativize(file.toPath()) + ": " + e.getMessage()); logger.info("Exception is ", e); } diff --git a/src/main/java/com/diffplug/gradle/spotless/FormatterStep.java b/src/main/java/com/diffplug/gradle/spotless/FormatterStep.java index c93a4e6610..6bbf9cbe37 100644 --- a/src/main/java/com/diffplug/gradle/spotless/FormatterStep.java +++ b/src/main/java/com/diffplug/gradle/spotless/FormatterStep.java @@ -15,8 +15,6 @@ */ package com.diffplug.gradle.spotless; -import com.diffplug.common.base.Throwing; - /** * An implementation of this class specifies a single step in a formatting process. * @@ -25,13 +23,30 @@ */ public class FormatterStep { private final String name; - private final Throwing.Function formatter; - private FormatterStep(String name, Throwing.Function formatter) { + private final FormattingOperation formatter; + + private FormatterStep(String name, FormattingOperation formatter) { this.name = name; this.formatter = formatter; } + /** Creates a FormatterStep from the given function. */ + public static FormatterStep create(String name, FormattingOperation formatter) { + return new FormatterStep(name, formatter); + } + + /** Creates a FormatterStep lazily from the given formatterSupplier function. */ + public static FormatterStep createLazy(String name, final FormattingOperationSupplier formatterSupplier) { + return new FormatterStep(name, new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return formatterSupplier.get().apply(raw); + } + + }); + } + /** The name of the step, for debugging purposes. */ public String getName() { return name; @@ -39,32 +54,12 @@ public String getName() { /** * Returns a formatted version of the given content. - * + * * @param raw File's content, guaranteed to have unix-style newlines ('\n') - * @return The formatted content, guaranteed to only have unix-style newlines - * @throws Throwable + * @return The formatted content, guaranteed to only have unix-style newlines + * @throws Throwable */ public String format(String raw) throws Throwable { return formatter.apply(raw); } - - /** Creates a FormatterStep from the given function. */ - public static FormatterStep create(String name, Throwing.Function formatter) { - return new FormatterStep(name, formatter); - } - - /** Creates a FormatterStep lazily from the given formatterSupplier function. */ - public static FormatterStep createLazy(String name, Throwing.Supplier> formatterSupplier) { - return new FormatterStep(name, new Throwing.Function() { - private Throwing.Function formatter; - - @Override - public String apply(String content) throws Throwable { - if (formatter == null) { - formatter = formatterSupplier.get(); - } - return formatter.apply(content); - } - }); - } } diff --git a/src/main/java/com/diffplug/gradle/spotless/FormattingOperation.java b/src/main/java/com/diffplug/gradle/spotless/FormattingOperation.java new file mode 100644 index 0000000000..e53a39d018 --- /dev/null +++ b/src/main/java/com/diffplug/gradle/spotless/FormattingOperation.java @@ -0,0 +1,7 @@ +package com.diffplug.gradle.spotless; + +public abstract class FormattingOperation { + public abstract String apply(final String raw) throws Throwable; + + public void init() throws Exception {} +} diff --git a/src/main/java/com/diffplug/gradle/spotless/FormattingOperationSupplier.java b/src/main/java/com/diffplug/gradle/spotless/FormattingOperationSupplier.java new file mode 100644 index 0000000000..22c857eff8 --- /dev/null +++ b/src/main/java/com/diffplug/gradle/spotless/FormattingOperationSupplier.java @@ -0,0 +1,22 @@ +package com.diffplug.gradle.spotless; + +public final class FormattingOperationSupplier { + private final FormattingOperation formatter; + private boolean initialized = false; + + public FormattingOperationSupplier(final FormattingOperation formatter) { + this.formatter = formatter; + } + + FormattingOperation get() throws Exception { + if (!initialized) { + initialize(); + } + return formatter; + } + + private void initialize() throws Exception { + initialized = true; + formatter.init(); + } +} diff --git a/src/main/java/com/diffplug/gradle/spotless/IndentStep.java b/src/main/java/com/diffplug/gradle/spotless/IndentStep.java index 042e61d6d4..f9b1d8a60b 100644 --- a/src/main/java/com/diffplug/gradle/spotless/IndentStep.java +++ b/src/main/java/com/diffplug/gradle/spotless/IndentStep.java @@ -17,19 +17,18 @@ /** Simple step which checks for consistent indentation characters. */ public class IndentStep { - public enum Type { - TAB, SPACE - } - private final Type type; private final int tabsToSpaces; + private final StringBuilder builder = new StringBuilder(); public IndentStep(Type type, int tabsToSpaces) { this.type = type; this.tabsToSpaces = tabsToSpaces; } - private final StringBuilder builder = new StringBuilder(); + private static boolean isSpaceOrTab(char c) { + return c == ' ' || c == '\t'; + } public String format(String raw) { // reset the buffer @@ -41,14 +40,14 @@ public String format(String raw) { char c; while (contentStart < raw.length() && isSpaceOrTab(c = raw.charAt(contentStart))) { switch (c) { - case ' ': - ++numSpaces; - break; - case '\t': - numSpaces += tabsToSpaces; - break; - default: - throw new IllegalArgumentException("Unexpected char " + c); + case ' ': + ++numSpaces; + break; + case '\t': + numSpaces += tabsToSpaces; + break; + default: + throw new IllegalArgumentException("Unexpected char " + c); } ++contentStart; } @@ -56,18 +55,18 @@ public String format(String raw) { // add the leading space in a canonical way if (numSpaces > 0) { switch (type) { - case SPACE: - for (int i = 0; i < numSpaces; ++i) { - builder.append(' '); - } - break; - case TAB: - for (int i = 0; i < numSpaces / tabsToSpaces; ++i) { - builder.append('\t'); - } - break; - default: - throw new IllegalArgumentException("Unexpected enum " + type); + case SPACE: + for (int i = 0; i < numSpaces; ++i) { + builder.append(' '); + } + break; + case TAB: + for (int i = 0; i < numSpaces / tabsToSpaces; ++i) { + builder.append('\t'); + } + break; + default: + throw new IllegalArgumentException("Unexpected enum " + type); } } @@ -82,10 +81,11 @@ public String format(String raw) { ++lineStart; builder.append(raw.subSequence(contentStart, lineStart)); } - } while (true); + } + while (true); } - private static boolean isSpaceOrTab(char c) { - return c == ' ' || c == '\t'; + public enum Type { + TAB, SPACE } } diff --git a/src/main/java/com/diffplug/gradle/spotless/LicenseHeaderStep.java b/src/main/java/com/diffplug/gradle/spotless/LicenseHeaderStep.java index 98fa267cfe..7d711a5034 100644 --- a/src/main/java/com/diffplug/gradle/spotless/LicenseHeaderStep.java +++ b/src/main/java/com/diffplug/gradle/spotless/LicenseHeaderStep.java @@ -15,6 +15,8 @@ */ package com.diffplug.gradle.spotless; +import org.gradle.api.GradleException; + import java.io.File; import java.io.IOException; import java.nio.charset.StandardCharsets; @@ -22,8 +24,6 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.gradle.api.GradleException; - /** Prefixes a license header before the package statement. */ public class LicenseHeaderStep { public static final String NAME = "LicenseHeader"; diff --git a/src/main/java/com/diffplug/gradle/spotless/LineEnding.java b/src/main/java/com/diffplug/gradle/spotless/LineEnding.java index 8f3b9c77e7..2feff1bb11 100644 --- a/src/main/java/com/diffplug/gradle/spotless/LineEnding.java +++ b/src/main/java/com/diffplug/gradle/spotless/LineEnding.java @@ -21,7 +21,7 @@ public enum LineEnding { public final String string; - private LineEnding(String ending) { + LineEnding(String ending) { this.string = ending; } diff --git a/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java b/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java index 6d35a0e31a..f942fdb5c8 100644 --- a/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java +++ b/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java @@ -15,26 +15,26 @@ */ package com.diffplug.gradle.spotless; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.function.Consumer; - import org.gradle.api.GradleException; import org.gradle.api.Project; import com.diffplug.gradle.spotless.java.JavaExtension; + +import java.util.LinkedHashMap; +import java.util.Map; + import groovy.lang.Closure; public class SpotlessExtension { final Project project; + final Map formats = new LinkedHashMap<>(); + /** Line endings (if any). */ + LineEnding lineEndings = LineEnding.PLATFORM_NATIVE; public SpotlessExtension(Project project) { this.project = project; } - /** Line endings (if any). */ - LineEnding lineEndings = LineEnding.PLATFORM_NATIVE; - public LineEnding getLineEndings() { return lineEndings; } @@ -43,8 +43,6 @@ public void setLineEndings(LineEnding lineEndings) { this.lineEndings = lineEndings; } - Map formats = new LinkedHashMap<>(); - /** Configures the special java-specific extension. */ public void java(Closure closure) { JavaExtension java = new JavaExtension(this); @@ -52,12 +50,6 @@ public void java(Closure closure) { closure.call(); } - /** Configures a custom extension. */ - public void java(Consumer closure) { - JavaExtension java = new JavaExtension(this); - closure.accept(java); - } - /** Configures a custom extension. */ public void format(String name, Closure closure) { FormatExtension extension = new FormatExtension(name, this); @@ -65,12 +57,6 @@ public void format(String name, Closure closure) { closure.call(); } - /** Configures a custom extension. */ - public void format(String name, Consumer closure) { - FormatExtension extension = new FormatExtension(name, this); - closure.accept(extension); - } - /** Called by the FormatExtension constructor. */ void addFormatExtension(FormatExtension extension) { FormatExtension former = formats.put(extension.name, extension); diff --git a/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java b/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java index 17935df2c6..21311a2bd8 100644 --- a/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java +++ b/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java @@ -15,22 +15,25 @@ */ package com.diffplug.gradle.spotless; -import java.util.Map; - +import org.gradle.api.Action; +import org.gradle.api.GradleException; import org.gradle.api.Plugin; import org.gradle.api.Project; import org.gradle.api.Task; import org.gradle.api.plugins.JavaBasePlugin; -import com.diffplug.common.base.Errors; +import java.util.Map; public class SpotlessPlugin implements Plugin { - Project project; - SpotlessExtension extension; - static final String EXTENSION = "spotless"; - static final String CHECK = "Check"; static final String APPLY = "Apply"; + private static final String CHECK = "Check"; + private Project project; + private SpotlessExtension extension; + + private static String capitalize(String input) { + return Character.toUpperCase(input.charAt(0)) + input.substring(1); + } public void apply(Project project) { this.project = project; @@ -40,7 +43,17 @@ public void apply(Project project) { // ExtensionContainer container = ((ExtensionAware) project.getExtensions().getByName(EXTENSION)).getExtensions(); // after the project has been evaluated, configure the check and format tasks per source set - project.afterEvaluate(unused -> Errors.rethrow().run(this::createTasks)); + project.afterEvaluate(new Action() { + @Override + public void execute(Project project) { + try { + createTasks(); + } + catch (Exception e) { + throw new GradleException("failed to configure", e); + } + } + }); } /** The extension for this plugin. */ @@ -60,9 +73,11 @@ void createTasks() throws Exception { // Add our check task as a dependency on the global check task // getTasks() returns a "live" collection, so this works even if the // task doesn't exist at the time this call is made - project.getTasks() - .matching(task -> task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME)) - .all(task -> task.dependsOn(rootCheckTask)); + for (Task task : project.getTasks()) { + if (task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME)) { + task.dependsOn(rootCheckTask); + } + } } FormatTask createTask(String name, FormatExtension subExtension, boolean check) throws Exception { @@ -73,8 +88,4 @@ FormatTask createTask(String name, FormatExtension subExtension, boolean check) subExtension.setupTask(task); return task; } - - private static String capitalize(String input) { - return Character.toUpperCase(input.charAt(0)) + input.substring(1); - } } diff --git a/src/main/java/com/diffplug/gradle/spotless/java/EclipseFormatterStep.java b/src/main/java/com/diffplug/gradle/spotless/java/EclipseFormatterStep.java index 9c7308048e..a55e514f5a 100644 --- a/src/main/java/com/diffplug/gradle/spotless/java/EclipseFormatterStep.java +++ b/src/main/java/com/diffplug/gradle/spotless/java/EclipseFormatterStep.java @@ -15,11 +15,6 @@ */ package com.diffplug.gradle.spotless.java; -import java.io.File; -import java.io.FileInputStream; -import java.io.InputStream; -import java.util.Properties; - import org.eclipse.jdt.core.ToolFactory; import org.eclipse.jdt.core.formatter.CodeFormatter; import org.eclipse.jface.text.Document; @@ -29,6 +24,11 @@ import com.diffplug.gradle.spotless.LineEnding; +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; +import java.util.Properties; + import groovy.util.Node; import groovy.util.NodeList; import groovy.util.XmlParser; @@ -38,23 +38,12 @@ public class EclipseFormatterStep { public static final String NAME = "Eclipse Formatter"; - private CodeFormatter codeFormatter; + private final CodeFormatter codeFormatter; private EclipseFormatterStep(Properties settings) { this.codeFormatter = ToolFactory.createCodeFormatter(settings); } - public String format(String raw) throws Exception { - TextEdit edit = codeFormatter.format(CodeFormatter.K_COMPILATION_UNIT, raw, 0, raw.length(), 0, LineEnding.UNIX.string); - if (edit == null) { - throw new IllegalArgumentException("Invalid java syntax for formatting."); - } else { - IDocument doc = new Document(raw); - edit.apply(doc); - return doc.get(); - } - } - /** Returns an EclipseFormatterStep from the given config file. */ public static EclipseFormatterStep load(File file) throws Exception { Properties settings = new Properties(); @@ -68,8 +57,8 @@ public static EclipseFormatterStep load(File file) throws Exception { } else if (file.getName().endsWith(".xml")) { Node xmlSettings = new XmlParser().parse(file); NodeList xmlSettingsElements = xmlSettings.getAt(new QName("profile")).getAt("setting"); - for (int i = 0; i < xmlSettingsElements.size(); ++i) { - Node setting = (Node) xmlSettingsElements.get(i); + for (Object xmlSettingsElement : xmlSettingsElements) { + Node setting = (Node) xmlSettingsElement; settings.put(setting.attributes().get("id"), setting.attributes().get("value")); } return new EclipseFormatterStep(settings); @@ -77,4 +66,15 @@ public static EclipseFormatterStep load(File file) throws Exception { throw new GradleException("Eclipse formatter file must be .properties or .xml"); } } + + public String format(String raw) throws Exception { + TextEdit edit = codeFormatter.format(CodeFormatter.K_COMPILATION_UNIT, raw, 0, raw.length(), 0, LineEnding.UNIX.string); + if (edit == null) { + throw new IllegalArgumentException("Invalid java syntax for formatting."); + } else { + IDocument doc = new Document(raw); + edit.apply(doc); + return doc.get(); + } + } } diff --git a/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterImpl.java b/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterImpl.java index 06441a089f..d6458c0ff1 100644 --- a/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterImpl.java +++ b/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterImpl.java @@ -15,22 +15,61 @@ */ package com.diffplug.gradle.spotless.java; -import java.util.*; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; // From https://github.com/krasa/EclipseCodeFormatter /*not thread safe*/ class ImportSorterImpl { - private List template = new ArrayList(); - private Map> matchingImports = new HashMap>(); - private ArrayList notMatching = new ArrayList(); - private Set allImportOrderItems = new HashSet(); + private final List template = new ArrayList(); + private final Map> matchingImports = new HashMap>(); + private final ArrayList notMatching = new ArrayList(); + private final Set allImportOrderItems = new HashSet(); + + private ImportSorterImpl(List importOrder) { + List importOrderCopy = new ArrayList(importOrder); + normalizeStaticOrderItems(importOrderCopy); + putStaticItemIfNotExists(importOrderCopy); + template.addAll(importOrderCopy); + this.allImportOrderItems.addAll(importOrderCopy); + } static List sort(List imports, List importsOrder) { ImportSorterImpl importsSorter = new ImportSorterImpl(importsOrder); return importsSorter.sort(imports); } + private static String betterMatching(String order1, String order2, String anImport) { + if (order1.equals(order2)) { + throw new IllegalArgumentException("orders are same"); + } + for (int i = 0; i < anImport.length() - 1; i++) { + if (order1.length() - 1 == i && order2.length() - 1 != i) { + return order2; + } + if (order2.length() - 1 == i && order1.length() - 1 != i) { + return order1; + } + char orderChar1 = order1.length() != 0 ? order1.charAt(i) : ' '; + char orderChar2 = order2.length() != 0 ? order2.charAt(i) : ' '; + char importChar = anImport.charAt(i); + + if (importChar == orderChar1 && importChar != orderChar2) { + return order1; + } else if (importChar != orderChar1 && importChar == orderChar2) { + return order2; + } + + } + return null; + } + private List sort(List imports) { filterMatchingImports(imports); mergeNotMatchingItems(false); @@ -40,14 +79,6 @@ private List sort(List imports) { return getResult(); } - private ImportSorterImpl(List importOrder) { - List importOrderCopy = new ArrayList(importOrder); - normalizeStaticOrderItems(importOrderCopy); - putStaticItemIfNotExists(importOrderCopy); - template.addAll(importOrderCopy); - this.allImportOrderItems.addAll(importOrderCopy); - } - private void putStaticItemIfNotExists(List allImportOrderItems) { boolean contains = false; int indexOfFirstStatic = 0; @@ -224,29 +255,4 @@ private List getResult() { return strings; } - private static String betterMatching(String order1, String order2, String anImport) { - if (order1.equals(order2)) { - throw new IllegalArgumentException("orders are same"); - } - for (int i = 0; i < anImport.length() - 1; i++) { - if (order1.length() - 1 == i && order2.length() - 1 != i) { - return order2; - } - if (order2.length() - 1 == i && order1.length() - 1 != i) { - return order1; - } - char orderChar1 = order1.length() != 0 ? order1.charAt(i) : ' '; - char orderChar2 = order2.length() != 0 ? order2.charAt(i) : ' '; - char importChar = anImport.charAt(i); - - if (importChar == orderChar1 && importChar != orderChar2) { - return order1; - } else if (importChar != orderChar1 && importChar == orderChar2) { - return order2; - } - - } - return null; - } - } diff --git a/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterStep.java b/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterStep.java index 9d3e00378d..9bdb935eb0 100644 --- a/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterStep.java +++ b/src/main/java/com/diffplug/gradle/spotless/java/ImportSorterStep.java @@ -17,14 +17,12 @@ import java.io.File; import java.io.IOException; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; -import java.util.AbstractMap; import java.util.ArrayList; import java.util.List; -import java.util.Map; import java.util.Scanner; import java.util.TreeMap; -import java.util.stream.Collectors; /** * From https://github.com/krasa/EclipseCodeFormatter @@ -33,10 +31,8 @@ */ public class ImportSorterStep { public static final String NAME = "ImportSorter"; - - public static final int START_INDEX_OF_IMPORTS_PACKAGE_DECLARATION = 7; public static final String N = "\n"; - + private static final int START_INDEX_OF_IMPORTS_PACKAGE_DECLARATION = 7; private List importsOrder; public ImportSorterStep(List importsOrder) { @@ -44,20 +40,16 @@ public ImportSorterStep(List importsOrder) { } public ImportSorterStep(File importsFile) throws IOException { - Map orderToImport = Files.readAllLines(importsFile.toPath()).stream() - // filter out comments - .filter(line -> !line.startsWith("#")) - // parse 0=input - .map(line -> { - String[] pieces = line.split("="); - int idx = Integer.parseInt(pieces[0]); - String name = pieces.length == 2 ? pieces[1] : ""; - return new AbstractMap.SimpleEntry(idx, name); - }) - // collect into map - .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); - // sort the entries by the key, save the values - importsOrder = new ArrayList<>(new TreeMap<>(orderToImport).values()); + TreeMap orderToImport = new TreeMap<>(); + for (String line : Files.readAllLines(importsFile.toPath(), StandardCharsets.UTF_8)) { + if (!line.startsWith("#")) { + String[] pieces = line.split("="); + int idx = Integer.parseInt(pieces[0]); + String name = pieces.length == 2 ? pieces[1] : ""; + orderToImport.put(idx, name); + } + } + importsOrder = new ArrayList<>(orderToImport.values()); } public String format(String raw) { diff --git a/src/main/java/com/diffplug/gradle/spotless/java/JavaExtension.java b/src/main/java/com/diffplug/gradle/spotless/java/JavaExtension.java index c32077119f..ad6b59a7ec 100644 --- a/src/main/java/com/diffplug/gradle/spotless/java/JavaExtension.java +++ b/src/main/java/com/diffplug/gradle/spotless/java/JavaExtension.java @@ -15,8 +15,6 @@ */ package com.diffplug.gradle.spotless.java; -import java.util.List; - import org.gradle.api.GradleException; import org.gradle.api.internal.file.UnionFileCollection; import org.gradle.api.plugins.JavaPluginConvention; @@ -24,17 +22,21 @@ import com.diffplug.gradle.spotless.FormatExtension; import com.diffplug.gradle.spotless.FormatTask; +import com.diffplug.gradle.spotless.FormattingOperation; +import com.diffplug.gradle.spotless.FormattingOperationSupplier; import com.diffplug.gradle.spotless.SpotlessExtension; +import java.io.IOException; +import java.util.List; + public class JavaExtension extends FormatExtension { - public static final String NAME = "java"; + public static final String LICENSE_HEADER_DELIMITER = "package "; + private static final String NAME = "java"; public JavaExtension(SpotlessExtension rootExtension) { super(NAME, rootExtension); } - public static final String LICENSE_HEADER_DELIMITER = "package "; - public void licenseHeader(String licenseHeader) { licenseHeader(licenseHeader, LICENSE_HEADER_DELIMITER); } @@ -43,16 +45,52 @@ public void licenseHeaderFile(Object licenseHeaderFile) { licenseHeaderFile(licenseHeaderFile, LICENSE_HEADER_DELIMITER); } - public void importOrder(List importOrder) { - customLazy(ImportSorterStep.NAME, () -> new ImportSorterStep(importOrder)::format); + public void importOrder(final List importOrder) { + customLazy(ImportSorterStep.NAME, new FormattingOperationSupplier(new FormattingOperation() { + ImportSorterStep step; + + @Override + public String apply(String raw) { + return step.format(raw); + } + + @Override + public void init() { + step = new ImportSorterStep(importOrder); + } + })); } - public void importOrderFile(Object importOrderFile) { - customLazy(ImportSorterStep.NAME, () -> new ImportSorterStep(getProject().file(importOrderFile))::format); + public void importOrderFile(final Object importOrderFile) { + customLazy(ImportSorterStep.NAME, new FormattingOperationSupplier(new FormattingOperation() { + ImportSorterStep step; + + @Override + public String apply(String raw) { + return step.format(raw); + } + + @Override + public void init() throws IOException { + step = new ImportSorterStep(getProject().file(importOrderFile)); + } + })); } - public void eclipseFormatFile(Object eclipseFormatFile) { - customLazy(EclipseFormatterStep.NAME, () -> EclipseFormatterStep.load(getProject().file(eclipseFormatFile))::format); + public void eclipseFormatFile(final Object eclipseFormatFile) { + customLazy(EclipseFormatterStep.NAME, new FormattingOperationSupplier(new FormattingOperation() { + EclipseFormatterStep step; + + @Override + public String apply(String raw) throws Exception { + return step.format(raw); + } + + @Override + public void init() throws Exception { + step = EclipseFormatterStep.load(getProject().file(eclipseFormatFile)); + } + })); } /** If the user hasn't specified the files yet, we'll assume he/she means all of the java files. */ diff --git a/src/test/java/com/diffplug/gradle/spotless/EndWithNewlineTest.java b/src/test/java/com/diffplug/gradle/spotless/EndWithNewlineTest.java index 4a4ba97f50..01bce43218 100644 --- a/src/test/java/com/diffplug/gradle/spotless/EndWithNewlineTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/EndWithNewlineTest.java @@ -33,8 +33,11 @@ private void endWithNewlineTest(String before) throws Exception { } private void endWithNewlineTest(String before, String after) throws Exception { - super.assertTask(test -> { - test.endWithNewline(); + super.assertTask(new SimpleConsumer() { + @Override + public void accept(FormatExtension ext) { + ext.endWithNewline(); + } }, before, after); } } diff --git a/src/test/java/com/diffplug/gradle/spotless/FormatTaskTest.java b/src/test/java/com/diffplug/gradle/spotless/FormatTaskTest.java index cc912dff28..6666cf251d 100644 --- a/src/test/java/com/diffplug/gradle/spotless/FormatTaskTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/FormatTaskTest.java @@ -15,15 +15,16 @@ */ package com.diffplug.gradle.spotless; -import java.io.File; -import java.io.IOException; -import java.util.Collections; +import org.junit.Before; +import org.junit.Test; import org.gradle.api.GradleException; import org.gradle.api.Project; import org.gradle.testfixtures.ProjectBuilder; -import org.junit.Before; -import org.junit.Test; + +import java.io.File; +import java.io.IOException; +import java.util.Collections; public class FormatTaskTest extends ResourceTest { private Project project; @@ -32,7 +33,7 @@ public class FormatTaskTest extends ResourceTest { @Before public void createTask() { project = ProjectBuilder.builder().build(); - task = (FormatTask) project.getTasks().create("underTest", FormatTask.class); + task = project.getTasks().create("underTest", FormatTask.class); } @Test(expected = GradleException.class) @@ -69,7 +70,12 @@ public void testStepCheckFail() throws IOException { task.target = Collections.singleton(testFile); task.check = true; - task.steps.add(FormatterStep.create("double-p", content -> content.replace("pp", "p"))); + task.steps.add(FormatterStep.create("double-p", new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return raw.replace("pp", "p"); + } + })); task.execute(); assertFileContent("\n", testFile); @@ -81,7 +87,12 @@ public void testStepCheckPass() throws IOException { task.target = Collections.singleton(testFile); task.check = true; - task.steps.add(FormatterStep.create("double-p", content -> content.replace("pp", "p"))); + task.steps.add(FormatterStep.create("double-p", new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return raw.replace("pp", "p"); + } + })); task.execute(); } @@ -91,7 +102,12 @@ public void testStepApply() throws IOException { task.target = Collections.singleton(testFile); task.check = false; - task.steps.add(FormatterStep.create("double-p", content -> content.replace("pp", "p"))); + task.steps.add(FormatterStep.create("double-p", new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return raw.replace("pp", "p"); + } + })); task.execute(); super.assertFileContent("aple", testFile); diff --git a/src/test/java/com/diffplug/gradle/spotless/IndentStepTest.java b/src/test/java/com/diffplug/gradle/spotless/IndentStepTest.java index 0074d73814..ed1b2d5490 100644 --- a/src/test/java/com/diffplug/gradle/spotless/IndentStepTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/IndentStepTest.java @@ -19,28 +19,34 @@ import org.junit.Test; public class IndentStepTest extends ResourceTest { + + FormattingOperation applyIndent(final IndentStep indent) { + return new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return indent.format(raw); + } + }; + } + @Test public void tabToTab() throws Throwable { - IndentStep indent = new IndentStep(IndentStep.Type.TAB, 4); - assertStep(indent::format, "IndentedWithTab.test", "IndentedWithTab.test"); + assertStep(applyIndent(new IndentStep(IndentStep.Type.TAB, 4)), "IndentedWithTab.test", "IndentedWithTab.test"); } @Test public void spaceToSpace() throws Throwable { - IndentStep indent = new IndentStep(IndentStep.Type.SPACE, 4); - assertStep(indent::format, "IndentedWithSpace.test", "IndentedWithSpace.test"); + assertStep(applyIndent(new IndentStep(IndentStep.Type.SPACE, 4)), "IndentedWithSpace.test", "IndentedWithSpace.test"); } @Test public void spaceToTab() throws Throwable { - IndentStep indent = new IndentStep(IndentStep.Type.TAB, 4); - assertStep(indent::format, "IndentedWithSpace.test", "IndentedWithTab.test"); + assertStep(applyIndent(new IndentStep(IndentStep.Type.TAB, 4)), "IndentedWithSpace.test", "IndentedWithTab.test"); } @Test public void tabToSpace() throws Throwable { - IndentStep indent = new IndentStep(IndentStep.Type.SPACE, 4); - assertStep(indent::format, "IndentedWithTab.test", "IndentedWithSpace.test"); + assertStep(applyIndent(new IndentStep(IndentStep.Type.SPACE, 4)), "IndentedWithTab.test", "IndentedWithSpace.test"); } @Test diff --git a/src/test/java/com/diffplug/gradle/spotless/LicenseHeaderStepTest.java b/src/test/java/com/diffplug/gradle/spotless/LicenseHeaderStepTest.java index e7fdfc7628..2c8f11cb00 100644 --- a/src/test/java/com/diffplug/gradle/spotless/LicenseHeaderStepTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/LicenseHeaderStepTest.java @@ -18,24 +18,34 @@ import org.junit.Assert; import org.junit.Test; -import com.diffplug.gradle.spotless.LicenseHeaderStep; import com.diffplug.gradle.spotless.java.JavaExtension; +import java.util.Objects; + public class LicenseHeaderStepTest extends ResourceTest { private static final String KEY_LICENSE = "TestLicense"; private static final String KEY_FILE_NOTAPPLIED = "Java8CodeFormatted.test"; private static final String KEY_FILE_APPLIED = "JavaCodeFormattedWithLicense.test"; + FormattingOperation applyLicenseStep(final LicenseHeaderStep step) { + return new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return step.format(raw); + } + }; + } + @Test public void fromString() throws Throwable { LicenseHeaderStep step = new LicenseHeaderStep(getTestResource(KEY_LICENSE), JavaExtension.LICENSE_HEADER_DELIMITER); - assertStep(step::format, KEY_FILE_NOTAPPLIED, KEY_FILE_APPLIED); + assertStep(applyLicenseStep(step), KEY_FILE_NOTAPPLIED, KEY_FILE_APPLIED); } @Test public void fromFile() throws Throwable { LicenseHeaderStep step = new LicenseHeaderStep(createTestFile(KEY_LICENSE), JavaExtension.LICENSE_HEADER_DELIMITER); - assertStep(step::format, KEY_FILE_NOTAPPLIED, KEY_FILE_APPLIED); + assertStep(applyLicenseStep(step), KEY_FILE_NOTAPPLIED, KEY_FILE_APPLIED); } @Test @@ -44,7 +54,7 @@ public void efficient() throws Throwable { String alreadyCorrect = "LicenseHeader\ncontentstart"; Assert.assertEquals(alreadyCorrect, step.format(alreadyCorrect)); // If no change is required, it should return the exact same string for efficiency reasons - Assert.assertTrue(alreadyCorrect == step.format(alreadyCorrect)); + Assert.assertTrue(Objects.equals(alreadyCorrect, step.format(alreadyCorrect))); } @Test @@ -53,7 +63,7 @@ public void sanitized() throws Throwable { LicenseHeaderStep step = new LicenseHeaderStep("LicenseHeader", "contentstart"); String alreadyCorrect = "LicenseHeader\ncontentstart"; Assert.assertEquals(alreadyCorrect, step.format(alreadyCorrect)); - Assert.assertTrue(alreadyCorrect == step.format(alreadyCorrect)); + Assert.assertTrue(Objects.equals(alreadyCorrect, step.format(alreadyCorrect))); } @Test @@ -62,6 +72,6 @@ public void sanitizerDoesntGoTooFar() throws Throwable { LicenseHeaderStep step = new LicenseHeaderStep("LicenseHeader\n\n", "contentstart"); String alreadyCorrect = "LicenseHeader\n\ncontentstart"; Assert.assertEquals(alreadyCorrect, step.format(alreadyCorrect)); - Assert.assertTrue(alreadyCorrect == step.format(alreadyCorrect)); + Assert.assertTrue(Objects.equals(alreadyCorrect, step.format(alreadyCorrect))); } } diff --git a/src/test/java/com/diffplug/gradle/spotless/ResourceTest.java b/src/test/java/com/diffplug/gradle/spotless/ResourceTest.java index cd1040b948..de5b2b8a8c 100644 --- a/src/test/java/com/diffplug/gradle/spotless/ResourceTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/ResourceTest.java @@ -15,6 +15,13 @@ */ package com.diffplug.gradle.spotless; +import groovy.lang.Closure; +import org.gradle.api.Project; +import org.gradle.testfixtures.ProjectBuilder; +import org.junit.Assert; +import org.junit.Rule; +import org.junit.rules.TemporaryFolder; + import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; @@ -23,26 +30,37 @@ import java.nio.file.Files; import java.util.Collections; import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Consumer; - -import org.gradle.api.Project; -import org.gradle.testfixtures.ProjectBuilder; -import org.junit.Assert; -import org.junit.Rule; -import org.junit.rules.TemporaryFolder; - -import com.diffplug.common.base.Throwing; public class ResourceTest { @Rule public TemporaryFolder folder = new TemporaryFolder(); + /** Creates a FormatTask based on the given consumer. */ + public static FormatTask createTask(final SimpleConsumer test) throws Exception { + Project project = ProjectBuilder.builder().build(); + SpotlessPlugin plugin = project.getPlugins().apply(SpotlessPlugin.class); + + final AtomicReference ref = new AtomicReference<>(); + plugin.getExtension().format("underTest", new Closure(plugin) { + @Override + public FormatExtension call() { + FormatExtension extension = (FormatExtension) getDelegate(); + ref.set(extension); + test.accept(extension); + return extension; + } + }); + + boolean check = false; + return plugin.createTask("underTest", ref.get(), check); + } + /** Returns the contents of the given file from the src/test/resources directory. */ protected String getTestResource(String filename) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); InputStream inputStream = getClass().getResourceAsStream("/" + filename); byte[] buffer = new byte[1024]; - int length = 0; + int length; while ((length = inputStream.read(buffer)) != -1) { baos.write(buffer, 0, length); } @@ -71,7 +89,7 @@ protected void assertFileContent(String expectedContent, File actual) throws IOE } /** Reads the given resource from "before", applies the step, and makes sure the result is "after". */ - protected void assertStep(Throwing.Function step, String unformattedPath, String expectedPath) throws Throwable { + protected void assertStep(FormattingOperation step, String unformattedPath, String expectedPath) throws Throwable { String unformatted = getTestResource(unformattedPath).replace("\r", ""); // unix-ified input String formatted = step.apply(unformatted); // no windows newlines @@ -82,23 +100,8 @@ protected void assertStep(Throwing.Function step, String unforma Assert.assertEquals(expected, formatted); } - /** Creates a FormatTask based on the given consumer. */ - public static FormatTask createTask(Consumer test) throws Exception { - Project project = ProjectBuilder.builder().build(); - SpotlessPlugin plugin = project.getPlugins().apply(SpotlessPlugin.class); - - AtomicReference ref = new AtomicReference<>(); - plugin.getExtension().format("underTest", ext -> { - ref.set(ext); - test.accept(ext); - }); - - boolean check = false; - return plugin.createTask("underTest", ref.get(), check); - } - /** Tests that the formatExtension causes the given change. */ - protected void assertTask(Consumer test, String before, String afterExpected) throws Exception { + protected void assertTask(final SimpleConsumer test, final String before, final String afterExpected) throws Exception { // create the task FormatTask task = createTask(test); // force unix line endings, since we're passing in raw strings diff --git a/src/test/java/com/diffplug/gradle/spotless/SelfTest.java b/src/test/java/com/diffplug/gradle/spotless/SelfTest.java index b9c1370c99..391d455211 100644 --- a/src/test/java/com/diffplug/gradle/spotless/SelfTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/SelfTest.java @@ -15,14 +15,16 @@ */ package com.diffplug.gradle.spotless; -import java.io.File; -import java.util.function.Consumer; - +import com.diffplug.gradle.spotless.java.JavaExtension; +import groovy.lang.Closure; import org.gradle.api.Project; +import org.gradle.api.Task; import org.gradle.testfixtures.ProjectBuilder; import org.junit.Ignore; import org.junit.Test; +import java.io.File; + /** * Running spotless on ourselves yields the following error: * @@ -36,17 +38,6 @@ * So, we'll just run it from inside of ourselves. */ public class SelfTest { - /** Runs the check (which we want to happen in the test suite). */ - @Test - @Ignore("The test passes in real life and Eclipse, but fails in Gradle test runner...") - public void check() throws Exception { - try { - runTasksWithCheck(true); - } catch (Exception e) { - throw new Exception("There are formatting errors in spotless' source code.\n" + "Ideally, you could just run 'spotlessApply', but because of an unresolved bootstrapping issue, you'll have to manually run the " + "main() method in com.diffplug.gradle.spotless.SelfTest", e); - } - } - /** Applies the format (which should be manual). */ public static void main(String[] args) throws Exception { runTasksWithCheck(false); @@ -54,43 +45,62 @@ public static void main(String[] args) throws Exception { /** Returns all of the FormatTasks which have check equal to the given value. */ private static void runTasksWithCheck(boolean check) throws Exception { - Project project = createProject(extension -> { - extension.java(java -> { - java.target("**/*.java"); - java.licenseHeaderFile("spotless.license.java"); - java.importOrderFile("spotless.importorder"); - java.eclipseFormatFile("spotless.eclipseformat.xml"); - java.customLazy("Lambda fix", () -> raw -> { - if (!raw.contains("public class SelfTest ")) { - // don't format this line away, lol - return raw.replace("} )", "})").replace("} ,", "},"); - } else { - return raw; + Project project = createProject(new SimpleConsumer() { + @Override + public void accept(SpotlessExtension extension) { + extension.java(new Closure(this) { + @Override + public JavaExtension call() { + final JavaExtension javaExt = (JavaExtension) getDelegate(); + javaExt.target("**/*.java"); + javaExt.licenseHeaderFile("spotless.license.java"); + javaExt.importOrderFile("spotless.importorder"); + javaExt.eclipseFormatFile("spotless.eclipseformat.xml"); + javaExt.customLazy("Lambda fix", new FormattingOperationSupplier(new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + if (!raw.contains("public class SelfTest ")) { + // don't format this line away, lol + return raw.replace("} )", "})").replace("} ,", "},"); + } else { + return raw; + } + } + })); + return javaExt; + } + }); + extension.format("misc", new Closure(this) { + @Override + public FormatExtension call() { + FormatExtension misc = (FormatExtension) getDelegate(); + misc.target("**/*.gradle", "**/*.md", "**/*.gitignore"); + misc.indentWithTabs(); + misc.trimTrailingWhitespace(); + misc.endWithNewline(); + return misc; } - } ); - } ); - extension.format("misc", misc -> { - misc.target("**/*.gradle", "**/*.md", "**/*.gitignore"); - misc.indentWithTabs(); - misc.trimTrailingWhitespace(); - misc.endWithNewline(); - } ); - } ); - project.getTasks().stream() - .filter(task -> task instanceof FormatTask) - .map(task -> (FormatTask) task) - .filter(task -> task.check == check) - .forEach(task -> { + }); + } + }); + + for (Task task : project.getTasks()) { + if (task instanceof FormatTask) { + FormatTask formatTask = (FormatTask) task; + if (formatTask.check == check) { try { - task.format(); - } catch (Exception e) { + formatTask.format(); + } + catch (Exception e) { throw new RuntimeException(e); } - } ); + } + } + } } /** Creates a Project which has had the SpotlessExtension setup. */ - private static Project createProject(Consumer test) throws Exception { + private static Project createProject(SimpleConsumer test) throws Exception { Project project = ProjectBuilder.builder().withProjectDir(new File("").getAbsoluteFile()).build(); // create the spotless plugin SpotlessPlugin plugin = project.getPlugins().apply(SpotlessPlugin.class); @@ -100,4 +110,16 @@ private static Project createProject(Consumer test) throws Ex // return the configured plugin return project; } + + /** Runs the check (which we want to happen in the test suite). */ + @Test + @Ignore("The test passes in real life and Eclipse, but fails in Gradle test runner...") + public void check() throws Exception { + try { + runTasksWithCheck(true); + } + catch (Exception e) { + throw new Exception("There are formatting errors in spotless' source code.\n" + "Ideally, you could just run 'spotlessApply', but because of an unresolved bootstrapping issue, you'll have to manually run the " + "main() method in com.diffplug.gradle.spotless.SelfTest", e); + } + } } diff --git a/src/test/java/com/diffplug/gradle/spotless/SimpleConsumer.java b/src/test/java/com/diffplug/gradle/spotless/SimpleConsumer.java new file mode 100644 index 0000000000..99b2e8bb96 --- /dev/null +++ b/src/test/java/com/diffplug/gradle/spotless/SimpleConsumer.java @@ -0,0 +1,6 @@ +package com.diffplug.gradle.spotless; + +public abstract class SimpleConsumer { + + abstract public void accept(T extension); +} diff --git a/src/test/java/com/diffplug/gradle/spotless/TrimTrailingWhitespaceTest.java b/src/test/java/com/diffplug/gradle/spotless/TrimTrailingWhitespaceTest.java index 4e4ca9ca2d..d05df653d4 100644 --- a/src/test/java/com/diffplug/gradle/spotless/TrimTrailingWhitespaceTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/TrimTrailingWhitespaceTest.java @@ -48,8 +48,10 @@ private void trimTrailingWhitespaceTestCase(String before) throws Exception { } private void trimTrailingWhitespaceTestCase(String before, String after) throws Exception { - super.assertTask(test -> { - test.trimTrailingWhitespace(); + super.assertTask(new SimpleConsumer() { + public void accept(FormatExtension extension) { + extension.trimTrailingWhitespace(); + } }, before, after); } } diff --git a/src/test/java/com/diffplug/gradle/spotless/java/EclipseFormatterStepTest.java b/src/test/java/com/diffplug/gradle/spotless/java/EclipseFormatterStepTest.java index 187c6c6c82..7ec36933a5 100644 --- a/src/test/java/com/diffplug/gradle/spotless/java/EclipseFormatterStepTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/java/EclipseFormatterStepTest.java @@ -15,26 +15,38 @@ */ package com.diffplug.gradle.spotless.java; -import java.io.File; +import org.junit.Test; import org.gradle.api.GradleException; -import org.junit.Test; +import com.diffplug.gradle.spotless.FormattingOperation; import com.diffplug.gradle.spotless.ResourceTest; +import java.io.File; + public class EclipseFormatterStepTest extends ResourceTest { @Test public void loadPropertiesSettings() throws Throwable { // setting for the formatter - EclipseFormatterStep step = EclipseFormatterStep.load(createTestFile("formatter.properties")); - assertStep(step::format, "JavaCodeUnformatted.test", "JavaCodeFormatted.test"); + final EclipseFormatterStep step = EclipseFormatterStep.load(createTestFile("formatter.properties")); + assertStep(new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return step.format(raw); + } + }, "JavaCodeUnformatted.test", "JavaCodeFormatted.test"); } @Test public void loadXmlSettings() throws Throwable { // setting for the formatter - EclipseFormatterStep step = EclipseFormatterStep.load(createTestFile("formatter.xml")); - assertStep(step::format, "JavaCodeUnformatted.test", "JavaCodeFormatted.test"); + final EclipseFormatterStep step = EclipseFormatterStep.load(createTestFile("formatter.xml")); + assertStep(new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return step.format(raw); + } + }, "JavaCodeUnformatted.test", "JavaCodeFormatted.test"); } @Test(expected = GradleException.class) diff --git a/src/test/java/com/diffplug/gradle/spotless/java/ImportSorterStepTest.java b/src/test/java/com/diffplug/gradle/spotless/java/ImportSorterStepTest.java index 0cbcd5b1dc..bb3cd11d11 100644 --- a/src/test/java/com/diffplug/gradle/spotless/java/ImportSorterStepTest.java +++ b/src/test/java/com/diffplug/gradle/spotless/java/ImportSorterStepTest.java @@ -15,23 +15,34 @@ */ package com.diffplug.gradle.spotless.java; -import java.util.Arrays; - import org.junit.Test; +import com.diffplug.gradle.spotless.FormattingOperation; import com.diffplug.gradle.spotless.ResourceTest; +import java.util.Arrays; + public class ImportSorterStepTest extends ResourceTest { @Test public void sortImportsFromArray() throws Throwable { - ImportSorterStep step = new ImportSorterStep(Arrays.asList("java", "javax", "org", "\\#com")); - assertStep(step::format, "JavaCodeUnsortedImports.test", "JavaCodeSortedImports.test"); + final ImportSorterStep step = new ImportSorterStep(Arrays.asList("java", "javax", "org", "\\#com")); + assertStep(new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return step.format(raw); + } + }, "JavaCodeUnsortedImports.test", "JavaCodeSortedImports.test"); } @Test public void sortImportsFromFile() throws Throwable { - ImportSorterStep step = new ImportSorterStep(createTestFile("import.properties")); - assertStep(step::format, "JavaCodeUnsortedImports.test", "JavaCodeSortedImports.test"); + final ImportSorterStep step = new ImportSorterStep(createTestFile("import.properties")); + assertStep(new FormattingOperation() { + @Override + public String apply(String raw) throws Throwable { + return step.format(raw); + } + }, "JavaCodeUnsortedImports.test", "JavaCodeSortedImports.test"); } @Test From 1f1c7b6db8ec71f3b54c3ecd8027e48ed8e1b156 Mon Sep 17 00:00:00 2001 From: Gabor Bernat Date: Sat, 29 Aug 2015 19:04:45 +0200 Subject: [PATCH 2/2] upgrade gradle to 2.6 --- gradle/wrapper/gradle-wrapper.jar | Bin 52141 -> 52266 bytes gradle/wrapper/gradle-wrapper.properties | 4 +- gradlew.bat | 180 +++++++++++------------ 3 files changed, 92 insertions(+), 92 deletions(-) diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 085a1cdc27db1185342f15a00441734e74fe3735..b5166dad4d90021f6a0b45268c0755719f1d5cd4 100644 GIT binary patch delta 8640 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 OP8h~Ugm3;c@_zu%56iCr delta 8509 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 2>&1 -if "%ERRORLEVEL%" == "0" goto init - -echo. -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto init - -echo. -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:init -@rem Get command-line arguments, handling Windowz variants - -if not "%OS%" == "Windows_NT" goto win9xME_args -if "%@eval[2+2]" == "4" goto 4NT_args - -:win9xME_args -@rem Slurp the command line arguments. -set CMD_LINE_ARGS= -set _SKIP=2 - -:win9xME_args_slurp -if "x%~1" == "x" goto execute - -set CMD_LINE_ARGS=%* -goto execute - -:4NT_args -@rem Get arguments from the 4NT Shell from JP Software -set CMD_LINE_ARGS=%$ - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% - -:end -@rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 -exit /b 1 - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windowz variants + +if not "%OS%" == "Windows_NT" goto win9xME_args +if "%@eval[2+2]" == "4" goto 4NT_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* +goto execute + +:4NT_args +@rem Get arguments from the 4NT Shell from JP Software +set CMD_LINE_ARGS=%$ + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega