411 lines
14 KiB
Java
411 lines
14 KiB
Java
package lombok.core.configuration;
|
|
|
|
import com.adjust.sdk.Constants;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.net.URI;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ConcurrentMap;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
import java.util.zip.ZipEntry;
|
|
import java.util.zip.ZipInputStream;
|
|
/* loaded from: com.discord-118107.apk:lombok/core/configuration/ConfigurationFile.SCL.lombok */
|
|
public abstract class ConfigurationFile {
|
|
private static final String LOMBOK_CONFIG_FILENAME = "lombok.config";
|
|
private final String identifier;
|
|
private static final Pattern VARIABLE = Pattern.compile("\\<(.+?)\\>");
|
|
private static final Map<String, String> ENV = new HashMap(System.getenv());
|
|
private static final ThreadLocal<byte[]> buffers = new AnonymousClass1();
|
|
|
|
/* renamed from: lombok.core.configuration.ConfigurationFile$1 reason: invalid class name */
|
|
/* loaded from: com.discord-118107.apk:lombok/core/configuration/ConfigurationFile$1.SCL.lombok */
|
|
class AnonymousClass1 extends ThreadLocal<byte[]> {
|
|
AnonymousClass1() {
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
/* JADX WARN: Can't rename method to resolve collision */
|
|
@Override // java.lang.ThreadLocal
|
|
public byte[] initialValue() {
|
|
return new byte[65536];
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/core/configuration/ConfigurationFile$ArchivedConfigurationFile.SCL.lombok */
|
|
private static class ArchivedConfigurationFile extends ConfigurationFile {
|
|
private static final URI ROOT1 = URI.create("http://x.y/a/");
|
|
private static final URI ROOT2 = URI.create("ftp://y.x/b/");
|
|
private static final ConcurrentMap<String, Object> locks = new ConcurrentHashMap();
|
|
private final File archive;
|
|
private final URI file;
|
|
private final Object lock;
|
|
private long lastModified = -2;
|
|
private String contents;
|
|
|
|
public static ConfigurationFile create(File file, URI uri) {
|
|
if (!isRelative(uri)) {
|
|
return null;
|
|
}
|
|
return new ArchivedConfigurationFile(file, uri, String.valueOf(file.getPath()) + "!" + uri.getPath());
|
|
}
|
|
|
|
static boolean isRelative(URI uri) {
|
|
try {
|
|
if (ROOT1.resolve(uri).toString().startsWith(ROOT1.toString())) {
|
|
return ROOT2.resolve(uri).toString().startsWith(ROOT2.toString());
|
|
}
|
|
return false;
|
|
} catch (Exception unused) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
ArchivedConfigurationFile(File file, URI uri, String str) {
|
|
super(str, null);
|
|
this.archive = file;
|
|
this.file = uri;
|
|
locks.putIfAbsent(file.getPath(), new Object());
|
|
this.lock = locks.get(file.getPath());
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
long getLastModifiedOrMissing() {
|
|
return getLastModifiedOrMissing(this.archive);
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Unknown variable types count: 1 */
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
*/
|
|
boolean exists() {
|
|
boolean z2;
|
|
if (!ConfigurationFile.access$1(this.archive)) {
|
|
return false;
|
|
}
|
|
?? r0 = this.lock;
|
|
synchronized (r0) {
|
|
try {
|
|
readIfNeccesary();
|
|
r0 = this.contents;
|
|
z2 = r0 != 0;
|
|
} catch (Exception unused) {
|
|
return false;
|
|
}
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Unknown variable types count: 1 */
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
*/
|
|
CharSequence contents() throws IOException {
|
|
?? r0 = this.lock;
|
|
synchronized (r0) {
|
|
readIfNeccesary();
|
|
r0 = this.contents;
|
|
}
|
|
return r0;
|
|
}
|
|
|
|
void readIfNeccesary() throws IOException {
|
|
long lastModifiedOrMissing = getLastModifiedOrMissing();
|
|
if (lastModifiedOrMissing != this.lastModified) {
|
|
this.contents = null;
|
|
this.lastModified = lastModifiedOrMissing;
|
|
if (lastModifiedOrMissing != -88) {
|
|
this.contents = read();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Finally extract failed */
|
|
private String read() throws IOException {
|
|
ZipEntry nextEntry;
|
|
FileInputStream fileInputStream = new FileInputStream(this.archive);
|
|
try {
|
|
ZipInputStream zipInputStream = new ZipInputStream(fileInputStream);
|
|
do {
|
|
nextEntry = zipInputStream.getNextEntry();
|
|
if (nextEntry == null) {
|
|
zipInputStream.close();
|
|
fileInputStream.close();
|
|
return null;
|
|
}
|
|
} while (!nextEntry.getName().equals(this.file.getPath()));
|
|
String access$2 = ConfigurationFile.access$2(zipInputStream);
|
|
zipInputStream.close();
|
|
fileInputStream.close();
|
|
return access$2;
|
|
} catch (Throwable th) {
|
|
fileInputStream.close();
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
public ConfigurationFile resolve(String str) {
|
|
try {
|
|
URI resolve = this.file.resolve(str);
|
|
if (!isRelative(resolve)) {
|
|
return null;
|
|
}
|
|
return create(this.archive, resolve);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
ConfigurationFile parent() {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/core/configuration/ConfigurationFile$CharSequenceConfigurationFile.SCL.lombok */
|
|
private static class CharSequenceConfigurationFile extends ConfigurationFile {
|
|
private final CharSequence contents;
|
|
private final long lastModified;
|
|
|
|
private CharSequenceConfigurationFile(String str, CharSequence charSequence, long j) {
|
|
super(str, null);
|
|
this.contents = charSequence;
|
|
this.lastModified = j;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
long getLastModifiedOrMissing() {
|
|
return this.lastModified;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
CharSequence contents() throws IOException {
|
|
return this.contents;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
boolean exists() {
|
|
return true;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
public ConfigurationFile resolve(String str) {
|
|
return null;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
ConfigurationFile parent() {
|
|
return null;
|
|
}
|
|
|
|
/* synthetic */ CharSequenceConfigurationFile(String str, CharSequence charSequence, long j, CharSequenceConfigurationFile charSequenceConfigurationFile) {
|
|
this(str, charSequence, j);
|
|
}
|
|
}
|
|
|
|
/* loaded from: com.discord-118107.apk:lombok/core/configuration/ConfigurationFile$RegularConfigurationFile.SCL.lombok */
|
|
private static class RegularConfigurationFile extends ConfigurationFile {
|
|
private final File file;
|
|
|
|
private RegularConfigurationFile(File file) {
|
|
super(file.getPath(), null);
|
|
this.file = file;
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
boolean exists() {
|
|
return ConfigurationFile.access$1(this.file);
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
public ConfigurationFile resolve(String str) {
|
|
if (str.endsWith("!")) {
|
|
return null;
|
|
}
|
|
String[] split = str.split("!");
|
|
if (split.length > 2) {
|
|
return null;
|
|
}
|
|
String str2 = split[0];
|
|
File resolveFile = resolveFile(replaceEnvironmentVariables(str2));
|
|
if (str2.endsWith(".zip") || str2.endsWith(".jar")) {
|
|
try {
|
|
return ArchivedConfigurationFile.create(resolveFile, URI.create(split.length == 1 ? ConfigurationFile.LOMBOK_CONFIG_FILENAME : split[1]));
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
} else if (split.length <= 1 && resolveFile != null) {
|
|
return forFile(resolveFile);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private File resolveFile(String str) {
|
|
char lowerCase;
|
|
boolean z2 = false;
|
|
int indexOf = str.indexOf(58);
|
|
if (indexOf != -1) {
|
|
if (indexOf != 1 || str.indexOf(58, indexOf + 1) != -1 || (lowerCase = Character.toLowerCase(str.charAt(0))) < 'a' || lowerCase > 'z') {
|
|
return null;
|
|
}
|
|
z2 = true;
|
|
}
|
|
if (str.charAt(0) == '/') {
|
|
z2 = true;
|
|
}
|
|
try {
|
|
return z2 ? new File(str) : new File(this.file.toURI().resolve(str));
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
long getLastModifiedOrMissing() {
|
|
return getLastModifiedOrMissing(this.file);
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
CharSequence contents() throws IOException {
|
|
FileInputStream fileInputStream = new FileInputStream(this.file);
|
|
try {
|
|
return ConfigurationFile.access$2(fileInputStream);
|
|
} finally {
|
|
fileInputStream.close();
|
|
}
|
|
}
|
|
|
|
@Override // lombok.core.configuration.ConfigurationFile
|
|
ConfigurationFile parent() {
|
|
File parentFile = this.file.getParentFile().getParentFile();
|
|
if (parentFile == null) {
|
|
return null;
|
|
}
|
|
return forDirectory(parentFile);
|
|
}
|
|
|
|
private static String replaceEnvironmentVariables(String str) {
|
|
int i = 0;
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
if (str.startsWith("~")) {
|
|
i = 1;
|
|
stringBuffer.append(System.getProperty("user.home", "~"));
|
|
}
|
|
Matcher matcher = ConfigurationFile.access$3().matcher(str.substring(i));
|
|
while (matcher.find()) {
|
|
String group = matcher.group(1);
|
|
String str2 = (String) ConfigurationFile.access$4().get(group);
|
|
if (str2 == null) {
|
|
str2 = "<" + group + ">";
|
|
}
|
|
matcher.appendReplacement(stringBuffer, str2);
|
|
}
|
|
matcher.appendTail(stringBuffer);
|
|
return stringBuffer.toString();
|
|
}
|
|
|
|
/* synthetic */ RegularConfigurationFile(File file, RegularConfigurationFile regularConfigurationFile) {
|
|
this(file);
|
|
}
|
|
}
|
|
|
|
static void setEnvironment(String str, String str2) {
|
|
ENV.put(str, str2);
|
|
}
|
|
|
|
public static ConfigurationFile forFile(File file) {
|
|
return new RegularConfigurationFile(file, null);
|
|
}
|
|
|
|
public static ConfigurationFile forDirectory(File file) {
|
|
return forFile(new File(file, LOMBOK_CONFIG_FILENAME));
|
|
}
|
|
|
|
public static ConfigurationFile fromCharSequence(String str, CharSequence charSequence, long j) {
|
|
return new CharSequenceConfigurationFile(str, charSequence, j, null);
|
|
}
|
|
|
|
private ConfigurationFile(String str) {
|
|
this.identifier = str;
|
|
}
|
|
|
|
abstract long getLastModifiedOrMissing();
|
|
|
|
abstract boolean exists();
|
|
|
|
abstract CharSequence contents() throws IOException;
|
|
|
|
public abstract ConfigurationFile resolve(String str);
|
|
|
|
abstract ConfigurationFile parent();
|
|
|
|
final String description() {
|
|
return this.identifier;
|
|
}
|
|
|
|
public final boolean equals(Object obj) {
|
|
if (!(obj instanceof ConfigurationFile)) {
|
|
return false;
|
|
}
|
|
return this.identifier.equals(((ConfigurationFile) obj).identifier);
|
|
}
|
|
|
|
public final int hashCode() {
|
|
return this.identifier.hashCode();
|
|
}
|
|
|
|
public static long getLastModifiedOrMissing(File file) {
|
|
if (!fileExists(file)) {
|
|
return -88L;
|
|
}
|
|
return file.lastModified();
|
|
}
|
|
|
|
private static boolean fileExists(File file) {
|
|
return file.exists() && file.isFile();
|
|
}
|
|
|
|
private static String read(InputStream inputStream) throws IOException {
|
|
byte[] bArr = buffers.get();
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
|
|
while (true) {
|
|
int read = inputStream.read(bArr);
|
|
if (read == -1) {
|
|
return new String(byteArrayOutputStream.toByteArray(), Constants.ENCODING);
|
|
}
|
|
byteArrayOutputStream.write(bArr, 0, read);
|
|
}
|
|
}
|
|
|
|
/* synthetic */ ConfigurationFile(String str, ConfigurationFile configurationFile) {
|
|
this(str);
|
|
}
|
|
|
|
static /* synthetic */ boolean access$1(File file) {
|
|
return fileExists(file);
|
|
}
|
|
|
|
static /* synthetic */ String access$2(InputStream inputStream) throws IOException {
|
|
return read(inputStream);
|
|
}
|
|
|
|
static /* synthetic */ Pattern access$3() {
|
|
return VARIABLE;
|
|
}
|
|
|
|
static /* synthetic */ Map access$4() {
|
|
return ENV;
|
|
}
|
|
}
|