Rework step mapping of Eclipse JDT formatter

Author: arouel

lib-extra/src/jdt/java/com/diffplug/spotless/extra/glue/jdt/EclipseJdtSortMembers.java

@@ -236,11 +236,11 @@ static class SortProperties {
 		}
 
 		static SortProperties from(Map<String, String> properties) {
-			boolean enabled = Boolean.parseBoolean(properties.getOrDefault("members.order.enabled", "false"));
-			String membersOrder = properties.getOrDefault("members.order", "");
-			boolean doNotSortFields = Boolean.parseBoolean(properties.getOrDefault("members.doNotSortFields", "true"));
-			boolean sortByVisibility = Boolean.parseBoolean(properties.getOrDefault("visibility.order.enabled", "false"));
-			String visibilityOrder = properties.getOrDefault("visibility.order", "");
+			boolean enabled = Boolean.parseBoolean(properties.getOrDefault("sp_cleanup.sort_members", "false"));
+			String membersOrder = properties.getOrDefault("outlinesortoption", "");
+			boolean doNotSortFields = !Boolean.parseBoolean(properties.getOrDefault("sp_cleanup.sort_members_all", "false"));
+			boolean sortByVisibility = Boolean.parseBoolean(properties.getOrDefault("org.eclipse.jdt.ui.enable.visibility.order", "false"));
+			String visibilityOrder = properties.getOrDefault("org.eclipse.jdt.ui.visibility.order", "");
 			return new SortProperties(enabled, membersOrder, doNotSortFields, sortByVisibility, visibilityOrder);
 		}
 	}

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

@@ -74,17 +74,6 @@ protected P2Model model(String version) {
 			return model;
 		}
 
-		public void setMembersOrdering(String order, boolean doNotSortFields) {
-			stepProperties.put("members.order.enabled", "true");
-			stepProperties.put("members.order", order);
-			stepProperties.put("members.doNotSortFields", Boolean.toString(doNotSortFields));
-		}
-
-		public void setVisibilityOrdering(String order) {
-			stepProperties.put("visibility.order.enabled", "true");
-			stepProperties.put("visibility.order", order);
-		}
-
 		@Override
 		public void setVersion(String version) {
 			if (version.endsWith(".0")) {
@@ -94,5 +83,26 @@ public void setVersion(String version) {
 			}
 			super.setVersion(version);
 		}
+
+		public void sortMembersDoNotSortFields(boolean doNotSortFields) {
+			boolean sortAllMembers = !doNotSortFields;
+			stepProperties.put("sp_cleanup.sort_members_all", String.valueOf(sortAllMembers));
+		}
+
+		public void sortMembersEnabled(boolean enabled) {
+			stepProperties.put("sp_cleanup.sort_members", String.valueOf(enabled));
+		}
+
+		public void sortMembersOrder(String order) {
+			stepProperties.put("outlinesortoption", order);
+		}
+
+		public void sortMembersVisibilityOrder(String order) {
+			stepProperties.put("org.eclipse.jdt.ui.visibility.order", order);
+		}
+
+		public void sortMembersVisibilityOrderEnabled(boolean enabled) {
+			stepProperties.put("org.eclipse.jdt.ui.enable.visibility.order", String.valueOf(enabled));
+		}
 	}
 }

lib-extra/src/test/java/com/diffplug/spotless/extra/java/EclipseJdtFormatterStepSpecialCaseTest.java

