Plexus/Plex
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex.git synced 2025-07-05 09:06:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

move this back

Browse Source
This commit is contained in:
Taah
2022-05-04 05:19:34 -07:00
parent de13860741
commit a24aa6a962
28 changed files with 142 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
proxy/src/main/java/dev/plex/config/TomlConfig.java
View File

@ -1,8 +1,8 @@
package dev.plex.config;
import dev.plex.Plex;
import dev.plex.toml.Toml;
import dev.plex.toml.TomlWriter;
import com.moandjiezana.toml.Toml;
import com.moandjiezana.toml.TomlWriter;
import lombok.Getter;
import lombok.Setter;

65
proxy/src/main/java/dev/plex/toml/ArrayValueWriter.java
View File

@ -1,65 +0,0 @@
package dev.plex.toml;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import static dev.plex.toml.ValueWriters.WRITERS;
public abstract class ArrayValueWriter implements ValueWriter {
static protected boolean isArrayish(Object value) {
return value instanceof Collection || value.getClass().isArray();
}
@Override
public boolean isPrimitiveType() {
return false;
}
static boolean isArrayOfPrimitive(Object array) {
Object first = peek(array);
if (first != null) {
ValueWriter valueWriter = WRITERS.findWriterFor(first);
return valueWriter.isPrimitiveType() || isArrayish(first);
}
return true;
}
@SuppressWarnings("unchecked")
protected Collection<?> normalize(Object value) {
Collection<Object> collection;
if (value.getClass().isArray()) {
// Arrays.asList() interprets an array as a single element,
// so convert it to a list by hand
collection = new ArrayList<Object>(Array.getLength(value));
for (int i = 0; i < Array.getLength(value); i++) {
Object elem = Array.get(value, i);
collection.add(elem);
}
} else {
collection = (Collection<Object>) value;
}
return collection;
}
private static Object peek(Object value) {
if (value.getClass().isArray()) {
if (Array.getLength(value) > 0) {
return Array.get(value, 0);
} else {
return null;
}
} else {
Collection<?> collection = (Collection<?>) value;
if (collection.size() > 0) {
return collection.iterator().next();
}
}
return null;
}
}

48
proxy/src/main/java/dev/plex/toml/BooleanValueReaderWriter.java
View File

@ -1,48 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
class BooleanValueReaderWriter implements ValueReader, ValueWriter {
static final BooleanValueReaderWriter BOOLEAN_VALUE_READER_WRITER = new BooleanValueReaderWriter();
@Override
public boolean canRead(String s) {
return s.startsWith("true") || s.startsWith("false");
}
@Override
public Object read(String s, AtomicInteger index, Context context) {
s = s.substring(index.get());
Boolean b = s.startsWith("true") ? Boolean.TRUE : Boolean.FALSE;
int endIndex = b == Boolean.TRUE ? 4 : 5;
index.addAndGet(endIndex - 1);
return b;
}
@Override
public boolean canWrite(Object value) {
return Boolean.class.isInstance(value);
}
@Override
public void write(Object value, WriterContext context) {
context.write(value.toString());
}
@Override
public boolean isPrimitiveType() {
return true;
}
private BooleanValueReaderWriter() {}
@Override
public String toString() {
return "boolean";
}
}

122
proxy/src/main/java/dev/plex/toml/Container.java
View File

@ -1,122 +0,0 @@
package dev.plex.toml;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public abstract class Container {
abstract boolean accepts(String key);
abstract void put(String key, Object value);
abstract Object get(String key);
abstract boolean isImplicit();
static class Table extends Container {
private final Map<String, Object> values = new HashMap<String, Object>();
final String name;
final boolean implicit;
Table() {
this(null, false);
}
public Table(String name) {
this(name, false);
}
public Table(String tableName, boolean implicit) {
this.name = tableName;
this.implicit = implicit;
}
@Override
boolean accepts(String key) {
return !values.containsKey(key) || values.get(key) instanceof TableArray;
}
@Override
void put(String key, Object value) {
values.put(key, value);
}
@Override
Object get(String key) {
return values.get(key);
}
boolean isImplicit() {
return implicit;
}
/**
* This modifies the Table's internal data structure, such that it is no longer usable.
*
* Therefore, this method must only be called when all data has been gathered.
* @return A Map-and-List-based of the TOML data
*/
Map<String, Object> consume() {
for (Map.Entry<String, Object> entry : values.entrySet()) {
if (entry.getValue() instanceof Table) {
entry.setValue(((Table) entry.getValue()).consume());
} else if (entry.getValue() instanceof TableArray) {
entry.setValue(((TableArray) entry.getValue()).getValues());
}
}
return values;
}
@Override
public String toString() {
return values.toString();
}
}
static class TableArray extends Container {
private final List<Table> values = new ArrayList<Table>();
TableArray() {
values.add(new Table());
}
@Override
boolean accepts(String key) {
return getCurrent().accepts(key);
}
@Override
void put(String key, Object value) {
values.add((Table) value);
}
@Override
Object get(String key) {
throw new UnsupportedOperationException();
}
boolean isImplicit() {
return false;
}
List<Map<String, Object>> getValues() {
ArrayList<Map<String, Object>> unwrappedValues = new ArrayList<Map<String,Object>>();
for (Table table : values) {
unwrappedValues.add(table.consume());
}
return unwrappedValues;
}
Table getCurrent() {
return values.get(values.size() - 1);
}
@Override
public String toString() {
return values.toString();
}
}
private Container() {}
}

19
proxy/src/main/java/dev/plex/toml/Context.java
View File

@ -1,19 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
public class Context {
final dev.plex.toml.Identifier identifier;
final AtomicInteger line;
final Results.Errors errors;
public Context(dev.plex.toml.Identifier identifier, AtomicInteger line, Results.Errors errors) {
this.identifier = identifier;
this.line = line;
this.errors = errors;
}
public Context with(dev.plex.toml.Identifier identifier) {
return new Context(identifier, line, errors);
}
}

22
proxy/src/main/java/dev/plex/toml/DatePolicy.java
View File

@ -1,22 +0,0 @@
package dev.plex.toml;
import java.util.TimeZone;
public class DatePolicy {
private final TimeZone timeZone;
private final boolean showFractionalSeconds;
DatePolicy(TimeZone timeZone, boolean showFractionalSeconds) {
this.timeZone = timeZone;
this.showFractionalSeconds = showFractionalSeconds;
}
TimeZone getTimeZone() {
return timeZone;
}
boolean isShowFractionalSeconds() {
return showFractionalSeconds;
}
}

160
proxy/src/main/java/dev/plex/toml/DateValueReaderWriter.java
View File

