486 lines
21 KiB
Java
486 lines
21 KiB
Java
package lombok.core.configuration;
|
|
|
|
import com.zwitserloot.cmdreader.CmdReader;
|
|
import com.zwitserloot.cmdreader.Description;
|
|
import com.zwitserloot.cmdreader.Excludes;
|
|
import com.zwitserloot.cmdreader.FullName;
|
|
import com.zwitserloot.cmdreader.InvalidCommandLineException;
|
|
import com.zwitserloot.cmdreader.Mandatory;
|
|
import com.zwitserloot.cmdreader.Requires;
|
|
import com.zwitserloot.cmdreader.Sequential;
|
|
import com.zwitserloot.cmdreader.Shorthand;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.PrintStream;
|
|
import java.net.URI;
|
|
import java.util.ArrayDeque;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.Deque;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.TreeMap;
|
|
import java.util.TreeSet;
|
|
import lombok.ConfigurationKeys;
|
|
import lombok.core.LombokApp;
|
|
import lombok.core.configuration.ConfigurationKeysLoader;
|
|
import lombok.core.configuration.ConfigurationParser;
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp.SCL.lombok */
|
|
public class ConfigurationApp extends LombokApp {
|
|
private PrintStream out = System.out;
|
|
private PrintStream err = System.err;
|
|
private static final URI NO_CONFIG = URI.create("");
|
|
private static final ConfigurationProblemReporter VOID = new AnonymousClass1();
|
|
|
|
/* renamed from: lombok.core.configuration.ConfigurationApp$1 reason: invalid class name */
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp$1.SCL.lombok */
|
|
class AnonymousClass1 implements ConfigurationProblemReporter {
|
|
AnonymousClass1() {
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationProblemReporter
|
|
public void report(String str, String str2, int i, CharSequence charSequence) {
|
|
}
|
|
}
|
|
|
|
/* renamed from: lombok.core.configuration.ConfigurationApp$2 reason: invalid class name */
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp$2.SCL.lombok */
|
|
class AnonymousClass2 implements ConfigurationProblemReporter {
|
|
private final /* synthetic */ List val$problems;
|
|
|
|
AnonymousClass2(List list) {
|
|
this.val$problems = list;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationProblemReporter
|
|
public void report(String str, String str2, int i, CharSequence charSequence) {
|
|
this.val$problems.add(String.format("%s: %s (%s:%d)", str2, charSequence, str, Integer.valueOf(i)));
|
|
}
|
|
}
|
|
|
|
/* renamed from: lombok.core.configuration.ConfigurationApp$3 reason: invalid class name */
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp$3.SCL.lombok */
|
|
class AnonymousClass3 implements ConfigurationParser.Collector {
|
|
private final /* synthetic */ Deque val$round;
|
|
private final /* synthetic */ Collection val$keys;
|
|
private final /* synthetic */ Map val$result;
|
|
|
|
AnonymousClass3(Deque deque, Collection collection, Map map) {
|
|
this.val$round = deque;
|
|
this.val$keys = collection;
|
|
this.val$result = map;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationParser.Collector
|
|
public void addImport(ConfigurationFile configurationFile, ConfigurationFile configurationFile2, int i) {
|
|
this.val$round.push(new Source(configurationFile, String.valueOf(configurationFile.description()) + " (imported from " + configurationFile2.description() + ":" + i + ")"));
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationParser.Collector
|
|
public void clear(ConfigurationKey<?> configurationKey, ConfigurationFile configurationFile, int i) {
|
|
trace(configurationKey, "clear " + configurationKey.getKeyName(), i);
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationParser.Collector
|
|
public void set(ConfigurationKey<?> configurationKey, Object obj, ConfigurationFile configurationFile, int i) {
|
|
trace(configurationKey, String.valueOf(configurationKey.getKeyName()) + " = " + obj, i);
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationParser.Collector
|
|
public void add(ConfigurationKey<?> configurationKey, Object obj, ConfigurationFile configurationFile, int i) {
|
|
trace(configurationKey, String.valueOf(configurationKey.getKeyName()) + " += " + obj, i);
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationParser.Collector
|
|
public void remove(ConfigurationKey<?> configurationKey, Object obj, ConfigurationFile configurationFile, int i) {
|
|
trace(configurationKey, String.valueOf(configurationKey.getKeyName()) + " -= " + obj, i);
|
|
}
|
|
|
|
private void trace(ConfigurationKey<?> configurationKey, String str, int i) {
|
|
if (this.val$keys.contains(configurationKey) || configurationKey == ConfigurationKeys.STOP_BUBBLING) {
|
|
List list = (List) this.val$result.get(configurationKey);
|
|
if (list == null) {
|
|
list = new ArrayList();
|
|
this.val$result.put(configurationKey, list);
|
|
}
|
|
list.add(String.format("%4d: %s", Integer.valueOf(i), str));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: lombok.core.configuration.ConfigurationApp$4 reason: invalid class name */
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp$4.SCL.lombok */
|
|
class AnonymousClass4 implements Comparator<URI> {
|
|
AnonymousClass4() {
|
|
}
|
|
|
|
public int compare(URI uri, URI uri2) {
|
|
return uri.toString().compareTo(uri2.toString());
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp$CmdArgs.SCL.lombok */
|
|
public static class CmdArgs {
|
|
@Mandatory(onlyIfNot = {"help", "generate"})
|
|
@Description("Paths to java files or directories the configuration is to be printed for.")
|
|
@Sequential
|
|
private List<String> paths = new ArrayList();
|
|
@Excludes({"paths"})
|
|
@Description("Generates a list containing all the available configuration parameters. Add --verbose to print more information.")
|
|
@Shorthand({"g"})
|
|
boolean generate = false;
|
|
@Description("Displays more information.")
|
|
@Shorthand({"v"})
|
|
boolean verbose = false;
|
|
@Requires({"verbose"})
|
|
@Description("Also display files that don't mention the key.")
|
|
@Shorthand({"n"})
|
|
@FullName("not-mentioned")
|
|
boolean notMentioned = false;
|
|
@Description("Limit the result to these keys.")
|
|
@Shorthand({"k"})
|
|
private List<String> key = new ArrayList();
|
|
@Description("Shows this help text.")
|
|
@Shorthand({"h", "?"})
|
|
boolean help = false;
|
|
|
|
static /* synthetic */ List access$0(CmdArgs cmdArgs) {
|
|
return cmdArgs.key;
|
|
}
|
|
|
|
static /* synthetic */ List access$1(CmdArgs cmdArgs) {
|
|
return cmdArgs.paths;
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118106.apk:lombok/core/configuration/ConfigurationApp$Source.SCL.lombok */
|
|
private static final class Source {
|
|
final ConfigurationFile file;
|
|
final String description;
|
|
|
|
Source(ConfigurationFile configurationFile, String str) {
|
|
this.file = configurationFile;
|
|
this.description = str;
|
|
}
|
|
}
|
|
|
|
@Override // lombok.core.LombokApp
|
|
public String getAppName() {
|
|
return "config";
|
|
}
|
|
|
|
@Override // lombok.core.LombokApp
|
|
public String getAppDescription() {
|
|
return "Prints the configurations for the provided paths to standard out.";
|
|
}
|
|
|
|
@Override // lombok.core.LombokApp
|
|
public List<String> getAppAliases() {
|
|
return Arrays.asList("configuration", "config", "conf", "settings");
|
|
}
|
|
|
|
@Override // lombok.core.LombokApp
|
|
public int runApp(List<String> list) throws Exception {
|
|
CmdReader of = CmdReader.of(CmdArgs.class);
|
|
try {
|
|
CmdArgs cmdArgs = (CmdArgs) of.make((String[]) list.toArray(new String[0]));
|
|
if (cmdArgs.help) {
|
|
this.out.println(of.generateCommandLineHelp("java -jar lombok.jar configuration"));
|
|
return 0;
|
|
}
|
|
ConfigurationKeysLoader.LoaderLoader.loadAllConfigurationKeys();
|
|
Collection<ConfigurationKey<?>> checkKeys = checkKeys(CmdArgs.access$0(cmdArgs));
|
|
if (checkKeys == null) {
|
|
return 1;
|
|
}
|
|
boolean z2 = cmdArgs.verbose;
|
|
if (cmdArgs.generate) {
|
|
return generate(checkKeys, z2, !CmdArgs.access$0(cmdArgs).isEmpty());
|
|
}
|
|
return display(checkKeys, z2, CmdArgs.access$1(cmdArgs), !CmdArgs.access$0(cmdArgs).isEmpty(), cmdArgs.notMentioned);
|
|
} catch (InvalidCommandLineException e) {
|
|
this.err.println(e.getMessage());
|
|
this.err.println(of.generateCommandLineHelp("java -jar lombok.jar configuration"));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public ConfigurationApp redirectOutput(PrintStream printStream, PrintStream printStream2) {
|
|
if (printStream != null) {
|
|
this.out = printStream;
|
|
}
|
|
if (printStream2 != null) {
|
|
this.err = printStream2;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public int generate(Collection<ConfigurationKey<?>> collection, boolean z2, boolean z3) {
|
|
Iterator<ConfigurationKey<?>> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
ConfigurationKey<?> next = it.next();
|
|
if (z3 || !next.isHidden()) {
|
|
String keyName = next.getKeyName();
|
|
ConfigurationDataType type = next.getType();
|
|
String description = next.getDescription();
|
|
boolean z4 = description != null && !description.isEmpty();
|
|
if (!z2) {
|
|
this.out.println(keyName);
|
|
if (z4) {
|
|
this.out.print(" ");
|
|
this.out.println(description);
|
|
}
|
|
this.out.println();
|
|
} else {
|
|
this.out.printf("##%n## Key : %s%n## Type: %s%n", keyName, type);
|
|
if (z4) {
|
|
this.out.printf("##%n## %s%n", description);
|
|
}
|
|
this.out.printf("##%n## Examples:%n#%n", new Object[0]);
|
|
this.out.printf("# clear %s%n", keyName);
|
|
String exampleValue = type.getParser().exampleValue();
|
|
if (type.isList()) {
|
|
this.out.printf("# %s += %s%n", keyName, exampleValue);
|
|
this.out.printf("# %s -= %s%n", keyName, exampleValue);
|
|
} else {
|
|
this.out.printf("# %s = %s%n", keyName, exampleValue);
|
|
}
|
|
this.out.printf("#%n%n", new Object[0]);
|
|
}
|
|
}
|
|
}
|
|
if (z2) {
|
|
return 0;
|
|
}
|
|
this.out.println("Use --verbose for more information.");
|
|
return 0;
|
|
}
|
|
|
|
public int display(Collection<ConfigurationKey<?>> collection, boolean z2, Collection<String> collection2, boolean z3, boolean z4) throws Exception {
|
|
TreeMap<URI, Set<String>> findSharedDirectories = findSharedDirectories(collection2);
|
|
if (findSharedDirectories == null) {
|
|
return 1;
|
|
}
|
|
Set<String> remove = findSharedDirectories.remove(NO_CONFIG);
|
|
if (remove != null) {
|
|
if (remove.size() == 1) {
|
|
this.out.printf("No 'lombok.config' found for '%s'.%n", remove.iterator().next());
|
|
} else {
|
|
this.out.println("No 'lombok.config' found for: ");
|
|
Iterator<String> it = remove.iterator();
|
|
while (it.hasNext()) {
|
|
this.out.printf("- %s%n", it.next());
|
|
}
|
|
}
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
AnonymousClass2 r0 = new AnonymousClass2(arrayList);
|
|
FileSystemSourceCache fileSystemSourceCache = new FileSystemSourceCache();
|
|
ConfigurationParser configurationParser = new ConfigurationParser(r0);
|
|
boolean z5 = true;
|
|
Iterator<Map.Entry<URI, Set<String>>> it2 = findSharedDirectories.entrySet().iterator();
|
|
while (it2.hasNext()) {
|
|
Map.Entry<URI, Set<String>> next = it2.next();
|
|
if (!z5) {
|
|
this.out.printf("%n%n", new Object[0]);
|
|
}
|
|
Set<String> value = next.getValue();
|
|
if (value.size() != 1) {
|
|
this.out.printf("Configuration for:%n", new Object[0]);
|
|
Iterator<String> it3 = value.iterator();
|
|
while (it3.hasNext()) {
|
|
this.out.printf("- %s%n", it3.next());
|
|
}
|
|
this.out.println();
|
|
} else if (collection2.size() != 1) {
|
|
this.out.printf("Configuration for '%s'.%n%n", value.iterator().next());
|
|
}
|
|
URI key = next.getKey();
|
|
BubblingConfigurationResolver bubblingConfigurationResolver = new BubblingConfigurationResolver(fileSystemSourceCache.forUri(key), fileSystemSourceCache.fileToSource(configurationParser));
|
|
Map<ConfigurationKey<?>, ? extends Collection<String>> trace = trace(collection, key, z4);
|
|
boolean z6 = false;
|
|
Iterator<ConfigurationKey<?>> it4 = collection.iterator();
|
|
while (it4.hasNext()) {
|
|
ConfigurationKey<?> next2 = it4.next();
|
|
Object resolve = bubblingConfigurationResolver.resolve(next2);
|
|
Collection<String> collection3 = (Collection) trace.get(next2);
|
|
if (!collection3.isEmpty() || z3) {
|
|
if (z6 && z2) {
|
|
this.out.println();
|
|
}
|
|
printValue(next2, resolve, z2, collection3);
|
|
z6 = true;
|
|
}
|
|
}
|
|
if (!z6) {
|
|
this.out.println("<default>");
|
|
}
|
|
z5 = false;
|
|
}
|
|
if (arrayList.isEmpty()) {
|
|
return 0;
|
|
}
|
|
this.err.printf("Problems in the configuration files:%n", new Object[0]);
|
|
Iterator it5 = arrayList.iterator();
|
|
while (it5.hasNext()) {
|
|
this.err.printf("- %s%n", (String) it5.next());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private void printValue(ConfigurationKey<?> configurationKey, Object obj, boolean z2, Collection<String> collection) {
|
|
if (z2) {
|
|
this.out.printf("# %s%n", configurationKey.getDescription());
|
|
}
|
|
if (obj == null) {
|
|
this.out.printf("clear %s%n", configurationKey.getKeyName());
|
|
} else if (obj instanceof List) {
|
|
List list = (List) obj;
|
|
if (list.isEmpty()) {
|
|
this.out.printf("clear %s%n", configurationKey.getKeyName());
|
|
}
|
|
Iterator it = list.iterator();
|
|
while (it.hasNext()) {
|
|
this.out.printf("%s += %s%n", configurationKey.getKeyName(), it.next());
|
|
}
|
|
} else {
|
|
this.out.printf("%s = %s%n", configurationKey.getKeyName(), obj);
|
|
}
|
|
if (z2) {
|
|
Iterator<String> it2 = collection.iterator();
|
|
while (it2.hasNext()) {
|
|
this.out.printf("# %s%n", it2.next());
|
|
}
|
|
}
|
|
}
|
|
|
|
private Map<ConfigurationKey<?>, ? extends Collection<String>> trace(Collection<ConfigurationKey<?>> collection, URI uri, boolean z2) throws Exception {
|
|
HashMap hashMap = new HashMap();
|
|
Iterator<ConfigurationKey<?>> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
hashMap.put(it.next(), new ArrayList());
|
|
}
|
|
HashSet hashSet = new HashSet();
|
|
boolean z3 = false;
|
|
HashSet hashSet2 = new HashSet();
|
|
for (ConfigurationFile forDirectory = ConfigurationFile.forDirectory(new File(uri)); forDirectory != null && !z3; forDirectory = forDirectory.parent()) {
|
|
if (forDirectory.exists()) {
|
|
ArrayDeque arrayDeque = new ArrayDeque();
|
|
arrayDeque.push(new Source(forDirectory, forDirectory.description()));
|
|
while (!arrayDeque.isEmpty()) {
|
|
Source pop = arrayDeque.pop();
|
|
if (pop != null && hashSet2.add(pop.file) && pop.file.exists()) {
|
|
Map<ConfigurationKey<?>, List<String>> trace = trace(pop.file, collection, arrayDeque);
|
|
z3 = stopBubbling(trace.get(ConfigurationKeys.STOP_BUBBLING));
|
|
Iterator<ConfigurationKey<?>> it2 = collection.iterator();
|
|
while (it2.hasNext()) {
|
|
ConfigurationKey<?> next = it2.next();
|
|
List<String> list = trace.get(next);
|
|
if (list == null) {
|
|
list = new ArrayList<>();
|
|
if (z2) {
|
|
list.add("");
|
|
list.add(String.valueOf(pop.description) + ":");
|
|
list.add(" <'" + next.getKeyName() + "' not mentioned>");
|
|
}
|
|
} else {
|
|
hashSet.add(next);
|
|
list.add(0, String.valueOf(pop.description) + ":");
|
|
list.add(0, "");
|
|
}
|
|
((List) hashMap.get(next)).addAll(0, list);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Iterator<ConfigurationKey<?>> it3 = collection.iterator();
|
|
while (it3.hasNext()) {
|
|
ConfigurationKey<?> next2 = it3.next();
|
|
if (hashSet.contains(next2)) {
|
|
List list2 = (List) hashMap.get(next2);
|
|
list2.remove(0);
|
|
if (z3) {
|
|
String str = (String) list2.get(0);
|
|
list2.set(0, String.valueOf(str.substring(0, str.length() - 1)) + " (stopped bubbling):");
|
|
}
|
|
} else {
|
|
hashMap.put(next2, Collections.emptyList());
|
|
}
|
|
}
|
|
return hashMap;
|
|
}
|
|
|
|
private Map<ConfigurationKey<?>, List<String>> trace(ConfigurationFile configurationFile, Collection<ConfigurationKey<?>> collection, Deque<Source> deque) throws IOException {
|
|
HashMap hashMap = new HashMap();
|
|
new ConfigurationParser(VOID).parse(configurationFile, new AnonymousClass3(deque, collection, hashMap));
|
|
return hashMap;
|
|
}
|
|
|
|
private boolean stopBubbling(List<String> list) {
|
|
return list != null && !list.isEmpty() && list.get(list.size() - 1).endsWith("true");
|
|
}
|
|
|
|
private Collection<ConfigurationKey<?>> checkKeys(List<String> list) {
|
|
Map<String, ConfigurationKey<?>> registeredKeys = ConfigurationKey.registeredKeys();
|
|
if (list.isEmpty()) {
|
|
return registeredKeys.values();
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
Iterator<String> it = list.iterator();
|
|
while (it.hasNext()) {
|
|
String next = it.next();
|
|
ConfigurationKey<?> configurationKey = registeredKeys.get(next);
|
|
if (configurationKey == null) {
|
|
this.err.printf("Unknown key '%s'%n", next);
|
|
return null;
|
|
}
|
|
arrayList.remove(configurationKey);
|
|
arrayList.add(configurationKey);
|
|
}
|
|
return arrayList;
|
|
}
|
|
|
|
private TreeMap<URI, Set<String>> findSharedDirectories(Collection<String> collection) {
|
|
TreeMap<URI, Set<String>> treeMap = new TreeMap<>(new AnonymousClass4());
|
|
Iterator<String> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
String next = it.next();
|
|
File file = new File(next);
|
|
if (!file.exists()) {
|
|
this.err.printf("File not found: '%s'%n", next);
|
|
return null;
|
|
}
|
|
URI findFirstLombokDirectory = findFirstLombokDirectory(file);
|
|
Set<String> set = treeMap.get(findFirstLombokDirectory);
|
|
if (set == null) {
|
|
set = new TreeSet<>();
|
|
treeMap.put(findFirstLombokDirectory, set);
|
|
}
|
|
set.add(next);
|
|
}
|
|
return treeMap;
|
|
}
|
|
|
|
private URI findFirstLombokDirectory(File file) {
|
|
File file2 = new File(file.toURI().normalize());
|
|
if (file.isFile()) {
|
|
file2 = file2.getParentFile();
|
|
}
|
|
while (file2 != null) {
|
|
if (new File(file2, "lombok.config").exists()) {
|
|
return file2.toURI();
|
|
}
|
|
file2 = file2.getParentFile();
|
|
}
|
|
return NO_CONFIG;
|
|
}
|
|
}
|