@@ -39,49 +39,63 @@ void issue_1638() {
 	@Test
 	void sort_members_global_by_visibility() {
 		EclipseJdtFormatterStep.Builder builder = EclipseJdtFormatterStep.createBuilder(TestProvisioner.mavenCentral());
-		builder.setMembersOrdering("SF,SI,SM,F,I,C,M,T", false);
-		builder.setVisibilityOrdering("B,R,D,V");
+		builder.sortMembersEnabled(true);
+		builder.sortMembersOrder("SF,SI,SM,F,I,C,M,T");
+		builder.sortMembersDoNotSortFields(false);
+		builder.sortMembersVisibilityOrderEnabled(true);
+		builder.sortMembersVisibilityOrder("B,R,D,V");
 		StepHarness.forStep(builder.build())
 				.testResource("java/eclipse/SortExample.test", "java/eclipse/SortExample.sortMembersByVisibility.clean");
 	}
 
 	@Test
 	void sort_members_global_enabled() {
 		EclipseJdtFormatterStep.Builder builder = EclipseJdtFormatterStep.createBuilder(TestProvisioner.mavenCentral());
-		builder.setMembersOrdering("SF,SI,SM,F,I,C,M,T", false);
+		builder.sortMembersEnabled(true);
+		builder.sortMembersOrder("SF,SI,SM,F,I,C,M,T");
+		builder.sortMembersDoNotSortFields(false);
 		StepHarness.forStep(builder.build())
 				.testResource("java/eclipse/SortExample.test", "java/eclipse/SortExample.sortMembers.clean");
 	}
 
 	@Test
 	void sort_members_global_no_fields() {
 		EclipseJdtFormatterStep.Builder builder = EclipseJdtFormatterStep.createBuilder(TestProvisioner.mavenCentral());
-		builder.setMembersOrdering("SF,SI,SM,F,I,C,M,T", true);
+		builder.sortMembersEnabled(true);
+		builder.sortMembersOrder("SF,SI,SM,F,I,C,M,T");
+		builder.sortMembersDoNotSortFields(true);
 		StepHarness.forStep(builder.build())
 				.testResource("java/eclipse/SortExample.test", "java/eclipse/SortExample.sortMembersNoFields.clean");
 	}
 
 	@Test
 	void sort_members_local_by_visibility() {
 		EclipseJdtFormatterStep.Builder builder = EclipseJdtFormatterStep.createBuilder(TestProvisioner.mavenCentral());
-		builder.setMembersOrdering("SF,SI,SM,F,I,C,M,T", false);
-		builder.setVisibilityOrdering("B,R,D,V");
+		builder.sortMembersEnabled(true);
+		builder.sortMembersOrder("SF,SI,SM,F,I,C,M,T");
+		builder.sortMembersDoNotSortFields(false);
+		builder.sortMembersVisibilityOrderEnabled(true);
+		builder.sortMembersVisibilityOrder("B,R,D,V");
 		StepHarness.forStep(builder.build())
 				.testResource("java/eclipse/SortExample.localSortByVisibility.test", "java/eclipse/SortExample.localSortByVisibility.clean");
 	}
 
 	@Test
 	void sort_members_local_enabled_false() {
 		EclipseJdtFormatterStep.Builder builder = EclipseJdtFormatterStep.createBuilder(TestProvisioner.mavenCentral());
-		builder.setMembersOrdering("SF,SI,SM,F,I,C,M,T", false);
+		builder.sortMembersEnabled(true);
+		builder.sortMembersOrder("SF,SI,SM,F,I,C,M,T");
+		builder.sortMembersDoNotSortFields(false);
 		StepHarness.forStep(builder.build())
 				.testResource("java/eclipse/SortExample.localEnabledFalse.test", "java/eclipse/SortExample.localEnabledFalse.clean");
 	}
 
 	@Test
 	void sort_members_local_no_fields() {
 		EclipseJdtFormatterStep.Builder builder = EclipseJdtFormatterStep.createBuilder(TestProvisioner.mavenCentral());
-		builder.setMembersOrdering("SF,SI,SM,F,I,C,M,T", false);
+		builder.sortMembersEnabled(true);
+		builder.sortMembersOrder("SF,SI,SM,F,I,C,M,T");
+		builder.sortMembersDoNotSortFields(false);
 		StepHarness.forStep(builder.build())
 				.testResource("java/eclipse/SortExample.localDoNotSortFields.test", "java/eclipse/SortExample.localDoNotSortFields.clean");
 	}

plugin-gradle/README.md

@@ -275,28 +275,32 @@ control system). It is turned off by default, but you might want to consider ena
 for a project.
 
 The format to specify the sort order follows the `outlinesortoption` and `org.eclipse.jdt.ui.visibility.order`
