-
Notifications
You must be signed in to change notification settings - Fork 435
/
JavaExtension.java
258 lines (214 loc) · 7.99 KB
/
JavaExtension.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/*
* Copyright 2016-2022 DiffPlug
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.diffplug.gradle.spotless;
import static com.diffplug.gradle.spotless.PluginGradlePreconditions.requireElementsNonNull;
import java.io.File;
import java.util.Objects;
import javax.inject.Inject;
import org.gradle.api.GradleException;
import org.gradle.api.Project;
import org.gradle.api.file.FileCollection;
import org.gradle.api.plugins.JavaPluginConvention;
import org.gradle.api.tasks.SourceSet;
import com.diffplug.spotless.FormatterStep;
import com.diffplug.spotless.extra.EclipseBasedStepBuilder;
import com.diffplug.spotless.extra.java.EclipseJdtFormatterStep;
import com.diffplug.spotless.generic.LicenseHeaderStep;
import com.diffplug.spotless.java.GoogleJavaFormatStep;
import com.diffplug.spotless.java.ImportOrderStep;
import com.diffplug.spotless.java.PalantirJavaFormatStep;
import com.diffplug.spotless.java.RemoveUnusedImportsStep;
public class JavaExtension extends FormatExtension implements HasBuiltinDelimiterForLicense {
static final String NAME = "java";
@Inject
public JavaExtension(SpotlessExtension spotless) {
super(spotless);
}
// If this constant changes, don't forget to change the similarly-named one in
// testlib/src/test/java/com/diffplug/spotless/generic/LicenseHeaderStepTest.java as well
static final String LICENSE_HEADER_DELIMITER = "package ";
@Override
public LicenseHeaderConfig licenseHeader(String licenseHeader) {
return licenseHeader(licenseHeader, LICENSE_HEADER_DELIMITER);
}
@Override
public LicenseHeaderConfig licenseHeaderFile(Object licenseHeaderFile) {
return licenseHeaderFile(licenseHeaderFile, LICENSE_HEADER_DELIMITER);
}
public ImportOrderConfig importOrder(String... importOrder) {
return new ImportOrderConfig(importOrder);
}
public ImportOrderConfig importOrderFile(Object importOrderFile) {
Objects.requireNonNull(importOrderFile);
return new ImportOrderConfig(getProject().file(importOrderFile));
}
public class ImportOrderConfig {
final String[] importOrder;
final File importOrderFile;
boolean wildcardsLast = false;
ImportOrderConfig(String[] importOrder) {
this.importOrder = importOrder;
importOrderFile = null;
addStep(createStep());
}
ImportOrderConfig(File importOrderFile) {
importOrder = null;
this.importOrderFile = importOrderFile;
addStep(createStep());
}
/** Sorts wildcard imports after non-wildcard imports, instead of before. */
public ImportOrderConfig wildcardsLast() {
return wildcardsLast(true);
}
public ImportOrderConfig wildcardsLast(boolean wildcardsLast) {
this.wildcardsLast = wildcardsLast;
replaceStep(createStep());
return this;
}
private FormatterStep createStep() {
ImportOrderStep importOrderStep = ImportOrderStep.forJava();
return importOrderFile != null
? importOrderStep.createFrom(wildcardsLast, getProject().file(importOrderFile))
: importOrderStep.createFrom(wildcardsLast, importOrder);
}
}
/** Removes any unused imports. */
public void removeUnusedImports() {
addStep(RemoveUnusedImportsStep.create(provisioner()));
}
/** Uses the <a href="https://github.com/google/google-java-format">google-java-format</a> jar to format source code. */
public GoogleJavaFormatConfig googleJavaFormat() {
return googleJavaFormat(GoogleJavaFormatStep.defaultVersion());
}
/**
* Uses the given version of <a href="https://github.com/google/google-java-format">google-java-format</a> to format source code.
*
* Limited to published versions. See <a href="https://github.com/diffplug/spotless/issues/33#issuecomment-252315095">issue #33</a>
* for an workaround for using snapshot versions.
*/
public GoogleJavaFormatConfig googleJavaFormat(String version) {
Objects.requireNonNull(version);
return new GoogleJavaFormatConfig(version);
}
public class GoogleJavaFormatConfig {
final String version;
String groupArtifact;
String style;
boolean reflowLongStrings;
GoogleJavaFormatConfig(String version) {
this.version = Objects.requireNonNull(version);
this.groupArtifact = GoogleJavaFormatStep.defaultGroupArtifact();
this.style = GoogleJavaFormatStep.defaultStyle();
addStep(createStep());
}
public GoogleJavaFormatConfig groupArtifact(String groupArtifact) {
this.groupArtifact = Objects.requireNonNull(groupArtifact);
replaceStep(createStep());
return this;
}
public GoogleJavaFormatConfig style(String style) {
this.style = Objects.requireNonNull(style);
replaceStep(createStep());
return this;
}
public GoogleJavaFormatConfig aosp() {
return style("AOSP");
}
public GoogleJavaFormatConfig reflowLongStrings() {
return reflowLongStrings(true);
}
public GoogleJavaFormatConfig reflowLongStrings(boolean reflowLongStrings) {
this.reflowLongStrings = reflowLongStrings;
replaceStep(createStep());
return this;
}
private FormatterStep createStep() {
return GoogleJavaFormatStep.create(
groupArtifact,
version,
style,
provisioner(),
reflowLongStrings);
}
}
/** Uses the <a href="https://github.com/palantir/palantir-java-format">palantir-java-format</a> jar to format source code. */
public PalantirJavaFormatConfig palantirJavaFormat() {
return palantirJavaFormat(PalantirJavaFormatStep.defaultVersion());
}
/**
* Uses the given version of <a href="https://github.com/palantir/palantir-java-format">palantir-java-format</a> to format source code.
*
* Limited to published versions. See <a href="https://github.com/diffplug/spotless/issues/33#issuecomment-252315095">issue #33</a>
* for an workaround for using snapshot versions.
*/
public PalantirJavaFormatConfig palantirJavaFormat(String version) {
Objects.requireNonNull(version);
return new PalantirJavaFormatConfig(version);
}
public class PalantirJavaFormatConfig {
final String version;
PalantirJavaFormatConfig(String version) {
this.version = Objects.requireNonNull(version);
addStep(createStep());
}
private FormatterStep createStep() {
return PalantirJavaFormatStep.create(version, provisioner());
}
}
public EclipseConfig eclipse() {
return new EclipseConfig(EclipseJdtFormatterStep.defaultVersion());
}
public EclipseConfig eclipse(String version) {
return new EclipseConfig(version);
}
public class EclipseConfig {
private final EclipseBasedStepBuilder builder;
EclipseConfig(String version) {
builder = EclipseJdtFormatterStep.createBuilder(provisioner());
builder.setVersion(version);
addStep(builder.build());
}
public void configFile(Object... configFiles) {
requireElementsNonNull(configFiles);
Project project = getProject();
builder.setPreferences(project.files(configFiles).getFiles());
replaceStep(builder.build());
}
}
/** If the user hasn't specified the files yet, we'll assume he/she means all of the java files. */
@Override
protected void setupTask(SpotlessTask task) {
if (target == null) {
JavaPluginConvention javaPlugin = getProject().getConvention().findPlugin(JavaPluginConvention.class);
if (javaPlugin == null) {
throw new GradleException("You must either specify 'target' manually or apply the 'java' plugin.");
}
FileCollection union = getProject().files();
for (SourceSet sourceSet : javaPlugin.getSourceSets()) {
union = union.plus(sourceSet.getAllJava());
}
target = union;
}
steps.replaceAll(step -> {
if (isLicenseHeaderStep(step)) {
return step.filterByFile(LicenseHeaderStep.unsupportedJvmFilesFilter());
} else {
return step;
}
});
super.setupTask(task);
}
}