@ -1,160 +0,0 @@
package dev.plex.toml;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DateValueReaderWriter implements ValueReader, ValueWriter {
static final DateValueReaderWriter DATE_VALUE_READER_WRITER = new DateValueReaderWriter();
static final DateValueReaderWriter DATE_PARSER_JDK_6 = new DateConverterJdk6();
private static final Pattern DATE_REGEX = Pattern.compile("(\\d{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9])(\\.\\d*)?(Z|(?:[+\\-]\\d{2}:\\d{2}))(.*)");
@Override
public boolean canRead(String s) {
if (s.length() < 5) {
return false;
}
for (int i = 0; i < 5; i++) {
char c = s.charAt(i);
if (i < 4) {
if (!Character.isDigit(c)) {
return false;
}
} else if (c != '-') {
return false;
}
}
return true;
}
@Override
public Object read(String original, AtomicInteger index, Context context) {
StringBuilder sb = new StringBuilder();
for (int i = index.get(); i < original.length(); i = index.incrementAndGet()) {
char c = original.charAt(i);
if (Character.isDigit(c) || c == '-' || c == '+' || c == ':' || c == '.' || c == 'T' || c == 'Z') {
sb.append(c);
} else {
index.decrementAndGet();
break;
}
}
String s = sb.toString();
Matcher matcher = DATE_REGEX.matcher(s);
if (!matcher.matches()) {
Results.Errors errors = new Results.Errors();
errors.invalidValue(context.identifier.getName(), s, context.line.get());
return errors;
}
String dateString = matcher.group(1);
String zone = matcher.group(3);
String fractionalSeconds = matcher.group(2);
String format = "yyyy-MM-dd'T'HH:mm:ss";
if (fractionalSeconds != null && !fractionalSeconds.isEmpty()) {
format += ".SSS";
dateString += fractionalSeconds;
}
format += "Z";
if ("Z".equals(zone)) {
dateString += "+0000";
} else if (zone.contains(":")) {
dateString += zone.replace(":", "");
}
try {
SimpleDateFormat dateFormat = new SimpleDateFormat(format);
dateFormat.setLenient(false);
return dateFormat.parse(dateString);
} catch (Exception e) {
Results.Errors errors = new Results.Errors();
errors.invalidValue(context.identifier.getName(), s, context.line.get());
return errors;
}
}
@Override
public boolean canWrite(Object value) {
return value instanceof Date;
}
@Override
public void write(Object value, WriterContext context) {
DateFormat formatter = getFormatter(context.getDatePolicy());
context.write(formatter.format(value));
}
@Override
public boolean isPrimitiveType() {
return true;
}
private DateFormat getFormatter(DatePolicy datePolicy) {
boolean utc = "UTC".equals(datePolicy.getTimeZone().getID());
String format;
if (utc && datePolicy.isShowFractionalSeconds()) {
format = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
} else if (utc) {
format = "yyyy-MM-dd'T'HH:mm:ss'Z'";
} else if (datePolicy.isShowFractionalSeconds()) {
format = getTimeZoneAndFractionalSecondsFormat();
} else {
format = getTimeZoneFormat();
}
SimpleDateFormat formatter = new SimpleDateFormat(format);
formatter.setTimeZone(datePolicy.getTimeZone());
return formatter;
}
String getTimeZoneFormat() {
return "yyyy-MM-dd'T'HH:mm:ssXXX";
}
String getTimeZoneAndFractionalSecondsFormat() {
return "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
}
private DateValueReaderWriter() {}
private static class DateConverterJdk6 extends DateValueReaderWriter {
@Override
public void write(Object value, WriterContext context) {
DateFormat formatter = super.getFormatter(context.getDatePolicy());
String date = formatter.format(value);
if ("UTC".equals(context.getDatePolicy().getTimeZone().getID())) {
context.write(date);
} else {
int insertionIndex = date.length() - 2;
context.write(date.substring(0, insertionIndex)).write(':').write(date.substring(insertionIndex));
}
}
@Override
String getTimeZoneAndFractionalSecondsFormat() {
return "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
}
@Override
String getTimeZoneFormat() {
return "yyyy-MM-dd'T'HH:mm:ssZ";
}
}
@Override
public String toString() {
return "datetime";
}
}

331
proxy/src/main/java/dev/plex/toml/Identifier.java
View File

@ -1,331 +0,0 @@
package dev.plex.toml;
public class Identifier
{
static final Identifier INVALID = new Identifier("", null);
private static final String ALLOWED_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_-";
private final String name;
private final Type type;
static Identifier from(String name, Context context)
{
Type type;
boolean valid;
name = name.trim();
if (name.startsWith("[["))
{
type = Type.TABLE_ARRAY;
valid = isValidTableArray(name, context);
} else if (name.startsWith("["))
{
type = Type.TABLE;
valid = isValidTable(name, context);
} else
{
type = Type.KEY;
valid = isValidKey(name, context);
}
if (!valid)
{
return Identifier.INVALID;
}
return new Identifier(extractName(name), type);
}
private Identifier(String name, Type type)
{
this.name = name;
this.type = type;
}
String getName()
{
return name;
}
String getBareName()
{
if (isKey())
{
return name;
}
if (isTable())
{
return name.substring(1, name.length() - 1);
}
return name.substring(2, name.length() - 2);
}
boolean isKey()
{
return type == Type.KEY;
}
boolean isTable()
{
return type == Type.TABLE;
}
boolean isTableArray()
{
return type == Type.TABLE_ARRAY;
}
private static enum Type
{
KEY, TABLE, TABLE_ARRAY;
}
private static String extractName(String raw)
{
boolean quoted = false;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < raw.length(); i++)
{
char c = raw.charAt(i);
if (c == '"' && (i == 0 || raw.charAt(i - 1) != '\\'))
{
quoted = !quoted;
sb.append('"');
} else if (quoted || !Character.isWhitespace(c))
{
sb.append(c);
}
}
return StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceUnicodeCharacters(sb.toString());
}
private static boolean isValidKey(String name, Context context)
{
if (name.trim().isEmpty())
{
context.errors.invalidKey(name, context.line.get());
return false;
}
boolean quoted = false;
for (int i = 0; i < name.length(); i++)
{
char c = name.charAt(i);
if (c == '"' && (i == 0 || name.charAt(i - 1) != '\\'))
{
if (!quoted && i > 0 && name.charAt(i - 1) != '.')
{
context.errors.invalidKey(name, context.line.get());
return false;
}
quoted = !quoted;
} else if (!quoted && (ALLOWED_CHARS.indexOf(c) == -1))
{
context.errors.invalidKey(name, context.line.get());
return false;
}
}
return true;
}
private static boolean isValidTable(String name, Context context)
{
boolean valid = true;
if (!name.endsWith("]"))
{
valid = false;
}
String trimmed = name.substring(1, name.length() - 1).trim();
if (trimmed.isEmpty() || trimmed.charAt(0) == '.' || trimmed.endsWith("."))
{
valid = false;
}
if (!valid)
{
context.errors.invalidTable(name, context.line.get());
return false;
}
boolean quoted = false;
boolean dotAllowed = false;
boolean quoteAllowed = true;
boolean charAllowed = true;
for (int i = 0; i < trimmed.length(); i++)
{
char c = trimmed.charAt(i);
if (!valid)
{
break;
}
if (dev.plex.toml.Keys.isQuote(c))
{
if (!quoteAllowed)
{
valid = false;
} else if (quoted && trimmed.charAt(i - 1) != '\\')
{
charAllowed = false;
dotAllowed = true;
quoteAllowed = false;
} else if (!quoted)
{
quoted = true;
quoteAllowed = true;
}
} else if (quoted)
{
continue;
} else if (c == '.')
{
if (dotAllowed)
{
charAllowed = true;
dotAllowed = false;
quoteAllowed = true;
} else
{
context.errors.emptyImplicitTable(name, context.line.get());
return false;
}
} else if (Character.isWhitespace(c))
{
char prev = trimmed.charAt(i - 1);
if (!Character.isWhitespace(prev) && prev != '.')
{
charAllowed = false;
dotAllowed = true;
quoteAllowed = true;
}
} else
{
if (charAllowed && ALLOWED_CHARS.indexOf(c) > -1)
{
charAllowed = true;
dotAllowed = true;
quoteAllowed = false;
} else
{
valid = false;
}
}
}
if (!valid)
{
context.errors.invalidTable(name, context.line.get());
return false;
}
return true;
}
private static boolean isValidTableArray(String line, Context context)
{
boolean valid = true;
if (!line.endsWith("]]"))
{
valid = false;
}
String trimmed = line.substring(2, line.length() - 2).trim();
if (trimmed.isEmpty() || trimmed.charAt(0) == '.' || trimmed.endsWith("."))
{
valid = false;
}
if (!valid)
{
context.errors.invalidTableArray(line, context.line.get());
return false;
}
boolean quoted = false;
boolean dotAllowed = false;
boolean quoteAllowed = true;
boolean charAllowed = true;
for (int i = 0; i < trimmed.length(); i++)
{
char c = trimmed.charAt(i);
if (!valid)
{
break;
}
if (c == '"')
{
if (!quoteAllowed)
{
valid = false;
} else if (quoted && trimmed.charAt(i - 1) != '\\')
{
charAllowed = false;
dotAllowed = true;
quoteAllowed = false;
} else if (!quoted)
{
quoted = true;
quoteAllowed = true;
}
} else if (quoted)
{
continue;
} else if (c == '.')
{
if (dotAllowed)
{
charAllowed = true;
dotAllowed = false;
quoteAllowed = true;
} else
{
context.errors.emptyImplicitTable(line, context.line.get());
return false;
}
} else if (Character.isWhitespace(c))
{
char prev = trimmed.charAt(i - 1);
if (!Character.isWhitespace(prev) && prev != '.' && prev != '"')
{
charAllowed = false;
dotAllowed = true;
quoteAllowed = true;
}
} else
{
if (charAllowed && ALLOWED_CHARS.indexOf(c) > -1)
{
charAllowed = true;
dotAllowed = true;
quoteAllowed = false;
} else
{
valid = false;
}
}
}
if (!valid)
{
context.errors.invalidTableArray(line, context.line.get());
return false;
}
return true;
}
}