-properties that can be found in the workspace folder of your Eclipse IDE. Look up the
+properties that can be found in the workspace folder of your Eclipse IDE. You can look at the
 file `.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.ui.prefs` in your workspace directory.
 
 ###### Define Sort Members settings on project level
 
 ```gradle
 spotless {
   java {
-    // specify the sort order of the member categories
-    // SF,SI,SM,F,I,C,M,T = Static Fields, Static Initializers, Static Methods, Fields, Initializers, Constructors, Methods, (Nested) Types
-    val memberCategoryOrder = "SF,SI,SM,F,I,C,M,T"
-    val doNotSortFields = true
-    eclipse().sortMembers(memberCategoryOrder, doNotSortFields)
-    // optional: specify ordering of members of the same category by the visibility within the category
-    // B,R,D,V = Public, Protected, Package, Private
-    val visibilityOrder = "B,R,D,V"
-    eclipse().sortMembers(memberCategoryOrder, doNotSortFields, visibilityOrder)
+    eclipse()
+      // Optional: Enable the Sort Members feature globally. (default: false)
+      .sortMembersEnabled(true)
+      // Optional: Specify the sort order of the member categories. (default: T,SF,SI,SM,F,I,C,M)
+      //   SF,SI,SM,F,I,C,M,T = Static Fields, Static Initializers, Static Methods, Fields, Initializers, Constructors, Methods, (Nested) Types
+      .sortMembersOrder("SF,SI,SM,F,I,C,M,T")
+      // Optional: Enable the reordering of fields, enum constants, and initializers. (default: true)
+      .sortMembersDoNotSortFields(false)
+      // Optional: Enable reordering of members of the same category by the visibility within the category. (default: false)
+      .sortMembersVisibilityOrderEnabled(true)
+      // Optional: Specify the ordering of members of the same category by the visibility within the category. (default: B,V,R,D)
+      //   B,R,D,V = Public, Protected, Package, Private
+      .sortMembersVisibilityOrder("B,R,D,V")
 ```
 
 ###### Overwrite Sort Members settings on file level
 
-You can enable/disable the sort properties on file level by adding the following comments:
+You can enable/disable the globally defined sort properties on file level by adding the following comments:
 - `// @SortMembers:enabled=false` - disable the Sort Members feature for this file
 - `// @SortMembers:doNotSortFields=true` - disable the sorting of static and instance fields
 - `// @SortMembers:sortByVisibility=false` - don't sort members by its visibility modifier

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

@@ -305,21 +305,34 @@ public EclipseConfig configFile(Object... configFiles) {
 			return this;
 		}
 
