Speedup GIT_ATTRIBUTES

CHANGES.md

@@ -16,6 +16,7 @@ We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (
  the version accordingly. ([#1804](https://github.com/diffplug/spotless/issues/1804)).
 * Support for `google-java-format`'s `skip-javadoc-formatting` option. ([#1793](https://github.com/diffplug/spotless/pull/1793))
 * Support configuration of mirrors for P2 repositories in maven DSL ([#1697](https://github.com/diffplug/spotless/issues/1697)).
+* New line endings mode `GIT_ATTRIBUTES_FAST_ALLSAME`. ([#1838](https://github.com/diffplug/spotless/pull/1838))
 ### Fixed
 * Fix support for plugins when using Prettier version `3.0.0` and newer. ([#1802](https://github.com/diffplug/spotless/pull/1802))
 * Fix configuration cache issue around `external process started '/usr/bin/git --version'`. ([#1806](https://github.com/diffplug/spotless/issues/1806))

lib-extra/src/main/java/com/diffplug/spotless/extra/GitAttributesLineEndings.java

@@ -68,6 +68,42 @@ public final class GitAttributesLineEndings {
  // prevent direct instantiation
  private GitAttributesLineEndings() {}
 
+ /**
+ * Creates a line-endings policy which matches {@link #create(File, Supplier)},
+ * which is much faster at the cost that every file under the policy
+ * is assumed to have the same line endings as the first file.
+ */
+ public static LineEnding.Policy createFastAllSame(File projectDir, Supplier<Iterable<File>> toFormat) {
+ return new LazyAllTheSame(projectDir, toFormat);
+ }
+
+ static class LazyAllTheSame extends LazyForwardingEquality<String> implements LineEnding.Policy {
+ private static final long serialVersionUID = 727912266173243664L;
+ transient File projectDir;
+ transient Supplier<Iterable<File>> toFormat;
+
+ public LazyAllTheSame(File projectDir, Supplier<Iterable<File>> toFormat) {
+ this.projectDir = projectDir;
+ this.toFormat = toFormat;
+ }
+
+ @Override
+ protected String calculateState() throws Exception {
+ var files = toFormat.get().iterator();
+ if (files.hasNext()) {
+ Runtime runtime = new RuntimeInit(projectDir).atRuntime();
+ return runtime.getEndingFor(files.next());
+ } else {
+ return LineEnding.UNIX.str();
+ }
+ }
+
+ @Override
+ public String getEndingFor(File file) {
+ return state();
+ }
+ }
+
  /**
  * Creates a line-endings policy whose serialized state is relativized against projectDir,
  * at the cost of eagerly evaluating the line-ending state of every target file when the

lib/src/main/java/com/diffplug/spotless/LineEnding.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2022 DiffPlug
+ * Copyright 2016-2023 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,11 +19,8 @@
 import java.io.Serializable;
 import java.lang.reflect.Method;
 import java.util.Objects;
-import java.util.function.BiFunction;
 import java.util.function.Supplier;
 
-import javax.annotation.Nullable;
-
 /**
  * Represents the line endings which should be written by the tool.
  */
@@ -37,6 +34,14 @@ public Policy createPolicy() {
  return super.createPolicy();
  }
  },
+ /** Uses the same line endings as Git, and assumes that every single file being formatted will have the same line ending. */
+ GIT_ATTRIBUTES_FAST_ALLSAME {
+ /** .gitattributes is path-specific, so you must use {@link LineEnding#createPolicy(File, Supplier)}. */
+ @Override @Deprecated
+ public Policy createPolicy() {
+ return super.createPolicy();
+ }
+ },
  /** {@code \n} on unix systems, {@code \r\n} on windows systems. */
  PLATFORM_NATIVE,
  /** {@code \r\n} */
@@ -51,33 +56,31 @@ public Policy createPolicy() {
  public Policy createPolicy(File projectDir, Supplier<Iterable<File>> toFormat) {
  Objects.requireNonNull(projectDir, "projectDir");
  Objects.requireNonNull(toFormat, "toFormat");
- if (this != GIT_ATTRIBUTES) {
- return createPolicy();
+ String gitAttributesMethod;
+ if (this == GIT_ATTRIBUTES) {
+ gitAttributesMethod = "create";
+ } else if (this == GIT_ATTRIBUTES_FAST_ALLSAME) {
+ gitAttributesMethod = "createFastAllSame";
  } else {
- if (gitAttributesPolicyCreator == null) {
- try {
- Class<?> clazz = Class.forName("com.diffplug.spotless.extra.GitAttributesLineEndings");
- Method method = clazz.getMethod("create", File.class, Supplier.class);
- gitAttributesPolicyCreator = (proj, target) -> ThrowingEx.get(() -> (Policy) method.invoke(null, proj, target));
- } catch (ClassNotFoundException | NoSuchMethodException | SecurityException e) {
- throw new IllegalStateException("LineEnding.GIT_ATTRIBUTES requires the spotless-lib-extra library, but it is not on the classpath", e);
- }
- }
- // gitAttributesPolicyCreator will always be nonnull at this point
- return gitAttributesPolicyCreator.apply(projectDir, toFormat);
+ return createPolicy();
+ }
+ try {
+ Class<?> clazz = Class.forName("com.diffplug.spotless.extra.GitAttributesLineEndings");
+ Method method = clazz.getMethod(gitAttributesMethod, File.class, Supplier.class);
+ return ThrowingEx.get(() -> (Policy) method.invoke(null, projectDir, toFormat));
+ } catch (ClassNotFoundException | NoSuchMethodException | SecurityException e) {
+ throw new IllegalStateException("LineEnding.GIT_ATTRIBUTES requires the spotless-lib-extra library, but it is not on the classpath", e);
  }
  }
 
- private static volatile @Nullable BiFunction<File, Supplier<Iterable<File>>, Policy> gitAttributesPolicyCreator;
-
  // @formatter:off
  /** Should use {@link #createPolicy(File, Supplier)} instead, but this will work iff its a path-independent LineEnding policy. */
  public Policy createPolicy() {
  switch (this) {
  case PLATFORM_NATIVE: return _platformNativePolicy;
  case WINDOWS: return WINDOWS_POLICY;
  case UNIX: return UNIX_POLICY;
- case MAC_CLASSIC: return MAC_CLASSIC_POLICY;
+ case MAC_CLASSIC: return MAC_CLASSIC_POLICY;
  default: throw new UnsupportedOperationException(this + " is a path-specific line ending.");
  }
  }
@@ -121,7 +124,7 @@ public String str() {
  case PLATFORM_NATIVE: return _platformNative;
  case WINDOWS: return "\r\n";
  case UNIX: return "\n";
- case MAC_CLASSIC: return "\r";
+ case MAC_CLASSIC: return "\r";
  default: throw new UnsupportedOperationException(this + " is a path-specific line ending.");
  }
  }

plugin-gradle/CHANGES.md

@@ -13,6 +13,9 @@ We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (
 * Fixed support for plugins when using Prettier version `3.0.0` and newer. ([#1802](https://github.com/diffplug/spotless/pull/1802))
 ### Changes
 * Bump default `ktlint` version to latest `0.50.0` -> `1.0.0`. ([#1808](https://github.com/diffplug/spotless/pull/1808))
+* **POSSIBLY BREAKING** the default line endings are now `GIT_ATTRIBUTES_FAST_ALLSAME` instead of `GIT_ATTRIBUTES`. ([#1838](https://github.com/diffplug/spotless/pull/1838))
+ * If all the files within a format have the same line endings, then there is no change in behavior.
+ * Fixes large performance regression. ([#1527](https://github.com/diffplug/spotless/issues/1527))
 
 ## [6.21.0] - 2023-08-29
 ### Added

plugin-gradle/README.md

@@ -1425,12 +1425,12 @@ spotless {
  encoding 'Cp1252' // except java, which will be Cp1252
 ```
 
-Line endings can also be set globally or per-format using the `lineEndings` property. Spotless supports four line ending modes: `UNIX`, `WINDOWS`, `MAC_CLASSIC`, `PLATFORM_NATIVE`, and `GIT_ATTRIBUTES`. The default value is `GIT_ATTRIBUTES`, and *we highly recommend that you* ***do not change*** *this value*. Git has opinions about line endings, and if Spotless and git disagree, then you're going to have a bad time.
+Line endings can also be set globally or per-format using the `lineEndings` property. Spotless supports four line ending modes: `UNIX`, `WINDOWS`, `MAC_CLASSIC`, `PLATFORM_NATIVE`, `GIT_ATTRIBUTES`, and `GIT_ATTRIBUTES_FAST_ALLSAME`. The default value is `GIT_ATTRIBUTES_FAST_ALLSAME`, and *we highly recommend that you* ***do not change*** *this value*. Git has opinions about line endings, and if Spotless and git disagree, then you're going to have a bad time. `FAST_ALLSAME` just means that Spotless can assume that every file being formatted has the same line endings ([more info](https://github.com/diffplug/spotless/pull/1838)).
 
 You can easily set the line endings of different files using [a `.gitattributes` file](https://help.github.com/articles/dealing-with-line-endings/). Here's an example `.gitattributes` which sets all files to unix newlines: `* text eol=lf`.
 
 <a name="custom"></a>
-<a name="custom-rulwa"></a>
+<a name="custom-steps"></a>
 
 ## Custom steps
 

plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java

@@ -57,7 +57,7 @@ RegisterDependenciesTask getRegisterDependenciesTask() {
  }
 
  /** Line endings (if any). */
- LineEnding lineEndings = LineEnding.GIT_ATTRIBUTES;
+ LineEnding lineEndings = LineEnding.GIT_ATTRIBUTES_FAST_ALLSAME;
 
  public LineEnding getLineEndings() {
  return lineEndings;

plugin-maven/CHANGES.md

@@ -28,6 +28,9 @@ We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (
 ### Changes
 * Bump default `flexmark` version to latest `0.64.0` -> `0.64.8`. ([#1801](https://github.com/diffplug/spotless/pull/1801))
 * Bump default `ktlint` version to latest `0.50.0` -> `1.0.0`. ([#1808](https://github.com/diffplug/spotless/pull/1808))
+* **POSSIBLY BREAKING** the default line endings are now `GIT_ATTRIBUTES_FAST_ALLSAME` instead of `GIT_ATTRIBUTES`. ([#1838](https://github.com/diffplug/spotless/pull/1838))
+ * If all the files within a format have the same line endings, then there is no change in behavior.
+ * Fixes large performance regression. ([#1527](https://github.com/diffplug/spotless/issues/1527))
 
 ## [2.39.0] - 2023-08-29
 ### Added

plugin-maven/README.md

@@ -1586,7 +1586,7 @@ Spotless uses UTF-8 by default, but you can use [any encoding which Java support
 </configuration>
 ```
 
-Line endings can also be set globally or per-format using the `lineEndings` property. Spotless supports four line ending modes: `UNIX`, `WINDOWS`, `MAC_CLASSIC`, `PLATFORM_NATIVE`, and `GIT_ATTRIBUTES`. The default value is `GIT_ATTRIBUTES`, and *we highly recommend that you* ***do not change*** *this value*. Git has opinions about line endings, and if Spotless and git disagree, then you're going to have a bad time.
+Line endings can also be set globally or per-format using the `lineEndings` property. Spotless supports four line ending modes: `UNIX`, `WINDOWS`, `MAC_CLASSIC`, `PLATFORM_NATIVE`, `GIT_ATTRIBUTES`, and `GIT_ATTRIBUTES_FAST_ALLSAME`. The default value is `GIT_ATTRIBUTES_FAST_ALLSAME`, and *we highly recommend that you* ***do not change*** *this value*. Git has opinions about line endings, and if Spotless and git disagree, then you're going to have a bad time. `FAST_ALLSAME` just means that Spotless can assume that every file being formatted has the same line endings ([more info](https://github.com/diffplug/spotless/pull/1838)).
 
 You can easily set the line endings of different files using [a `.gitattributes` file](https://help.github.com/articles/dealing-with-line-endings/). Here's an example `.gitattributes` which sets all files to unix newlines: `* text eol=lf`.
 

plugin-maven/src/main/java/com/diffplug/spotless/maven/AbstractSpotlessMojo.java

@@ -80,7 +80,7 @@
 public abstract class AbstractSpotlessMojo extends AbstractMojo {
  private static final String DEFAULT_INDEX_FILE_NAME = "spotless-index";
  private static final String DEFAULT_ENCODING = "UTF-8";
- private static final String DEFAULT_LINE_ENDINGS = "GIT_ATTRIBUTES";
+ private static final String DEFAULT_LINE_ENDINGS = "GIT_ATTRIBUTES_FAST_ALLSAME";
 
  /** Value to allow unsetting the ratchet inherited from parent pom configuration. */
  static final String RATCHETFROM_NONE = "NONE";