62
proxy/src/main/java/dev/plex/toml/IdentifierConverter.java
View File

@ -1,62 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
public class IdentifierConverter {
static final IdentifierConverter IDENTIFIER_CONVERTER = new IdentifierConverter();
dev.plex.toml.Identifier convert(String s, AtomicInteger index, dev.plex.toml.Context context) {
boolean quoted = false;
StringBuilder name = new StringBuilder();
boolean terminated = false;
boolean isKey = s.charAt(index.get()) != '[';
boolean isTableArray = !isKey && s.length() > index.get() + 1 && s.charAt(index.get() + 1) == '[';
boolean inComment = false;
for (int i = index.get(); i < s.length(); i = index.incrementAndGet()) {
char c = s.charAt(i);
if (dev.plex.toml.Keys.isQuote(c) && (i == 0 || s.charAt(i - 1) != '\\')) {
quoted = !quoted;
name.append(c);
} else if (c == '\n') {
index.decrementAndGet();
break;
} else if (quoted) {
name.append(c);
} else if (c == '=' && isKey) {
terminated = true;
break;
} else if (c == ']' && !isKey) {
if (!isTableArray || s.length() > index.get() + 1 && s.charAt(index.get() + 1) == ']') {
terminated = true;
name.append(']');
if (isTableArray) {
name.append(']');
}
}
} else if (terminated && c == '#') {
inComment = true;
} else if (terminated && !Character.isWhitespace(c) && !inComment) {
terminated = false;
break;
} else if (!terminated) {
name.append(c);
}
}
if (!terminated) {
if (isKey) {
context.errors.unterminatedKey(name.toString(), context.line.get());
} else {
context.errors.invalidKey(name.toString(), context.line.get());
}
return dev.plex.toml.Identifier.INVALID;
}
return dev.plex.toml.Identifier.from(name.toString(), context);
}
private IdentifierConverter() {}
}

30
proxy/src/main/java/dev/plex/toml/IndentationPolicy.java
View File

@ -1,30 +0,0 @@
package dev.plex.toml;
/**
* Controls how a {@link TomlWriter} indents tables and key/value pairs.
*
* The default policy is to not indent.
*/
public class IndentationPolicy {
private final int tableIndent;
private final int keyValueIndent;
private final int arrayDelimiterPadding;
IndentationPolicy(int keyIndentation, int tableIndentation, int arrayDelimiterPadding) {
this.keyValueIndent = keyIndentation;
this.tableIndent = tableIndentation;
this.arrayDelimiterPadding = arrayDelimiterPadding;
}
int getTableIndent() {
return tableIndent;
}
int getKeyValueIndent() {
return keyValueIndent;
}
int getArrayDelimiterPadding() {
return arrayDelimiterPadding;
}
}

75
proxy/src/main/java/dev/plex/toml/InlineTableValueReader.java
View File

@ -1,75 +0,0 @@
package dev.plex.toml;
import java.util.HashMap;
import java.util.concurrent.atomic.AtomicInteger;
class InlineTableValueReader implements ValueReader {
static final InlineTableValueReader INLINE_TABLE_VALUE_READER = new InlineTableValueReader();
@Override
public boolean canRead(String s) {
return s.startsWith("{");
}
@Override
public Object read(String s, AtomicInteger sharedIndex, Context context) {
AtomicInteger line = context.line;
int startLine = line.get();
int startIndex = sharedIndex.get();
boolean inKey = true;
boolean inValue = false;
boolean terminated = false;
StringBuilder currentKey = new StringBuilder();
HashMap<String, Object> results = new HashMap<String, Object>();
Results.Errors errors = new Results.Errors();
for (int i = sharedIndex.incrementAndGet(); sharedIndex.get() < s.length(); i = sharedIndex.incrementAndGet()) {
char c = s.charAt(i);
if (inValue && !Character.isWhitespace(c)) {
Object converted = ValueReaders.VALUE_READERS.convert(s, sharedIndex, context.with(dev.plex.toml.Identifier.from(currentKey.toString(), context)));
if (converted instanceof Results.Errors) {
errors.add((Results.Errors) converted);
return errors;
}
String currentKeyTrimmed = currentKey.toString().trim();
Object previous = results.put(currentKeyTrimmed, converted);
if (previous != null) {
errors.duplicateKey(currentKeyTrimmed, context.line.get());
return errors;
}
currentKey = new StringBuilder();
inValue = false;
} else if (c == ',') {
inKey = true;
inValue = false;
currentKey = new StringBuilder();
} else if (c == '=') {
inKey = false;
inValue = true;
} else if (c == '}') {
terminated = true;
break;
} else if (inKey) {
currentKey.append(c);
}
}
if (!terminated) {
errors.unterminated(context.identifier.getName(), s.substring(startIndex), startLine);
}
if (errors.hasErrors()) {
return errors;
}
return results;
}
private InlineTableValueReader() {}
}

69
proxy/src/main/java/dev/plex/toml/Keys.java
View File

@ -1,69 +0,0 @@
package dev.plex.toml;
import java.util.ArrayList;
import java.util.List;
class Keys {
static class Key {
final String name;
final int index;
final String path;
Key(String name, int index, Key next) {
this.name = name;
this.index = index;
if (next != null) {
this.path = name + "." + next.path;
} else {
this.path = name;
}
}
}
static Key[] split(String key) {
List<Key> splitKey = new ArrayList<Key>();
StringBuilder current = new StringBuilder();
boolean quoted = false;
boolean indexable = true;
boolean inIndex = false;
int index = -1;
for (int i = key.length() - 1; i > -1; i--) {
char c = key.charAt(i);
if (c == ']' && indexable) {
inIndex = true;
continue;
}
indexable = false;
if (c == '[' && inIndex) {
inIndex = false;
index = Integer.parseInt(current.toString());
current = new StringBuilder();
continue;
}
if (isQuote(c) && (i == 0 || key.charAt(i - 1) != '\\')) {
quoted = !quoted;
indexable = false;
}
if (c != '.' || quoted) {
current.insert(0, c);
} else {
splitKey.add(0, new Key(current.toString(), index, !splitKey.isEmpty() ? splitKey.get(0) : null));
indexable = true;
index = -1;
current = new StringBuilder();
}
}
splitKey.add(0, new Key(current.toString(), index, !splitKey.isEmpty() ? splitKey.get(0) : null));
return splitKey.toArray(new Key[0]);
}
static boolean isQuote(char c) {
return c == '"' || c == '\'';
}
private Keys() {}
}

47
proxy/src/main/java/dev/plex/toml/LiteralStringValueReader.java
View File