-		public EclipseConfig sortMembers(String memberCategoryOrder, boolean doNotSortFields) {
-			requireElementsNonNull(memberCategoryOrder);
-			builder.setMembersOrdering(memberCategoryOrder, doNotSortFields);
+		public EclipseConfig sortMembersDoNotSortFields(boolean doNotSortFields) {
+			builder.sortMembersDoNotSortFields(doNotSortFields);
 			replaceStep(builder.build());
 			return this;
 		}
 
-		public EclipseConfig sortMembers(
-				String memberCategoryOrder,
-				boolean doNotSortFields,
-				String visibilityOrder) {
-			requireElementsNonNull(memberCategoryOrder);
-			requireElementsNonNull(visibilityOrder);
-			builder.setMembersOrdering(memberCategoryOrder, doNotSortFields);
-			builder.setVisibilityOrdering(visibilityOrder);
+		public EclipseConfig sortMembersEnabled(boolean enabled) {
+			builder.sortMembersEnabled(enabled);
+			replaceStep(builder.build());
+			return this;
+		}
+
+		public EclipseConfig sortMembersOrder(String order) {
+			requireElementsNonNull(order);
+			builder.sortMembersOrder(order);
+			replaceStep(builder.build());
+			return this;
+		}
+
+		public EclipseConfig sortMembersVisibilityOrder(String order) {
+			requireElementsNonNull(order);
+			builder.sortMembersVisibilityOrder(order);
+			replaceStep(builder.build());
+			return this;
+		}
+
+		public EclipseConfig sortMembersVisibilityOrderEnabled(boolean enabled) {
+			builder.sortMembersVisibilityOrderEnabled(enabled);
 			replaceStep(builder.build());
 			return this;
 		}

plugin-maven/README.md

@@ -261,11 +261,50 @@ any other maven phase (i.e. compile) then it can be configured as below;
 
 ```xml
 <eclipse>
-  <version>4.26</version>                     <!-- optional version of Eclipse Formatter -->
-  <file>${project.basedir}/eclipse-formatter.xml</file> <!-- optional -->
+  <!-- Optional: Specify the Eclipse JDT version to use. -->
+  <version>4.26</version>
+  <!-- Optional: Specify a file which contains all formatting options. -->
+  <file>${project.basedir}/eclipse-formatter.xml</file>
 </eclipse>
 ```
 
+#### Sort Members
+
+Not only can you format your code with Eclipse JDT, but you can also sort the members as you know it from Eclipse IDE.
+This ensures that the methods are always in sorted order (and thus reduces the likelihood of collisions in a version
+control system). It is turned off by default, but you might want to consider enabling it when setting coding standards
+for a project.
+
+The format to specify the sort order follows the `outlinesortoption` and `org.eclipse.jdt.ui.visibility.order`
+properties that can be found in the workspace folder of your Eclipse IDE. You can look at the
+file `.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.ui.prefs` in your workspace directory.
+
+###### Define Sort Members settings on project level
+
+```xml
+<eclipse>
+  <!-- Optional: Enable the Sort Members feature globally. (default: false) -->
+  <sortMembersEnabled>true</sortMembersEnabled>
+  <!-- Optional: Specify the sort order of the member categories. (default: T,SF,SI,SM,F,I,C,M)
+       SF,SI,SM,F,I,C,M,T = Static Fields, Static Initializers, Static Methods, Fields, Initializers, Constructors, Methods, (Nested) Types -->
+  <sortMembersOrder>SF,SI,SM,F,I,C,M,T</sortMembersOrder>
+  <!-- Optional: Enable the reordering of fields, enum constants, and initializers. (default: true) -->
+  <sortMembersDoNotSortFields>false</sortMembersDoNotSortFields>
+  <!-- Optional: Enable reordering of members of the same category by the visibility within the category. (default: false) -->
+  <sortMembersVisibilityOrderEnabled>true</sortMembersVisibilityOrderEnabled>
+  <!-- Optional: Specify the ordering of members of the same category by the visibility within the category. (default: B,V,R,D)
+       B,R,D,V = Public, Protected, Package, Private -->
+  <sortMembersVisibilityOrder>B,R,D,V</sortMembersVisibilityOrder>
+</eclipse>
+```
+
+###### Overwrite Sort Members settings on file level
+
+You can enable/disable the globally defined sort properties on file level by adding the following comments:
+- `// @SortMembers:enabled=false` - disable the Sort Members feature for this file
+- `// @SortMembers:doNotSortFields=true` - disable the sorting of static and instance fields
+- `// @SortMembers:sortByVisibility=false` - don't sort members by its visibility modifier
+
 ### formatAnnotations
 
 Type annotations should be on the same line as the type that they qualify.

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

@@ -24,7 +24,6 @@
 import org.eclipse.aether.RepositorySystemSession;
 
 import com.diffplug.spotless.FormatterStep;
-import com.diffplug.spotless.extra.EquoBasedStepBuilder;
 import com.diffplug.spotless.extra.P2Mirror;
 import com.diffplug.spotless.extra.java.EclipseJdtFormatterStep;
 import com.diffplug.spotless.maven.FormatterStepConfig;
@@ -41,11 +40,26 @@ public class Eclipse implements FormatterStepFactory {
 	@Parameter
 	private List<P2Mirror> p2Mirrors = new ArrayList<>();
 
+	@Parameter
+	private Boolean sortMembersDoNotSortFields = true;
+
+	@Parameter
+	private Boolean sortMembersEnabled = false;
+
+	@Parameter
+	private String sortMembersOrder;
+
+	@Parameter
+	private String sortMembersVisibilityOrder;
+
+	@Parameter
+	private Boolean sortMembersVisibilityOrderEnabled = false;
+
 	private File cacheDirectory;
 
 	@Override
 	public FormatterStep newFormatterStep(FormatterStepConfig stepConfig) {
-		EquoBasedStepBuilder eclipseConfig = EclipseJdtFormatterStep.createBuilder(stepConfig.getProvisioner());
+		EclipseJdtFormatterStep.Builder eclipseConfig = EclipseJdtFormatterStep.createBuilder(stepConfig.getProvisioner());
 		eclipseConfig.setVersion(version == null ? EclipseJdtFormatterStep.defaultVersion() : version);
 		if (null != file) {
 			File settingsFile = stepConfig.getFileLocator().locateFile(file);
@@ -55,6 +69,24 @@ public FormatterStep newFormatterStep(FormatterStepConfig stepConfig) {
 		if (null != cacheDirectory) {
 			eclipseConfig.setCacheDirectory(cacheDirectory);
 		}
+		if (null != sortMembersEnabled) {
+			eclipseConfig.sortMembersEnabled(sortMembersEnabled);
+		}
+		if (null != sortMembersOrder) {
+			eclipseConfig.sortMembersOrder(sortMembersOrder);
+		}
+		if (null != sortMembersDoNotSortFields) {
+			eclipseConfig.sortMembersDoNotSortFields(sortMembersDoNotSortFields);
+		}
+		if (null != sortMembersVisibilityOrder) {
+			eclipseConfig.sortMembersVisibilityOrder(sortMembersVisibilityOrder);
+		}
+		if (null != sortMembersVisibilityOrderEnabled) {
+			eclipseConfig.sortMembersVisibilityOrderEnabled(sortMembersVisibilityOrderEnabled);
+		}
+		if (null != cacheDirectory) {
+			eclipseConfig.setCacheDirectory(cacheDirectory);
+		}
 		return eclipseConfig.build();
 	}