Skip to content

Commit 2085159

Browse files
fvghfvgh
committed
First draft for JDT clean-up.
1 parent 777d0b7 commit 2085159

11 files changed

+695
-159
lines changed

‎_ext/eclipse-jdt/build.gradle

+13
Original file line numberDiff line numberDiff line change
@@ -10,9 +10,22 @@ ext {
1010

1111
dependencies {
1212
compile "com.diffplug.spotless:spotless-eclipse-base:${VER_SPOTLESS_ECLISPE_BASE}"
13+
/*
14+
* JDT core manipulation required for clean-up base interfaces and import sorting
15+
* It depends on JDT core, which is required for fomatting.
16+
*/
1317
compile("org.eclipse.jdt:org.eclipse.jdt.core.manipulation:${VER_ECLIPSE_JDT_CORE_MANIPULATION}") {
1418
exclude group: 'org.eclipse.jdt', module: 'org.eclipse.jdt.launching'
1519
exclude group: 'org.eclipse.platform', module: 'org.eclipse.ant.core'
1620
exclude group: 'org.eclipse.platform', module: 'org.eclipse.core.expressions'
1721
}
22+
/*
23+
* JDT UI required for clean-up.
24+
* Only the org.eclipse.jdt.internal.corext.fix package is required.
25+
* All dependencies (like SWT) are excluded.
26+
*/
27+
compile("org.eclipse.jdt:org.eclipse.jdt.ui:${VER_ECLIPSE_JDT_UI}") {
28+
exclude group: 'org.eclipse.platform'
29+
exclude group: 'org.eclipse.jdt'
30+
}
1831
}

‎_ext/eclipse-jdt/gradle.properties

+3-2
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
# Mayor/Minor versions correspond to the minimum Eclipse version supported/tested.
22
# Patch version is incremented for backward compatible patches of this library.
3-
ext_version=4.11.0
3+
ext_version=4.12.0
44
ext_artifactId=spotless-eclipse-jdt
55
ext_description=Eclipse's JDT formatter bundled for Spotless
66

@@ -12,4 +12,5 @@ ext_VER_JAVA=1.8
1212

1313
# Compile
1414
VER_ECLIPSE_JDT_CORE_MANIPULATION=[1.11.0,2.0.0[
15-
VER_SPOTLESS_ECLISPE_BASE=[3.0.0,4.0.0[
15+
VER_ECLIPSE_JDT_UI=[3.18.0,4.0.0[
16+
VER_SPOTLESS_ECLISPE_BASE=[3.2.0,4.0.0[

‎_ext/eclipse-jdt/src/main/java/com/diffplug/spotless/extra/eclipse/java/CleanUpFactory.java

+216
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,216 @@
1+
/*
2+
* Copyright 2016 DiffPlug
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package com.diffplug.spotless.extra.eclipse.java;
17+
18+
import java.io.IOException;
19+
import java.io.InputStream;
20+
import java.lang.reflect.Constructor;
21+
import java.lang.reflect.InvocationTargetException;
22+
import java.net.URL;
23+
import java.util.ArrayList;
24+
import java.util.Collections;
25+
import java.util.HashMap;
26+
import java.util.LinkedHashMap;
27+
import java.util.LinkedList;
28+
import java.util.List;
29+
import java.util.Map;
30+
import java.util.Optional;
31+
import java.util.Properties;
32+
import java.util.Set;
33+
import java.util.stream.Collectors;
34+
35+
import javax.xml.parsers.ParserConfigurationException;
36+
import javax.xml.parsers.SAXParser;
37+
import javax.xml.parsers.SAXParserFactory;
38+
import javax.xml.xpath.XPathExpressionException;
39+
40+
import org.assertj.core.util.Sets;
41+
import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
42+
import org.eclipse.jdt.internal.corext.fix.CleanUpConstantsOptions;
43+
import org.eclipse.jdt.ui.cleanup.CleanUpOptions;
44+
import org.eclipse.jdt.ui.cleanup.ICleanUp;
45+
import org.slf4j.Logger;
46+
import org.slf4j.LoggerFactory;
47+
import org.xml.sax.Attributes;
48+
import org.xml.sax.SAXException;
49+
import org.xml.sax.helpers.DefaultHandler;
50+
51+
/** Provides configured clean-up implementations. */
52+
final class CleanUpFactory {
53+
54+
private final static Set<String> UNSUPPORTED_CLASSES = Collections.unmodifiableSet(Sets.newLinkedHashSet(
55+
"org.eclipse.jdt.internal.ui.fix.UnimplementedCodeCleanUp" //Would require Eclipse templates
56+
));
57+
58+
@SuppressWarnings("serial")
59+
private final static Map<String, FixedValue> UNSUPPORTED_CONFIG = Collections.unmodifiableMap(new HashMap<String, FixedValue>() {
60+
{
61+
put(CleanUpConstants.REMOVE_UNUSED_CODE_IMPORTS, new FixedValue("false", "Unused import clean-up only works in case all imports can be resolved. As an alternative use: " + CleanUpConstants.ORGANIZE_IMPORTS));
62+
}
63+
});
64+
65+
private final static String CLEAN_UP_CONFIG_FILE_NAME = "plugin.xml";
66+
private final static String CLEAN_UP_CONFIG_DEPENDENCY_NAME = "org.eclipse.jdt.ui";
67+
private static List<Constructor<? extends ICleanUp>> CLEAN_UP_SEQUENCE = null;
68+
private final CleanUpOptions options;
69+
70+
CleanUpFactory(Properties settings) {
71+
options = new CleanUpOptions();
72+
Logger logger = LoggerFactory.getLogger(CleanUpFactory.class);
73+
CleanUpConstantsOptions.setDefaultOptions(CleanUpConstants.DEFAULT_CLEAN_UP_OPTIONS, options);
74+
UNSUPPORTED_CONFIG.entrySet().stream().forEach(entry -> options.setOption(entry.getKey(), entry.getValue().value));
75+
settings.forEach((key, value) -> {
76+
FixedValue fixed = UNSUPPORTED_CONFIG.get(key);
77+
if (null != fixed && fixed.value != value) {
78+
logger.warn(String.format("Using %s for %s instead of %s: %s", fixed.value, key, value, fixed.reason));
79+
} else {
80+
options.setOption(key.toString(), value.toString());
81+
}
82+
});
83+
try {
84+
initializeCleanupActions();
85+
} catch (IOException | ParserConfigurationException | XPathExpressionException e) {
86+
throw new RuntimeException("Faild to read Eclipse Clean-Up configuration.", e);
87+
}
88+
}
89+
90+
private static synchronized void initializeCleanupActions() throws IOException, ParserConfigurationException, XPathExpressionException {
91+
if (null != CLEAN_UP_SEQUENCE) {
92+
return;
93+
}
94+
ClassLoader loader = CleanUpFactory.class.getClassLoader();
95+
Optional<URL> configUrl = Collections.list(loader.getResources(CLEAN_UP_CONFIG_FILE_NAME)).stream().filter(url -> url.getPath().contains(CLEAN_UP_CONFIG_DEPENDENCY_NAME)).findAny();
96+
if (!configUrl.isPresent()) {
97+
throw new RuntimeException("Could not find JAR containing " + CLEAN_UP_CONFIG_DEPENDENCY_NAME + ":" + CLEAN_UP_CONFIG_FILE_NAME);
98+
}
99+
InputStream configXmlStream = configUrl.get().openStream();
100+
try {
101+
SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();
102+
CleanUpExtensionHandler handler = new CleanUpExtensionHandler();
103+
saxParser.parse(configXmlStream, handler);
104+
CLEAN_UP_SEQUENCE = handler.getCleanUpSequence();
105+
} catch (SAXException e) {
106+
//Add information about the XML location
107+
throw new RuntimeException("Failed to parse " + configUrl.get().toExternalForm(), e);
108+
}
109+
}
110+
111+
public List<ICleanUp> create() {
112+
return CLEAN_UP_SEQUENCE.stream().map(constructor -> {
113+
try {
114+
ICleanUp cleanUp = constructor.newInstance();
115+
cleanUp.setOptions(options);
116+
return cleanUp;
117+
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
118+
throw new RuntimeException("Failed to created clean-up action for " + constructor.getName(), e);
119+
}
120+
}).collect(Collectors.toList());
121+
}
122+
123+
private static class FixedValue {
124+
public final String value;
125+
public final String reason;
126+
127+
FixedValue(String value, String reason) {
128+
this.value = value;
129+
this.reason = reason;
130+
}
131+
};
132+
133+
private final static class CleanUpExtensionHandler extends DefaultHandler {
134+
private final static String CLEAN_UP_ELEMENT_NAME = "cleanUp";
135+
private final static String ID_ATTRIBUTE_NAME = "id";
136+
private final static String CLASS_ATTRIBUTE_NAME = "class";
137+
private final static String RUN_AFTER_ATTRIBUTE_NAME = "runAfter";
138+
private final Map<String, Constructor<? extends ICleanUp>> constructor;
139+
private final Map<String, String> runAfter;
140+
private final LinkedList<String> sorted;
141+
142+
CleanUpExtensionHandler() {
143+
constructor = new HashMap<>();
144+
runAfter = new LinkedHashMap<>(); //E.g. the elements are already sorted
145+
sorted = new LinkedList<>();
146+
}
147+
148+
@Override
149+
public void startDocument() throws SAXException {
150+
constructor.clear();
151+
runAfter.clear();
152+
sorted.clear();
153+
super.startDocument();
154+
}
155+
156+
@Override
157+
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
158+
if (CLEAN_UP_ELEMENT_NAME == qName) {
159+
String id = getMandatoryAttribute(attributes, ID_ATTRIBUTE_NAME);
160+
String className = getMandatoryAttribute(attributes, CLASS_ATTRIBUTE_NAME);
161+
if (!UNSUPPORTED_CLASSES.contains(className)) {
162+
try {
163+
Class<?> clazz = Class.forName(className);
164+
Class<? extends ICleanUp> clazzImplementsICleanUp = clazz.asSubclass(ICleanUp.class);
165+
constructor.put(id, clazzImplementsICleanUp.getConstructor());
166+
} catch (ClassNotFoundException | ClassCastException | NoSuchMethodException | SecurityException e) {
167+
throw new SAXException("Failed to obtain constructor for " + CLEAN_UP_ELEMENT_NAME + " element class " + className, e);
168+
}
169+
}
170+
String runAfterId = attributes.getValue(RUN_AFTER_ATTRIBUTE_NAME);
171+
if (null == runAfterId) {
172+
sorted.push(id);
173+
} else {
174+
runAfter.put(id, runAfterId);
175+
}
176+
}
177+
super.startElement(uri, localName, qName, attributes);
178+
}
179+
180+
private static String getMandatoryAttribute(Attributes attributes, String qName) throws SAXException {
181+
String value = attributes.getValue(qName);
182+
if (null == value) {
183+
throw new SAXException(CLEAN_UP_ELEMENT_NAME + " element without " + qName + " attribute.");
184+
}
185+
return value;
186+
}
187+
188+
@Override
189+
public void endDocument() throws SAXException {
190+
if (runAfter.isEmpty()) {
191+
throw new SAXException(CLEAN_UP_ELEMENT_NAME + " element has not been found in XML.");
192+
}
193+
while (!runAfter.isEmpty()) {
194+
//E.g. the elements are already sorted. Hence only one iteration is expected.
195+
List<String> foundEntries = new ArrayList<>(runAfter.size());
196+
for (Map.Entry<String, String> entry : runAfter.entrySet()) {
197+
int runAfterIndex = sorted.lastIndexOf(entry.getValue());
198+
if (0 <= runAfterIndex) {
199+
foundEntries.add(entry.getKey());
200+
sorted.add(runAfterIndex + 1, entry.getKey());
201+
}
202+
}
203+
foundEntries.forEach(e -> runAfter.remove(e));
204+
if (foundEntries.isEmpty()) {
205+
throw new SAXException(CLEAN_UP_ELEMENT_NAME + " element the following precessor IDs cannot be resolved: " + runAfter.values().stream().collect(Collectors.joining("; ")));
206+
}
207+
}
208+
super.endDocument();
209+
}
210+
211+
public List<Constructor<? extends ICleanUp>> getCleanUpSequence() {
212+
return sorted.stream().map(id -> constructor.get(id)).filter(clazz -> null != clazz).collect(Collectors.toList());
213+
}
214+
}
215+
216+
}

0 commit comments

Comments
 (0)