@ -1,47 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
public class LiteralStringValueReader implements dev.plex.toml.ValueReader
{
public static final LiteralStringValueReader LITERAL_STRING_VALUE_READER = new LiteralStringValueReader();
@Override
public boolean canRead(String s)
{
return s.startsWith("'");
}
@Override
public Object read(String s, AtomicInteger index, Context context)
{
int startLine = context.line.get();
boolean terminated = false;
int startIndex = index.incrementAndGet();
for (int i = index.get(); i < s.length(); i = index.incrementAndGet())
{
char c = s.charAt(i);
if (c == '\'')
{
terminated = true;
break;
}
}
if (!terminated)
{
Results.Errors errors = new Results.Errors();
errors.unterminated(context.identifier.getName(), s.substring(startIndex), startLine);
return errors;
}
String substring = s.substring(startIndex, index.get());
return substring;
}
private LiteralStringValueReader()
{
}
}

166
proxy/src/main/java/dev/plex/toml/MapValueWriter.java
View File

@ -1,166 +0,0 @@
package dev.plex.toml;
import java.io.File;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class MapValueWriter implements ValueWriter
{
static final ValueWriter MAP_VALUE_WRITER = new MapValueWriter();
private static final Pattern REQUIRED_QUOTING_PATTERN = Pattern.compile("^.*[^A-Za-z\\d_-].*$");
@Override
public boolean canWrite(Object value)
{
return value instanceof Map;
}
@Override
public void write(Object value, WriterContext context)
{
File file = null;
if (context.file != null)
{
file = context.file;
}
Map<?, ?> from = (Map<?, ?>) value;
dev.plex.toml.Toml toml = null;
if (file != null)
{
toml = new Toml().read(file);
}
if (hasPrimitiveValues(from, context))
{
if (context.hasRun)
{
if (toml != null)
{
if (!toml.getValues().containsKey(context.key))
{
context.writeKey();
}
} else
{
context.writeKey();
}
}
}
// Render primitive types and arrays of primitive first so they are
// grouped under the same table (if there is one)
for (Map.Entry<?, ?> entry : from.entrySet())
{
Object key = entry.getKey();
Object fromValue = entry.getValue();
if (fromValue == null)
{
continue;
}
if (context.hasRun && toml != null)
{
if (context.key != null)
{
if (key.toString().equalsIgnoreCase(context.key)) continue;
if (toml.contains(context.key + "." + key)) continue;
}
}
ValueWriter valueWriter = ValueWriters.WRITERS.findWriterFor(fromValue);
if (valueWriter.isPrimitiveType())
{
context.indent();
context.write(quoteKey(key)).write(" = ");
valueWriter.write(fromValue, context);
context.write('\n');
} else if (valueWriter == PrimitiveArrayValueWriter.PRIMITIVE_ARRAY_VALUE_WRITER)
{
context.setArrayKey(key.toString());
context.write(quoteKey(key)).write(" = ");
valueWriter.write(fromValue, context);
context.write('\n');
}
}
// Now render (sub)tables and arrays of tables
for (Object key : from.keySet())
{
Object fromValue = from.get(key);
if (fromValue == null)
{
continue;
}
if (context.hasRun && toml != null)
{
if (context.key != null)
{
if (key.toString().equalsIgnoreCase(context.key)) continue;
if (toml.contains(context.key + "." + key)) continue;
}
}
ValueWriter valueWriter = ValueWriters.WRITERS.findWriterFor(fromValue);
if (valueWriter == this || valueWriter == ObjectValueWriter.OBJECT_VALUE_WRITER || valueWriter == TableArrayValueWriter.TABLE_ARRAY_VALUE_WRITER)
{
WriterContext context1 = context.pushTable(quoteKey(key));
context1.parentName = key.toString();
context1.hasRun = true;
context1.file = context.file;
valueWriter.write(fromValue, context1);
}
}
}
@Override
public boolean isPrimitiveType()
{
return false;
}
private static String quoteKey(Object key)
{
String stringKey = key.toString();
Matcher matcher = REQUIRED_QUOTING_PATTERN.matcher(stringKey);
if (matcher.matches())
{
stringKey = "\"" + stringKey + "\"";
}
return stringKey;
}
private static boolean hasPrimitiveValues(Map<?, ?> values, WriterContext context)
{
for (Object key : values.keySet())
{
Object fromValue = values.get(key);
if (fromValue == null)
{
continue;
}
ValueWriter valueWriter = ValueWriters.WRITERS.findWriterFor(fromValue);
if (valueWriter.isPrimitiveType() || valueWriter == PrimitiveArrayValueWriter.PRIMITIVE_ARRAY_VALUE_WRITER)
{
return true;
}
}
return false;
}
private MapValueWriter()
{
}
}

52
proxy/src/main/java/dev/plex/toml/MultilineLiteralStringValueReader.java
View File

@ -1,52 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
class MultilineLiteralStringValueReader implements dev.plex.toml.ValueReader
{
static final MultilineLiteralStringValueReader MULTILINE_LITERAL_STRING_VALUE_READER = new MultilineLiteralStringValueReader();
@Override
public boolean canRead(String s) {
return s.startsWith("'''");
}
@Override
public Object read(String s, AtomicInteger index, dev.plex.toml.Context context) {
AtomicInteger line = context.line;
int startLine = line.get();
int originalStartIndex = index.get();
int startIndex = index.addAndGet(3);
int endIndex = -1;
if (s.charAt(startIndex) == '\n') {
startIndex = index.incrementAndGet();
line.incrementAndGet();
}
for (int i = startIndex; i < s.length(); i = index.incrementAndGet()) {
char c = s.charAt(i);
if (c == '\n') {
line.incrementAndGet();
}
if (c == '\'' && s.length() > i + 2 && s.charAt(i + 1) == '\'' && s.charAt(i + 2) == '\'') {
endIndex = i;
index.addAndGet(2);
break;
}
}
if (endIndex == -1) {
Results.Errors errors = new Results.Errors();
errors.unterminated(context.identifier.getName(), s.substring(originalStartIndex), startLine);
return errors;
}
return s.substring(startIndex, endIndex);
}
private MultilineLiteralStringValueReader() {}
}

57
proxy/src/main/java/dev/plex/toml/MultilineStringValueReader.java
View File

@ -1,57 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
class MultilineStringValueReader implements dev.plex.toml.ValueReader
{
static final MultilineStringValueReader MULTILINE_STRING_VALUE_READER = new MultilineStringValueReader();
@Override
public boolean canRead(String s) {
return s.startsWith("\"\"\"");
}
@Override
public Object read(String s, AtomicInteger index, dev.plex.toml.Context context) {
AtomicInteger line = context.line;
int startLine = line.get();
int originalStartIndex = index.get();
int startIndex = index.addAndGet(3);
int endIndex = -1;
if (s.charAt(startIndex) == '\n') {
startIndex = index.incrementAndGet();
line.incrementAndGet();
}
for (int i = startIndex; i < s.length(); i = index.incrementAndGet()) {
char c = s.charAt(i);
if (c == '\n') {
line.incrementAndGet();
} else if (c == '"' && s.length() > i + 2 && s.charAt(i + 1) == '"' && s.charAt(i + 2) == '"') {
endIndex = i;
index.addAndGet(2);
break;
}
}
if (endIndex == -1) {
dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
errors.unterminated(context.identifier.getName(), s.substring(originalStartIndex), startLine);
return errors;
}
s = s.substring(startIndex, endIndex);
s = s.replaceAll("\\\\\\s+", "");
s = dev.plex.toml.StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceUnicodeCharacters(s);
s = dev.plex.toml.StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceSpecialCharacters(s);
return s;
}
private MultilineStringValueReader() {
}
}

105
proxy/src/main/java/dev/plex/toml/NumberValueReaderWriter.java
View File

@ -1,105 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
class NumberValueReaderWriter implements ValueReader, ValueWriter {
static final NumberValueReaderWriter NUMBER_VALUE_READER_WRITER = new NumberValueReaderWriter();
@Override
public boolean canRead(String s) {
char firstChar = s.charAt(0);
return firstChar == '+' || firstChar == '-' || Character.isDigit(firstChar);
}
@Override
public Object read(String s, AtomicInteger index, Context context) {
boolean signable = true;
boolean dottable = false;
boolean exponentable = false;
boolean terminatable = false;
boolean underscorable = false;
String type = "";
StringBuilder sb = new StringBuilder();
for (int i = index.get(); i < s.length(); i = index.incrementAndGet()) {
char c = s.charAt(i);
boolean notLastChar = s.length() > i + 1;
if (Character.isDigit(c)) {
sb.append(c);
signable = false;
terminatable = true;
if (type.isEmpty()) {
type = "integer";
dottable = true;
}
underscorable = notLastChar;
exponentable = !type.equals("exponent");
} else if ((c == '+' || c == '-') && signable && notLastChar) {
signable = false;
terminatable = false;
if (c == '-') {
sb.append('-');
}
} else if (c == '.' && dottable && notLastChar) {
sb.append('.');
type = "float";
terminatable = false;
dottable = false;
exponentable = false;
underscorable = false;
} else if ((c == 'E' || c == 'e') && exponentable && notLastChar) {
sb.append('E');
type = "exponent";
terminatable = false;
signable = true;
dottable = false;
exponentable = false;
underscorable = false;
} else if (c == '_' && underscorable && notLastChar && Character.isDigit(s.charAt(i + 1))) {
underscorable = false;
} else {
if (!terminatable) {
type = "";
}
index.decrementAndGet();
break;
}
}
if (type.equals("integer")) {
return Long.valueOf(sb.toString());
} else if (type.equals("float")) {
return Double.valueOf(sb.toString());
} else if (type.equals("exponent")) {
String[] exponentString = sb.toString().split("E");
return Double.parseDouble(exponentString[0]) * Math.pow(10, Double.parseDouble(exponentString[1]));
} else {
Results.Errors errors = new Results.Errors();
errors.invalidValue(context.identifier.getName(), sb.toString(), context.line.get());
return errors;
}
}
@Override
public boolean canWrite(Object value) {
return Number.class.isInstance(value);
}
@Override
public void write(Object value, WriterContext context) {
context.write(value.toString());
}
@Override
public boolean isPrimitiveType() {
return true;
}
@Override
public String toString() {
return "number";
}
}

69
proxy/src/main/java/dev/plex/toml/ObjectValueWriter.java
View File

@ -1,69 +0,0 @@
package dev.plex.toml;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;
import static dev.plex.toml.MapValueWriter.MAP_VALUE_WRITER;
class ObjectValueWriter implements dev.plex.toml.ValueWriter
{
static final dev.plex.toml.ValueWriter OBJECT_VALUE_WRITER = new ObjectValueWriter();
@Override
public boolean canWrite(Object value) {
return true;
}
@Override
public void write(Object value, dev.plex.toml.WriterContext context) {
Map<String, Object> to = new LinkedHashMap<String, Object>();
Set<Field> fields = getFields(value.getClass());
for (Field field : fields) {
to.put(field.getName(), getFieldValue(field, value));
}
MAP_VALUE_WRITER.write(to, context);
}
@Override
public boolean isPrimitiveType() {
return false;
}
private static Set<Field> getFields(Class<?> cls) {
Set<Field> fields = new LinkedHashSet<Field>(Arrays.asList(cls.getDeclaredFields()));
while (cls != Object.class) {
fields.addAll(Arrays.asList(cls.getDeclaredFields()));
cls = cls.getSuperclass();
}
removeConstantsAndSyntheticFields(fields);
return fields;
}
private static void removeConstantsAndSyntheticFields(Set<Field> fields) {
Iterator<Field> iterator = fields.iterator();
while (iterator.hasNext()) {
Field field = iterator.next();
if ((Modifier.isFinal(field.getModifiers()) && Modifier.isStatic(field.getModifiers())) || field.isSynthetic() || Modifier.isTransient(field.getModifiers())) {
iterator.remove();
}
}
}
private static Object getFieldValue(Field field, Object o) {
boolean isAccessible = field.isAccessible();
field.setAccessible(true);
Object value = null;
try {
value = field.get(o);
} catch (IllegalAccessException ignored) {
}
field.setAccessible(isAccessible);
return value;
}
private ObjectValueWriter() {}
}

55
proxy/src/main/java/dev/plex/toml/PrimitiveArrayValueWriter.java
View File

@ -1,55 +0,0 @@
package dev.plex.toml;
import java.util.Collection;
import static dev.plex.toml.ValueWriters.WRITERS;
class PrimitiveArrayValueWriter extends dev.plex.toml.ArrayValueWriter
{
static final ValueWriter PRIMITIVE_ARRAY_VALUE_WRITER = new PrimitiveArrayValueWriter();
@Override
public boolean canWrite(Object value) {
return isArrayish(value) && isArrayOfPrimitive(value);
}
@Override
public void write(Object o, WriterContext context) {
Collection<?> values = normalize(o);
context.write('[');
context.writeArrayDelimiterPadding();
boolean first = true;
ValueWriter firstWriter = null;
for (Object value : values) {
if (first) {
firstWriter = WRITERS.findWriterFor(value);
first = false;
} else {
ValueWriter writer = WRITERS.findWriterFor(value);
if (writer != firstWriter) {
throw new IllegalStateException(
context.getContextPath() +
": cannot write a heterogeneous array; first element was of type " + firstWriter +
" but found " + writer
);
}
context.write(", ");
}
WRITERS.findWriterFor(value).write(value, context);
}
context.writeArrayDelimiterPadding();
context.write(']');
}
private PrimitiveArrayValueWriter() {}
@Override
public String toString() {
return "primitive-array";
}
}

290
proxy/src/main/java/dev/plex/toml/Results.java
View File

@ -1,290 +0,0 @@
package dev.plex.toml;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
class Results {
static class Errors {
private final StringBuilder sb = new StringBuilder();
void duplicateTable(String table, int line) {
sb.append("Duplicate table definition on line ")
.append(line)
.append(": [")
.append(table)
.append("]");
}
public void tableDuplicatesKey(String table, AtomicInteger line) {
sb.append("Key already exists for table defined on line ")
.append(line.get())
.append(": [")
.append(table)
.append("]");
}
public void keyDuplicatesTable(String key, AtomicInteger line) {
sb.append("Table already exists for key defined on line ")
.append(line.get())
.append(": ")
.append(key);
}
void emptyImplicitTable(String table, int line) {
sb.append("Invalid table definition due to empty implicit table name: ")
.append(table);
}
void invalidTable(String table, int line) {
sb.append("Invalid table definition on line ")
.append(line)
.append(": ")
.append(table)
.append("]");
}
void duplicateKey(String key, int line) {
sb.append("Duplicate key");
if (line > -1) {
sb.append(" on line ")
.append(line);
}
sb.append(": ")
.append(key);
}
void invalidTextAfterIdentifier(dev.plex.toml.Identifier identifier, char text, int line) {
sb.append("Invalid text after key ")
.append(identifier.getName())
.append(" on line ")
.append(line)
.append(". Make sure to terminate the value or add a comment (#).");
}
void invalidKey(String key, int line) {
sb.append("Invalid key on line ")
.append(line)
.append(": ")
.append(key);
}
void invalidTableArray(String tableArray, int line) {
sb.append("Invalid table array definition on line ")
.append(line)
.append(": ")
.append(tableArray);
}
void invalidValue(String key, String value, int line) {
sb.append("Invalid value on line ")
.append(line)
.append(": ")
.append(key)
.append(" = ")
.append(value);
}
void unterminatedKey(String key, int line) {
sb.append("Key is not followed by an equals sign on line ")
.append(line)
.append(": ")
.append(key);
}
void unterminated(String key, String value, int line) {
sb.append("Unterminated value on line ")
.append(line)
.append(": ")
.append(key)
.append(" = ")
.append(value.trim());
}
public void heterogenous(String key, int line) {
sb.append(key)
.append(" becomes a heterogeneous array on line ")
.append(line);
}
boolean hasErrors() {
return sb.length() > 0;
}
@Override
public String toString() {
return sb.toString();
}
public void add(Errors other) {
sb.append(other.sb);
}
}
final Errors errors = new Errors();
private final Set<String> tables = new HashSet<String>();
private final Deque<dev.plex.toml.Container> stack = new ArrayDeque<dev.plex.toml.Container>();
Results() {
stack.push(new dev.plex.toml.Container.Table(""));
}
void addValue(String key, Object value, AtomicInteger line) {
dev.plex.toml.Container currentTable = stack.peek();
if (value instanceof Map) {
String path = getInlineTablePath(key);
if (path == null) {
startTable(key, line);
} else if (path.isEmpty()) {
startTables(dev.plex.toml.Identifier.from(key, null), line);
} else {
startTables(dev.plex.toml.Identifier.from(path, null), line);
}
@SuppressWarnings("unchecked")
Map<String, Object> valueMap = (Map<String, Object>) value;
for (Map.Entry<String, Object> entry : valueMap.entrySet()) {
addValue(entry.getKey(), entry.getValue(), line);
}
stack.pop();
} else if (currentTable.accepts(key)) {
currentTable.put(key, value);
} else {
if (currentTable.get(key) instanceof dev.plex.toml.Container) {
errors.keyDuplicatesTable(key, line);
} else {
errors.duplicateKey(key, line != null ? line.get() : -1);
}
}
}
void startTableArray(dev.plex.toml.Identifier identifier, AtomicInteger line) {
String tableName = identifier.getBareName();
while (stack.size() > 1) {
stack.pop();
}
dev.plex.toml.Keys.Key[] tableParts = dev.plex.toml.Keys.split(tableName);
for (int i = 0; i < tableParts.length; i++) {
String tablePart = tableParts[i].name;
dev.plex.toml.Container currentContainer = stack.peek();
if (currentContainer.get(tablePart) instanceof dev.plex.toml.Container.TableArray) {
dev.plex.toml.Container.TableArray currentTableArray = (dev.plex.toml.Container.TableArray) currentContainer.get(tablePart);
stack.push(currentTableArray);
if (i == tableParts.length - 1) {
currentTableArray.put(tablePart, new dev.plex.toml.Container.Table());
}
stack.push(currentTableArray.getCurrent());
currentContainer = stack.peek();
} else if (currentContainer.get(tablePart) instanceof dev.plex.toml.Container.Table && i < tableParts.length - 1) {
dev.plex.toml.Container nextTable = (dev.plex.toml.Container) currentContainer.get(tablePart);
stack.push(nextTable);
} else if (currentContainer.accepts(tablePart)) {
dev.plex.toml.Container newContainer = i == tableParts.length - 1 ? new dev.plex.toml.Container.TableArray() : new dev.plex.toml.Container.Table();
addValue(tablePart, newContainer, line);
stack.push(newContainer);
if (newContainer instanceof dev.plex.toml.Container.TableArray) {
stack.push(((dev.plex.toml.Container.TableArray) newContainer).getCurrent());
}
} else {
errors.duplicateTable(tableName, line.get());
break;
}
}
}
void startTables(dev.plex.toml.Identifier id, AtomicInteger line) {
String tableName = id.getBareName();
while (stack.size() > 1) {
stack.pop();
}
dev.plex.toml.Keys.Key[] tableParts = dev.plex.toml.Keys.split(tableName);
for (int i = 0; i < tableParts.length; i++) {
String tablePart = tableParts[i].name;
dev.plex.toml.Container currentContainer = stack.peek();
if (currentContainer.get(tablePart) instanceof dev.plex.toml.Container) {
dev.plex.toml.Container nextTable = (dev.plex.toml.Container) currentContainer.get(tablePart);
if (i == tableParts.length - 1 && !nextTable.isImplicit()) {
errors.duplicateTable(tableName, line.get());
return;
}
stack.push(nextTable);
if (stack.peek() instanceof dev.plex.toml.Container.TableArray) {
stack.push(((dev.plex.toml.Container.TableArray) stack.peek()).getCurrent());
}
} else if (currentContainer.accepts(tablePart)) {
startTable(tablePart, i < tableParts.length - 1, line);
} else {
errors.tableDuplicatesKey(tablePart, line);
break;
}
}
}
/**
* Warning: After this method has been called, this instance is no longer usable.
*/
Map<String, Object> consume() {
dev.plex.toml.Container values = stack.getLast();
stack.clear();
return ((dev.plex.toml.Container.Table) values).consume();
}
private dev.plex.toml.Container startTable(String tableName, AtomicInteger line) {
dev.plex.toml.Container newTable = new dev.plex.toml.Container.Table(tableName);
addValue(tableName, newTable, line);
stack.push(newTable);
return newTable;
}
private dev.plex.toml.Container startTable(String tableName, boolean implicit, AtomicInteger line) {
dev.plex.toml.Container newTable = new dev.plex.toml.Container.Table(tableName, implicit);
addValue(tableName, newTable, line);
stack.push(newTable);
return newTable;
}
private String getInlineTablePath(String key) {
Iterator<dev.plex.toml.Container> descendingIterator = stack.descendingIterator();
StringBuilder sb = new StringBuilder();
while (descendingIterator.hasNext()) {
dev.plex.toml.Container next = descendingIterator.next();
if (next instanceof dev.plex.toml.Container.TableArray) {
return null;
}
dev.plex.toml.Container.Table table = (dev.plex.toml.Container.Table) next;
if (table.name == null) {
break;
}
if (sb.length() > 0) {
sb.append('.');
}
sb.append(table.name);
}
if (sb.length() > 0) {
sb.append('.');
}
sb.append(key)
.insert(0, '[')
.append(']');
return sb.toString();
}
}

129
proxy/src/main/java/dev/plex/toml/StringValueReaderWriter.java
View File

@ -1,129 +0,0 @@
package dev.plex.toml;
import java.net.URI;
import java.net.URL;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class StringValueReaderWriter implements ValueReader, dev.plex.toml.ValueWriter
{
static final StringValueReaderWriter STRING_VALUE_READER_WRITER = new StringValueReaderWriter();
private static final Pattern UNICODE_REGEX = Pattern.compile("\\\\[uU](.{4})");
static private final String[] specialCharacterEscapes = new String[93];
static {
specialCharacterEscapes['\b'] = "\\b";
specialCharacterEscapes['\t'] = "\\t";
specialCharacterEscapes['\n'] = "\\n";
specialCharacterEscapes['\f'] = "\\f";
specialCharacterEscapes['\r'] = "\\r";
specialCharacterEscapes['"'] = "\\\"";
specialCharacterEscapes['\\'] = "\\\\";
}
@Override
public boolean canRead(String s) {
return s.startsWith("\"");
}
@Override
public Object read(String s, AtomicInteger index, Context context) {
int startIndex = index.incrementAndGet();
int endIndex = -1;
for (int i = index.get(); i < s.length(); i = index.incrementAndGet()) {
char ch = s.charAt(i);
if (ch == '"' && s.charAt(i - 1) != '\\') {
endIndex = i;
break;
}
}
if (endIndex == -1) {
Results.Errors errors = new Results.Errors();
errors.unterminated(context.identifier.getName(), s.substring(startIndex - 1), context.line.get());
return errors;
}
String raw = s.substring(startIndex, endIndex);
s = replaceUnicodeCharacters(raw);
s = replaceSpecialCharacters(s);
if (s == null) {
Results.Errors errors = new Results.Errors();
errors.invalidValue(context.identifier.getName(), raw, context.line.get());
return errors;
}
return s;
}
String replaceUnicodeCharacters(String value) {
Matcher unicodeMatcher = UNICODE_REGEX.matcher(value);
while (unicodeMatcher.find()) {
value = value.replace(unicodeMatcher.group(), new String(Character.toChars(Integer.parseInt(unicodeMatcher.group(1), 16))));
}
return value;
}
String replaceSpecialCharacters(String s) {
for (int i = 0; i < s.length() - 1; i++) {
char ch = s.charAt(i);
char next = s.charAt(i + 1);
if (ch == '\\' && next == '\\') {
i++;
} else if (ch == '\\' && !(next == 'b' || next == 'f' || next == 'n' || next == 't' || next == 'r' || next == '"' || next == '\\')) {
return null;
}
}
return s.replace("\\n", "\n")
.replace("\\\"", "\"")
.replace("\\t", "\t")
.replace("\\r", "\r")
.replace("\\\\", "\\")
.replace("\\/", "/")
.replace("\\b", "\b")
.replace("\\f", "\f");
}
@Override
public boolean canWrite(Object value) {
return value instanceof String || value instanceof Character || value instanceof URL || value instanceof URI || value instanceof Enum;
}
@Override
public void write(Object value, dev.plex.toml.WriterContext context) {
context.write('"');
escapeUnicode(value.toString(), context);
context.write('"');
}
@Override
public boolean isPrimitiveType() {
return true;
}
private void escapeUnicode(String in, dev.plex.toml.WriterContext context) {
for (int i = 0; i < in.length(); i++) {
int codePoint = in.codePointAt(i);
if (codePoint < specialCharacterEscapes.length && specialCharacterEscapes[codePoint] != null) {
context.write(specialCharacterEscapes[codePoint]);
} else {
context.write(in.charAt(i));
}
}
}
private StringValueReaderWriter() {}
@Override
public String toString() {
return "string";
}
}

63
proxy/src/main/java/dev/plex/toml/TomlParser.java
View File

@ -1,63 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
class TomlParser {
static Results run(String tomlString) {
final Results results = new Results();
if (tomlString.isEmpty()) {
return results;
}
AtomicInteger index = new AtomicInteger();
boolean inComment = false;
AtomicInteger line = new AtomicInteger(1);
dev.plex.toml.Identifier identifier = null;
Object value = null;
for (int i = index.get(); i < tomlString.length(); i = index.incrementAndGet()) {
char c = tomlString.charAt(i);
if (results.errors.hasErrors()) {
break;
}
if (c == '#' && !inComment) {
inComment = true;
} else if (!Character.isWhitespace(c) && !inComment && identifier == null) {
dev.plex.toml.Identifier id = IdentifierConverter.IDENTIFIER_CONVERTER.convert(tomlString, index, new dev.plex.toml.Context(null, line, results.errors));
if (id != dev.plex.toml.Identifier.INVALID) {
if (id.isKey()) {
identifier = id;
} else if (id.isTable()) {
results.startTables(id, line);
} else if (id.isTableArray()) {
results.startTableArray(id, line);
}
}
} else if (c == '\n') {
inComment = false;
identifier = null;
value = null;
line.incrementAndGet();
} else if (!inComment && identifier != null && identifier.isKey() && value == null && !Character.isWhitespace(c)) {
value = ValueReaders.VALUE_READERS.convert(tomlString, index, new dev.plex.toml.Context(identifier, line, results.errors));
if (value instanceof Results.Errors) {
results.errors.add((Results.Errors) value);
} else {
results.addValue(identifier.getName(), value, line);
}
} else if (value != null && !inComment && !Character.isWhitespace(c)) {
results.errors.invalidTextAfterIdentifier(identifier, c, line.get());
}
}
return results;
}
private TomlParser() {}
}

179
proxy/src/main/java/dev/plex/toml/TomlWriter.java
View File

@ -1,179 +0,0 @@
package dev.plex.toml;
import org.jetbrains.annotations.Nullable;
import java.io.*;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import static dev.plex.toml.MapValueWriter.MAP_VALUE_WRITER;
import static dev.plex.toml.ValueWriters.WRITERS;
/**
* <p>Converts Objects to TOML</p>
*
* <p>An input Object can comprise arbitrarily nested combinations of Java primitive types,
* other {@link Object}s, {@link Map}s, {@link List}s, and Arrays. {@link Object}s and {@link Map}s
* are output to TOML tables, and {@link List}s and Array to TOML arrays.</p>
*
* <p>Example usage:</p>
* <pre><code>
* class AClass {
* int anInt = 1;
* int[] anArray = { 2, 3 };
* }
*
* String tomlString = new TomlWriter().write(new AClass());
* </code></pre>
*/
public class TomlWriter
{
public static class Builder
{
private int keyIndentation;
private int tableIndentation;
private int arrayDelimiterPadding = 0;
private TimeZone timeZone = TimeZone.getTimeZone("UTC");
private boolean showFractionalSeconds = false;
public Builder indentValuesBy(int spaces)
{
this.keyIndentation = spaces;
return this;
}
public Builder indentTablesBy(int spaces)
{
this.tableIndentation = spaces;
return this;
}
public Builder timeZone(TimeZone timeZone)
{
this.timeZone = timeZone;
return this;
}
/**
* @param spaces number of spaces to put between opening square bracket and first item and between closing square bracket and last item
* @return this TomlWriter.Builder instance
*/
public Builder padArrayDelimitersBy(int spaces)
{
this.arrayDelimiterPadding = spaces;
return this;
}
public TomlWriter build()
{
return new TomlWriter(keyIndentation, tableIndentation, arrayDelimiterPadding, timeZone, showFractionalSeconds);
}
public Builder showFractionalSeconds()
{
this.showFractionalSeconds = true;
return this;
}
}
private final dev.plex.toml.IndentationPolicy indentationPolicy;
private final DatePolicy datePolicy;
/**
* Creates a TomlWriter instance.
*/
public TomlWriter()
{
this(0, 0, 0, TimeZone.getTimeZone("UTC"), false);
}
private TomlWriter(int keyIndentation, int tableIndentation, int arrayDelimiterPadding, TimeZone timeZone, boolean showFractionalSeconds)
{
this.indentationPolicy = new dev.plex.toml.IndentationPolicy(keyIndentation, tableIndentation, arrayDelimiterPadding);
this.datePolicy = new DatePolicy(timeZone, showFractionalSeconds);
}
/**
* Write an Object into TOML String.
*
* @param from the object to be written
* @return a string containing the TOML representation of the given Object
*/
public String write(Object from)
{
try
{
StringWriter output = new StringWriter();
write(from, output, null);
return output.toString();
} catch (IOException e)
{
throw new RuntimeException(e);
}
}
/**
* Write an Object in TOML to a {@link File}. Output is encoded as UTF-8.
*
* @param from the object to be written
* @param target the File to which the TOML will be written
* @throws IOException if any file operations fail
*/
public void write(Object from, File target) throws IOException
{
OutputStream outputStream = new FileOutputStream(target, true);
try
{
write(from, outputStream, target);
} finally
{
outputStream.close();
}
}
/**
* Write an Object in TOML to a {@link OutputStream}. Output is encoded as UTF-8.
*
* @param from the object to be written
* @param target the OutputStream to which the TOML will be written. The stream is NOT closed after being written to.
* @throws IOException if target.write() fails
*/
public void write(Object from, OutputStream target, @Nullable File file) throws IOException
{
OutputStreamWriter writer = new OutputStreamWriter(target, "UTF-8");
write(from, writer, file);
writer.flush();
}
/**
* Write an Object in TOML to a {@link Writer}. You MUST ensure that the {@link Writer}s's encoding is set to UTF-8 for the TOML to be valid.
*
* @param from the object to be written. Can be a Map or a custom type. Must not be null.
* @param target the Writer to which TOML will be written. The Writer is not closed.
* @throws IOException if target.write() fails
* @throws IllegalArgumentException if from is of an invalid type
*/
public void write(Object from, Writer target, @Nullable File file) throws IOException
{
ValueWriter valueWriter = WRITERS.findWriterFor(from);
if (valueWriter == MAP_VALUE_WRITER || valueWriter == ObjectValueWriter.OBJECT_VALUE_WRITER)
{
WriterContext context = new WriterContext(indentationPolicy, datePolicy, target);
if (file != null && file.exists())
{
context.file = file;
}
valueWriter.write(from, context);
} else
{
throw new IllegalArgumentException("An object of class " + from.getClass().getSimpleName() + " cannot produce valid TOML. Please pass in a Map or a custom type.");
}
}
}

37
proxy/src/main/java/dev/plex/toml/ValueReaders.java
View File

@ -1,37 +0,0 @@
package dev.plex.toml;
import java.util.concurrent.atomic.AtomicInteger;
import static dev.plex.toml.ArrayValueReader.ARRAY_VALUE_READER;
import static dev.plex.toml.BooleanValueReaderWriter.BOOLEAN_VALUE_READER_WRITER;
import static dev.plex.toml.DateValueReaderWriter.DATE_VALUE_READER_WRITER;
import static dev.plex.toml.InlineTableValueReader.INLINE_TABLE_VALUE_READER;
import static dev.plex.toml.LiteralStringValueReader.LITERAL_STRING_VALUE_READER;
import static dev.plex.toml.MultilineLiteralStringValueReader.MULTILINE_LITERAL_STRING_VALUE_READER;
import static dev.plex.toml.MultilineStringValueReader.MULTILINE_STRING_VALUE_READER;
import static dev.plex.toml.NumberValueReaderWriter.NUMBER_VALUE_READER_WRITER;
import static dev.plex.toml.StringValueReaderWriter.STRING_VALUE_READER_WRITER;
class ValueReaders {
static final ValueReaders VALUE_READERS = new ValueReaders();
Object convert(String value, AtomicInteger index, dev.plex.toml.Context context) {
String substring = value.substring(index.get());
for (dev.plex.toml.ValueReader valueParser : READERS) {
if (valueParser.canRead(substring)) {
return valueParser.read(value, index, context);
}
}
dev.plex.toml.Results.Errors errors = new dev.plex.toml.Results.Errors();
errors.invalidValue(context.identifier.getName(), substring, context.line.get());
return errors;
}
private ValueReaders() {}
private static final dev.plex.toml.ValueReader[] READERS = {
MULTILINE_STRING_VALUE_READER, MULTILINE_LITERAL_STRING_VALUE_READER, LITERAL_STRING_VALUE_READER, STRING_VALUE_READER_WRITER, DATE_VALUE_READER_WRITER, NUMBER_VALUE_READER_WRITER, BOOLEAN_VALUE_READER_WRITER, ARRAY_VALUE_READER, INLINE_TABLE_VALUE_READER
};
}

9
proxy/src/main/java/dev/plex/toml/ValueWriter.java
View File

@ -1,9 +0,0 @@
package dev.plex.toml;
interface ValueWriter {
boolean canWrite(Object value);
void write(Object value, dev.plex.toml.WriterContext context);
boolean isPrimitiveType();
}

31
proxy/src/main/java/dev/plex/toml/ValueWriters.java
View File

@ -1,31 +0,0 @@
package dev.plex.toml;
import static dev.plex.toml.MapValueWriter.MAP_VALUE_WRITER;
import static dev.plex.toml.NumberValueReaderWriter.NUMBER_VALUE_READER_WRITER;
class ValueWriters {
static final ValueWriters WRITERS = new ValueWriters();
ValueWriter findWriterFor(Object value) {
for (ValueWriter valueWriter : VALUE_WRITERS) {
if (valueWriter.canWrite(value)) {
return valueWriter;
}
}
return ObjectValueWriter.OBJECT_VALUE_WRITER;
}
private ValueWriters() {}
private static DateValueReaderWriter getPlatformSpecificDateConverter() {
String specificationVersion = Runtime.class.getPackage().getSpecificationVersion();
return specificationVersion != null && specificationVersion.startsWith("1.6") ? DateValueReaderWriter.DATE_PARSER_JDK_6 : DateValueReaderWriter.DATE_VALUE_READER_WRITER;
}
private static final ValueWriter[] VALUE_WRITERS = {
StringValueReaderWriter.STRING_VALUE_READER_WRITER, NUMBER_VALUE_READER_WRITER, BooleanValueReaderWriter.BOOLEAN_VALUE_READER_WRITER, getPlatformSpecificDateConverter(),
MAP_VALUE_WRITER, PrimitiveArrayValueWriter.PRIMITIVE_ARRAY_VALUE_WRITER, TableArrayValueWriter.TABLE_ARRAY_VALUE_WRITER
};
}

182
proxy/src/main/java/dev/plex/toml/WriterContext.java
View File

@ -1,182 +0,0 @@
package dev.plex.toml;
import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.util.Arrays;
class WriterContext
{
private String arrayKey = null;
private boolean isArrayOfTable = false;
private boolean empty = true;
public final String key;
private final String currentTableIndent;
private final String currentFieldIndent;
private final Writer output;
private final dev.plex.toml.IndentationPolicy indentationPolicy;
private final DatePolicy datePolicy;
public File file;
public String parentName;
public boolean hasRun = false;
WriterContext(dev.plex.toml.IndentationPolicy indentationPolicy, DatePolicy datePolicy, Writer output)
{
this("", "", output, indentationPolicy, datePolicy);
}
WriterContext pushTable(String newKey)
{
String newIndent = "";
if (!key.isEmpty())
{
newIndent = growIndent(indentationPolicy);
}
String fullKey = key.isEmpty() ? newKey : key + "." + newKey;
WriterContext subContext = new WriterContext(fullKey, newIndent, output, indentationPolicy, datePolicy);
if (!empty)
{
subContext.empty = false;
}
return subContext;
}
WriterContext pushTableFromArray()
{
WriterContext subContext = new WriterContext(key, currentTableIndent, output, indentationPolicy, datePolicy);
if (!empty)
{
subContext.empty = false;
}
subContext.setIsArrayOfTable(true);
return subContext;
}
WriterContext write(String s)
{
try
{
output.write(s);
if (empty && !s.isEmpty())
{
empty = false;
}
return this;
} catch (IOException e)
{
throw new RuntimeException(e);
}
}
void write(char[] chars)
{
for (char c : chars)
{
write(c);
}
}
WriterContext write(char c)
{
try
{
output.write(c);
empty = false;
return this;
} catch (IOException e)
{
throw new RuntimeException(e);
}
}
void writeKey()
{
if (key.isEmpty())
{
return;
}
if (!empty)
{
write('\n');
}
write(currentTableIndent);
if (isArrayOfTable)
{
write("[[").write(key).write("]]\n");
} else
{
write('[').write(key).write("]\n");
}
}
void writeArrayDelimiterPadding()
{
for (int i = 0; i < indentationPolicy.getArrayDelimiterPadding(); i++)
{
write(' ');
}
}
void indent()
{
if (!key.isEmpty())
{
write(currentFieldIndent);
}
}
DatePolicy getDatePolicy()
{
return datePolicy;
}
WriterContext setIsArrayOfTable(boolean isArrayOfTable)
{
this.isArrayOfTable = isArrayOfTable;
return this;
}
WriterContext setArrayKey(String arrayKey)
{
this.arrayKey = arrayKey;
return this;
}
String getContextPath()
{
return key.isEmpty() ? arrayKey : key + "." + arrayKey;
}
private String growIndent(dev.plex.toml.IndentationPolicy indentationPolicy)
{
return currentTableIndent + fillStringWithSpaces(indentationPolicy.getTableIndent());
}
private String fillStringWithSpaces(int count)
{
char[] chars = new char[count];
Arrays.fill(chars, ' ');
return new String(chars);
}
private WriterContext(String key, String tableIndent, Writer output, dev.plex.toml.IndentationPolicy indentationPolicy, DatePolicy datePolicy)
{
this.key = key;
this.output = output;
this.indentationPolicy = indentationPolicy;
this.currentTableIndent = tableIndent;
this.datePolicy = datePolicy;
this.currentFieldIndent = tableIndent + fillStringWithSpaces(this.indentationPolicy.getKeyValueIndent());
}
}