results) {
+
+ public boolean ok() {
+ return results.stream().allMatch(ExampleResult::ok);
+ }
+ }
+}
diff --git a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaSpecification.java b/planetiler-core/src/main/java/com/onthegomap/planetiler/validator/SchemaSpecification.java
similarity index 88%
rename from planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaSpecification.java
rename to planetiler-core/src/main/java/com/onthegomap/planetiler/validator/SchemaSpecification.java
index 65385adc91..2014e9b9af 100644
--- a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaSpecification.java
+++ b/planetiler-core/src/main/java/com/onthegomap/planetiler/validator/SchemaSpecification.java
@@ -1,17 +1,21 @@
-package com.onthegomap.planetiler.custommap.validator;
+package com.onthegomap.planetiler.validator;
import static com.onthegomap.planetiler.config.PlanetilerConfig.MAX_MAXZOOM;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
-import com.onthegomap.planetiler.custommap.YAML;
import com.onthegomap.planetiler.geo.GeometryType;
+import com.onthegomap.planetiler.util.YAML;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
-/** A model of example input source features and expected output vector tile features that a schema should produce. */
+/**
+ * A model of example input source features and expected output vector tile features that a schema should produce.
+ *
+ * Executed by a subclass of {@link BaseSchemaValidator}.
+ */
@JsonIgnoreProperties(ignoreUnknown = true)
public record SchemaSpecification(List examples) {
diff --git a/planetiler-core/src/test/java/com/onthegomap/planetiler/PlanetilerTests.java b/planetiler-core/src/test/java/com/onthegomap/planetiler/PlanetilerTests.java
index d1224780f3..ade78a6639 100644
--- a/planetiler-core/src/test/java/com/onthegomap/planetiler/PlanetilerTests.java
+++ b/planetiler-core/src/test/java/com/onthegomap/planetiler/PlanetilerTests.java
@@ -204,18 +204,6 @@ private PlanetilerResults runWithReaderFeaturesProfile(
);
}
- private PlanetilerResults runWithOsmElements(
- Map args,
- List features,
- BiConsumer profileFunction
- ) throws Exception {
- return run(
- args,
- (featureGroup, profile, config) -> processOsmFeatures(featureGroup, profile, config, features),
- TestProfile.processSourceFeatures(profileFunction)
- );
- }
-
private PlanetilerResults runWithOsmElements(
Map args,
List features,
diff --git a/planetiler-core/src/test/java/com/onthegomap/planetiler/TestUtils.java b/planetiler-core/src/test/java/com/onthegomap/planetiler/TestUtils.java
index 5064b1ff65..876ad03ffa 100644
--- a/planetiler-core/src/test/java/com/onthegomap/planetiler/TestUtils.java
+++ b/planetiler-core/src/test/java/com/onthegomap/planetiler/TestUtils.java
@@ -7,6 +7,7 @@
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.DynamicTest.dynamicTest;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -26,6 +27,8 @@
import com.onthegomap.planetiler.mbtiles.Verify;
import com.onthegomap.planetiler.reader.SourceFeature;
import com.onthegomap.planetiler.stats.Stats;
+import com.onthegomap.planetiler.validator.BaseSchemaValidator;
+import com.onthegomap.planetiler.validator.SchemaSpecification;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
@@ -47,7 +50,9 @@
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
import org.apache.commons.lang3.reflect.FieldUtils;
+import org.junit.jupiter.api.DynamicNode;
import org.locationtech.jts.algorithm.Orientation;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.CoordinateSequence;
@@ -340,6 +345,20 @@ public static Path extractPathToResource(Path tempDir, String resource, String l
return path;
}
+ public static Stream validateProfile(Profile profile, String spec) {
+ return validateProfile(profile, SchemaSpecification.load(spec));
+ }
+
+ public static Stream validateProfile(Profile profile, SchemaSpecification spec) {
+ var result = BaseSchemaValidator.validate(profile, spec, PlanetilerConfig.defaults());
+ return result.results().stream().map(test -> dynamicTest(test.example().name(), () -> {
+ var issues = test.issues().get();
+ if (!issues.isEmpty()) {
+ fail("Failed with " + issues.size() + " issues:\n" + String.join("\n", issues));
+ }
+ }));
+ }
+
public interface GeometryComparision {
Geometry geom();
@@ -632,7 +651,7 @@ public static void assertMinFeatureCount(Mbtiles db, String layer, int zoom, Map
try {
int num = Verify.getNumFeatures(db, layer, zoom, attrs, envelope, clazz);
- assertTrue(expected < num,
+ assertTrue(expected <= num,
"z%d features in %s, expected at least %d got %d".formatted(zoom, layer, expected, num));
} catch (GeometryException e) {
fail(e);
diff --git a/planetiler-core/src/test/java/com/onthegomap/planetiler/validator/BaseSchemaValidatorTest.java b/planetiler-core/src/test/java/com/onthegomap/planetiler/validator/BaseSchemaValidatorTest.java
new file mode 100644
index 0000000000..5ce9bd1ced
--- /dev/null
+++ b/planetiler-core/src/test/java/com/onthegomap/planetiler/validator/BaseSchemaValidatorTest.java
@@ -0,0 +1,204 @@
+package com.onthegomap.planetiler.validator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.onthegomap.planetiler.FeatureCollector;
+import com.onthegomap.planetiler.Profile;
+import com.onthegomap.planetiler.TestUtils;
+import com.onthegomap.planetiler.config.Arguments;
+import com.onthegomap.planetiler.config.PlanetilerConfig;
+import com.onthegomap.planetiler.reader.SourceFeature;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.Set;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DynamicNode;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class BaseSchemaValidatorTest {
+
+ private final String goodSpecString = """
+ examples:
+ - name: test output
+ input:
+ source: osm
+ geometry: polygon
+ tags:
+ natural: water
+ output:
+ - layer: water
+ geometry: polygon
+ tags:
+ natural: water
+ """;
+ private final SchemaSpecification goodSpec = SchemaSpecification.load(goodSpecString);
+
+ private final Profile waterSchema = new Profile() {
+ @Override
+ public void processFeature(SourceFeature sourceFeature, FeatureCollector features) {
+ if (sourceFeature.canBePolygon() && sourceFeature.hasTag("natural", "water")) {
+ features.polygon("water")
+ .setMinPixelSize(10)
+ .inheritAttrFromSource("natural");
+ }
+ }
+
+ @Override
+ public String name() {
+ return "test profile";
+ }
+ };
+
+ private Result validate(Profile profile, String spec) {
+ var result = BaseSchemaValidator.validate(
+ profile,
+ SchemaSpecification.load(spec),
+ PlanetilerConfig.defaults()
+ );
+ for (var example : result.results()) {
+ if (example.issues().isFailure()) {
+ assertNotNull(example.issues().get());
+ }
+ }
+ // also exercise the cli writer and return what it would have printed to stdout
+ var cliOutput = validateCli(profile, SchemaSpecification.load(spec));
+ return new Result(result, cliOutput);
+ }
+
+ private String validateCli(Profile profile, SchemaSpecification spec) {
+ try (
+ var baos = new ByteArrayOutputStream();
+ var printStream = new PrintStream(baos, true, StandardCharsets.UTF_8)
+ ) {
+ new BaseSchemaValidator(Arguments.of(), printStream) {
+ @Override
+ protected Result validate(Set pathsToWatch) {
+ return validate(profile, spec, PlanetilerConfig.from(args));
+ }
+ }.validateFromCli();
+ return baos.toString(StandardCharsets.UTF_8);
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ }
+
+ private Result validateWater(String layer, String geometry, String tags, String allowExtraTags) throws IOException {
+ return validate(
+ waterSchema,
+ """
+ examples:
+ - name: test output
+ input:
+ source: osm
+ geometry: polygon
+ tags:
+ natural: water
+ output:
+ layer: %s
+ geometry: %s
+ %s
+ tags:
+ %s
+ """.formatted(layer, geometry, allowExtraTags == null ? "" : allowExtraTags,
+ tags == null ? "" : tags.indent(6).strip())
+ );
+ }
+
+ @ParameterizedTest
+ @CsvSource(value = {
+ "true,water,polygon,natural: water,",
+ "true,water,polygon,,",
+ "true,water,polygon,'natural: water\nother: null',",
+ "false,water,polygon,natural: null,",
+ "false,water2,polygon,natural: water,",
+ "false,water,line,natural: water,",
+ "false,water,line,natural: water,",
+ "false,water,polygon,natural: water2,",
+ "false,water,polygon,'natural: water\nother: value',",
+
+ "true,water,polygon,natural: water,allow_extra_tags: true",
+ "true,water,polygon,natural: water,allow_extra_tags: false",
+ "true,water,polygon,,allow_extra_tags: true",
+ "false,water,polygon,,allow_extra_tags: false",
+
+ "true,water,polygon,,min_size: 10",
+ "false,water,polygon,,min_size: 9",
+ })
+ void testValidateWaterPolygon(boolean shouldBeOk, String layer, String geometry, String tags, String allowExtraTags)
+ throws IOException {
+ var results = validateWater(layer, geometry, tags, allowExtraTags);
+ assertEquals(1, results.output.results().size());
+ assertEquals("test output", results.output.results().get(0).example().name());
+ if (shouldBeOk) {
+ assertTrue(results.output.ok(), results.toString());
+ assertFalse(results.cliOutput.contains("FAIL"), "contained FAIL but should not have: " + results.cliOutput);
+ } else {
+ assertFalse(results.output.ok(), "Expected an issue, but there were none");
+ assertTrue(results.cliOutput.contains("FAIL"), "did not contain FAIL but should have: " + results.cliOutput);
+ }
+ }
+
+ @Test
+ void testValidationFailsWrongNumberOfFeatures() throws IOException {
+ var results = validate(
+ waterSchema,
+ """
+ examples:
+ - name: test output
+ input:
+ source: osm
+ geometry: polygon
+ tags:
+ natural: water
+ output:
+ """
+ );
+ assertFalse(results.output.ok(), results.toString());
+
+ results = validate(
+ waterSchema,
+ """
+ examples:
+ - name: test output
+ input:
+ source: osm
+ geometry: polygon
+ tags:
+ natural: water
+ output:
+ - layer: water
+ geometry: polygon
+ tags:
+ natural: water
+ - layer: water2
+ geometry: polygon
+ tags:
+ natural: water2
+ """
+ );
+ assertFalse(results.output.ok(), results.toString());
+ }
+
+ @TestFactory
+ Stream testJunitAdapterSpec() {
+ return TestUtils.validateProfile(waterSchema, goodSpec);
+ }
+
+ @TestFactory
+ Stream testJunitAdapterString() {
+ return TestUtils.validateProfile(waterSchema, goodSpecString);
+ }
+
+
+ record Result(BaseSchemaValidator.Result output, String cliOutput) {}
+}
diff --git a/planetiler-custommap/pom.xml b/planetiler-custommap/pom.xml
index 40548cc7e2..c02e323e21 100644
--- a/planetiler-custommap/pom.xml
+++ b/planetiler-custommap/pom.xml
@@ -18,10 +18,6 @@
planetiler-core
${project.parent.version}
-
- org.snakeyaml
- snakeyaml-engine
-
org.commonmark
commonmark
diff --git a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/ConfiguredMapMain.java b/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/ConfiguredMapMain.java
index 23283e531d..ff73a1f56c 100644
--- a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/ConfiguredMapMain.java
+++ b/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/ConfiguredMapMain.java
@@ -5,6 +5,7 @@
import com.onthegomap.planetiler.custommap.configschema.DataSourceType;
import com.onthegomap.planetiler.custommap.configschema.SchemaConfig;
import com.onthegomap.planetiler.custommap.expression.ParseException;
+import com.onthegomap.planetiler.util.YAML;
import java.nio.file.Files;
import java.nio.file.Path;
diff --git a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/configschema/SchemaConfig.java b/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/configschema/SchemaConfig.java
index c4b70912a9..fc11d488cc 100644
--- a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/configschema/SchemaConfig.java
+++ b/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/configschema/SchemaConfig.java
@@ -1,7 +1,7 @@
package com.onthegomap.planetiler.custommap.configschema;
import com.fasterxml.jackson.annotation.JsonProperty;
-import com.onthegomap.planetiler.custommap.YAML;
+import com.onthegomap.planetiler.util.YAML;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Map;
diff --git a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaValidator.java b/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaValidator.java
index b112a189fb..53b9f64d1d 100644
--- a/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaValidator.java
+++ b/planetiler-custommap/src/main/java/com/onthegomap/planetiler/custommap/validator/SchemaValidator.java
@@ -1,44 +1,31 @@
package com.onthegomap.planetiler.custommap.validator;
import com.fasterxml.jackson.core.JacksonException;
-import com.onthegomap.planetiler.FeatureCollector;
-import com.onthegomap.planetiler.Profile;
import com.onthegomap.planetiler.config.Arguments;
-import com.onthegomap.planetiler.config.PlanetilerConfig;
import com.onthegomap.planetiler.custommap.ConfiguredProfile;
import com.onthegomap.planetiler.custommap.Contexts;
-import com.onthegomap.planetiler.custommap.YAML;
import com.onthegomap.planetiler.custommap.configschema.SchemaConfig;
-import com.onthegomap.planetiler.geo.GeometryType;
-import com.onthegomap.planetiler.reader.SimpleFeature;
-import com.onthegomap.planetiler.stats.Stats;
import com.onthegomap.planetiler.util.AnsiColors;
-import com.onthegomap.planetiler.util.FileWatcher;
-import com.onthegomap.planetiler.util.Format;
-import com.onthegomap.planetiler.util.Try;
+import com.onthegomap.planetiler.util.YAML;
+import com.onthegomap.planetiler.validator.BaseSchemaValidator;
+import com.onthegomap.planetiler.validator.SchemaSpecification;
import java.io.PrintStream;
import java.nio.file.Path;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
import java.util.List;
-import java.util.Locale;
-import java.util.Objects;
import java.util.Set;
-import java.util.TreeSet;
import java.util.stream.Stream;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.locationtech.jts.geom.Geometry;
-import org.locationtech.jts.io.ParseException;
-import org.locationtech.jts.io.WKTReader;
import org.snakeyaml.engine.v2.exceptions.YamlEngineException;
-/** Verifies that a profile maps input elements map to expected output vector tile features. */
-public class SchemaValidator {
+public class SchemaValidator extends BaseSchemaValidator {
- private static final String PASS_BADGE = AnsiColors.greenBackground(" PASS ");
- private static final String FAIL_BADGE = AnsiColors.redBackground(" FAIL ");
+ private final Path schemaPath;
+
+ SchemaValidator(Arguments args, String schemaFile, PrintStream output) {
+ super(args, output);
+ schemaPath = schemaFile == null ? args.inputFile("schema", "Schema file") :
+ args.inputFile("schema", "Schema file", Path.of(schemaFile));
+ }
public static void main(String[] args) {
// let users run `verify schema.yml` as a shortcut
@@ -48,36 +35,24 @@ public static void main(String[] args) {
args = Stream.of(args).skip(1).toArray(String[]::new);
}
var arguments = Arguments.fromEnvOrArgs(args);
- var schema = schemaFile == null ? arguments.inputFile("schema", "Schema file") :
- arguments.inputFile("schema", "Schema file", Path.of(schemaFile));
- var watch =
- arguments.getBoolean("watch", "Watch files for changes and re-run validation when schema or spec changes", false);
-
-
- PrintStream output = System.out;
- output.println("OK");
- var paths = validateFromCli(schema, output);
-
- if (watch) {
- output.println();
- output.println("Watching filesystem for changes...");
- var watcher = FileWatcher.newWatcher(paths.toArray(Path[]::new));
- watcher.pollForChanges(Duration.ofMillis(300), changed -> validateFromCli(schema, output));
- }
+ new SchemaValidator(arguments, schemaFile, System.out).runOrWatch();
}
- private static boolean hasCause(Throwable t, Class cause) {
- return t != null && (cause.isInstance(t) || hasCause(t.getCause(), cause));
+
+ /**
+ * Returns the result of validating the profile defined by {@code schema} against the examples in
+ * {@code specification}.
+ */
+ public static Result validate(SchemaConfig schema, SchemaSpecification specification) {
+ var context = Contexts.buildRootContext(Arguments.of().silence(), schema.args());
+ return validate(new ConfiguredProfile(schema, context), specification, context.config());
}
- static Set validateFromCli(Path schemaPath, PrintStream output) {
- Set pathsToWatch = new HashSet<>();
- pathsToWatch.add(schemaPath);
- output.println();
- output.println("Validating...");
- output.println();
- SchemaValidator.Result result;
+ @Override
+ protected Result validate(Set pathsToWatch) {
+ Result result = null;
try {
+ pathsToWatch.add(schemaPath);
var schema = SchemaConfig.load(schemaPath);
var examples = schema.examples();
// examples can either be embedded in the yaml file, or referenced
@@ -108,169 +83,7 @@ static Set validateFromCli(Path schemaPath, PrintStream output) {
String.join("\n", ExceptionUtils.getStackTrace(rootCause)))
.indent(4));
}
- return pathsToWatch;
- }
- int failed = 0, passed = 0;
- List failures = new ArrayList<>();
- for (var example : result.results) {
- if (example.ok()) {
- passed++;
- output.printf("%s %s%n", PASS_BADGE, example.example().name());
- } else {
- failed++;
- printFailure(example, output);
- failures.add(example);
- }
- }
- if (!failures.isEmpty()) {
- output.println();
- output.println("Summary of failures:");
- for (var failure : failures) {
- printFailure(failure, output);
- }
- }
- List summary = new ArrayList<>();
- boolean none = (passed + failed) == 0;
- if (none || failed > 0) {
- summary.add(AnsiColors.redBold(failed + " failed"));
- }
- if (none || passed > 0) {
- summary.add(AnsiColors.greenBold(passed + " passed"));
- }
- if (none || passed > 0 && failed > 0) {
- summary.add((failed + passed) + " total");
- }
- output.println();
- output.println(String.join(", ", summary));
- return pathsToWatch;
- }
-
- private static void printFailure(ExampleResult example, PrintStream output) {
- output.printf("%s %s%n", FAIL_BADGE, example.example().name());
- if (example.issues.isFailure()) {
- output.println(ExceptionUtils.getStackTrace(example.issues.exception()).indent(4).stripTrailing());
- } else {
- for (var issue : example.issues().get()) {
- output.println(" ● " + issue.indent(4).strip());
- }
- }
- }
-
- private static Geometry parseGeometry(String geometry) {
- String wkt = switch (geometry.toLowerCase(Locale.ROOT).trim()) {
- case "point" -> "POINT (0 0)";
- case "line" -> "LINESTRING (0 0, 1 1)";
- case "polygon" -> "POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))";
- default -> geometry;
- };
- try {
- return new WKTReader().read(wkt);
- } catch (ParseException e) {
- throw new IllegalArgumentException("""
- Bad geometry: "%s", must be "point" "line" "polygon" or a valid WKT string.
- """.formatted(geometry));
- }
- }
-
- /**
- * Returns the result of validating the profile defined by {@code schema} against the examples in
- * {@code specification}.
- */
- public static Result validate(SchemaConfig schema, SchemaSpecification specification) {
- var context = Contexts.buildRootContext(Arguments.of().silence(), schema.args());
- return validate(new ConfiguredProfile(schema, context), specification, context.config());
- }
-
- /** Returns the result of validating {@code profile} against the examples in {@code specification}. */
- public static Result validate(Profile profile, SchemaSpecification specification, PlanetilerConfig config) {
- var featureCollectorFactory = new FeatureCollector.Factory(config, Stats.inMemory());
- return new Result(specification.examples().stream().map(example -> new ExampleResult(example, Try.apply(() -> {
- List issues = new ArrayList<>();
- var input = example.input();
- var expectedFeatures = example.output();
- var geometry = parseGeometry(input.geometry());
- var feature = SimpleFeature.create(geometry, input.tags(), input.source(), null, 0);
- var collector = featureCollectorFactory.get(feature);
- profile.processFeature(feature, collector);
- List result = new ArrayList<>();
- collector.forEach(result::add);
- if (result.size() != expectedFeatures.size()) {
- issues.add(
- "Different number of elements, expected=%s actual=%s".formatted(expectedFeatures.size(), result.size()));
- } else {
- // TODO print a diff of the input and output feature YAML representations
- for (int i = 0; i < expectedFeatures.size(); i++) {
- var expected = expectedFeatures.get(i);
- var actual = result.stream().max(proximityTo(expected)).orElseThrow();
- result.remove(actual);
- var actualTags = actual.getAttrsAtZoom(expected.atZoom());
- String prefix = "feature[%d]".formatted(i);
- validate(prefix + ".layer", issues, expected.layer(), actual.getLayer());
- validate(prefix + ".minzoom", issues, expected.minZoom(), actual.getMinZoom());
- validate(prefix + ".maxzoom", issues, expected.maxZoom(), actual.getMaxZoom());
- validate(prefix + ".minsize", issues, expected.minSize(), actual.getMinPixelSizeAtZoom(expected.atZoom()));
- validate(prefix + ".geometry", issues, expected.geometry(), GeometryType.typeOf(actual.getGeometry()));
- Set tags = new TreeSet<>(actualTags.keySet());
- expected.tags().forEach((tag, value) -> {
- validate(prefix + ".tags[\"%s\"]".formatted(tag), issues, value, actualTags.get(tag), false);
- tags.remove(tag);
- });
- if (Boolean.FALSE.equals(expected.allowExtraTags())) {
- for (var tag : tags) {
- validate(prefix + ".tags[\"%s\"]".formatted(tag), issues, null, actualTags.get(tag), false);
- }
- }
- }
- }
- return issues;
- }))).toList());
- }
-
- private static Comparator proximityTo(SchemaSpecification.OutputFeature expected) {
- return Comparator.comparingInt(item -> (Objects.equals(item.getLayer(), expected.layer()) ? 2 : 0) +
- (Objects.equals(GeometryType.typeOf(item.getGeometry()), expected.geometry()) ? 1 : 0));
- }
-
- private static void validate(String field, List issues, T expected, T actual, boolean ignoreWhenNull) {
- if ((!ignoreWhenNull || expected != null) && !Objects.equals(expected, actual)) {
- // handle when expected and actual are int/long or long/int
- if (expected instanceof Number && actual instanceof Number && expected.toString().equals(actual.toString())) {
- return;
- }
- issues.add("%s: expected <%s> actual <%s>".formatted(field, format(expected), format(actual)));
- }
- }
-
- private static String format(Object o) {
- if (o == null) {
- return "null";
- } else if (o instanceof String s) {
- return Format.quote(s);
- } else {
- return o.toString();
- }
- }
-
- private static void validate(String field, List issues, T expected, T actual) {
- validate(field, issues, expected, actual, true);
- }
-
- /** Result of comparing the output vector tile feature to what was expected. */
- public record ExampleResult(
- SchemaSpecification.Example example,
- // TODO include a symmetric diff so we can pretty-print the expected/actual output diff
- Try> issues
- ) {
-
- public boolean ok() {
- return issues.isSuccess() && issues.get().isEmpty();
- }
- }
-
- public record Result(List results) {
-
- public boolean ok() {
- return results.stream().allMatch(ExampleResult::ok);
}
+ return result;
}
}
diff --git a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/BooleanExpressionParserTest.java b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/BooleanExpressionParserTest.java
index b7dec4a8d8..5b17b81b59 100644
--- a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/BooleanExpressionParserTest.java
+++ b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/BooleanExpressionParserTest.java
@@ -4,6 +4,7 @@
import static org.junit.jupiter.api.Assertions.assertEquals;
import com.onthegomap.planetiler.expression.Expression;
+import com.onthegomap.planetiler.util.YAML;
import java.util.Map;
import org.junit.jupiter.api.Test;
diff --git a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/ConfigExpressionParserTest.java b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/ConfigExpressionParserTest.java
index 78f8804e25..46c25652ea 100644
--- a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/ConfigExpressionParserTest.java
+++ b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/ConfigExpressionParserTest.java
@@ -8,6 +8,7 @@
import com.onthegomap.planetiler.expression.DataType;
import com.onthegomap.planetiler.expression.Expression;
import com.onthegomap.planetiler.expression.MultiExpression;
+import com.onthegomap.planetiler.util.YAML;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
diff --git a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/SchemaTests.java b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/SchemaTests.java
index 3400fe668d..ab9c918366 100644
--- a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/SchemaTests.java
+++ b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/SchemaTests.java
@@ -1,35 +1,26 @@
package com.onthegomap.planetiler.custommap;
-import static org.junit.jupiter.api.DynamicTest.dynamicTest;
-
+import com.onthegomap.planetiler.TestUtils;
+import com.onthegomap.planetiler.config.Arguments;
import com.onthegomap.planetiler.custommap.configschema.SchemaConfig;
-import com.onthegomap.planetiler.custommap.validator.SchemaSpecification;
-import com.onthegomap.planetiler.custommap.validator.SchemaValidator;
+import com.onthegomap.planetiler.validator.SchemaSpecification;
import java.nio.file.Path;
-import java.util.List;
-import org.junit.jupiter.api.DynamicTest;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DynamicNode;
import org.junit.jupiter.api.TestFactory;
class SchemaTests {
@TestFactory
- List shortbread() {
- return testSchema("shortbread.yml", "shortbread.spec.yml");
+ Stream shortbread() {
+ return test("shortbread.yml", "shortbread.spec.yml");
}
- private List testSchema(String schema, String spec) {
+ private static Stream test(String schemaFile, String specFile) {
var base = Path.of("src", "main", "resources", "samples");
- var result = SchemaValidator.validate(
- SchemaConfig.load(base.resolve(schema)),
- SchemaSpecification.load(base.resolve(spec))
- );
- return result.results().stream()
- .map(test -> dynamicTest(test.example().name(), () -> {
- if (test.issues().isFailure()) {
- throw test.issues().exception();
- }
- if (!test.issues().get().isEmpty()) {
- throw new AssertionError("Validation failed:\n" + String.join("\n", test.issues().get()));
- }
- })).toList();
+ SchemaConfig schema = SchemaConfig.load(base.resolve(schemaFile));
+ SchemaSpecification specification = SchemaSpecification.load(base.resolve(specFile));
+ var context = Contexts.buildRootContext(Arguments.of().silence(), schema.args());
+ var profile = new ConfiguredProfile(schema, context);
+ return TestUtils.validateProfile(profile, specification);
}
}
diff --git a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/validator/SchemaValidatorTest.java b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/validator/SchemaValidatorTest.java
index eff36cc9c9..3672493398 100644
--- a/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/validator/SchemaValidatorTest.java
+++ b/planetiler-custommap/src/test/java/com/onthegomap/planetiler/custommap/validator/SchemaValidatorTest.java
@@ -5,7 +5,10 @@
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import com.onthegomap.planetiler.config.Arguments;
import com.onthegomap.planetiler.custommap.configschema.SchemaConfig;
+import com.onthegomap.planetiler.validator.BaseSchemaValidator;
+import com.onthegomap.planetiler.validator.SchemaSpecification;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
@@ -22,7 +25,7 @@ class SchemaValidatorTest {
@TempDir
Path tmpDir;
- record Result(SchemaValidator.Result output, String cliOutput) {}
+ record Result(BaseSchemaValidator.Result output, String cliOutput) {}
private Result validate(String schema, String spec) throws IOException {
var result = SchemaValidator.validate(
@@ -57,55 +60,13 @@ private String validateCli(Path path) {
var baos = new ByteArrayOutputStream();
var printStream = new PrintStream(baos, true, StandardCharsets.UTF_8)
) {
- SchemaValidator.validateFromCli(
- path,
- printStream
- );
+ new SchemaValidator(Arguments.of(), path.toString(), printStream).validateFromCli();
return baos.toString(StandardCharsets.UTF_8);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
- String waterSchema = """
- sources:
- osm:
- type: osm
- url: geofabrik:rhode-island
- layers:
- - id: water
- features:
- - source: osm
- geometry: polygon
- min_size: 10
- include_when:
- natural: water
- attributes:
- - key: natural
- """;
-
- private Result validateWater(String layer, String geometry, String tags, String allowExtraTags) throws IOException {
- return validate(
- waterSchema,
- """
- examples:
- - name: test output
- input:
- source: osm
- geometry: polygon
- tags:
- natural: water
- output:
- layer: %s
- geometry: %s
- %s
- tags:
- %s
- """.formatted(layer, geometry, allowExtraTags == null ? "" : allowExtraTags,
- tags == null ? "" : tags.indent(6).strip())
- );
- }
-
@ParameterizedTest
@CsvSource(value = {
"true,water,polygon,natural: water,",
@@ -128,37 +89,23 @@ private Result validateWater(String layer, String geometry, String tags, String
})
void testValidateWaterPolygon(boolean shouldBeOk, String layer, String geometry, String tags, String allowExtraTags)
throws IOException {
- var results = validateWater(layer, geometry, tags, allowExtraTags);
- assertEquals(1, results.output.results().size());
- assertEquals("test output", results.output.results().get(0).example().name());
- if (shouldBeOk) {
- assertTrue(results.output.ok(), results.toString());
- assertFalse(results.cliOutput.contains("FAIL"), "contained FAIL but should not have: " + results.cliOutput);
- } else {
- assertFalse(results.output.ok(), "Expected an issue, but there were none");
- assertTrue(results.cliOutput.contains("FAIL"), "did not contain FAIL but should have: " + results.cliOutput);
- }
- }
-
- @Test
- void testValidationFailsWrongNumberOfFeatures() throws IOException {
var results = validate(
- waterSchema,
"""
- examples:
- - name: test output
- input:
- source: osm
+ sources:
+ osm:
+ type: osm
+ url: geofabrik:rhode-island
+ layers:
+ - id: water
+ features:
+ - source: osm
geometry: polygon
- tags:
+ min_size: 10
+ include_when:
natural: water
- output:
- """
- );
- assertFalse(results.output.ok(), results.toString());
-
- results = validate(
- waterSchema,
+ attributes:
+ - key: natural
+ """,
"""
examples:
- name: test output
@@ -168,17 +115,23 @@ void testValidationFailsWrongNumberOfFeatures() throws IOException {
tags:
natural: water
output:
- - layer: water
- geometry: polygon
- tags:
- natural: water
- - layer: water2
- geometry: polygon
+ layer: %s
+ geometry: %s
+ %s
tags:
- natural: water2
- """
+ %s
+ """.formatted(layer, geometry, allowExtraTags == null ? "" : allowExtraTags,
+ tags == null ? "" : tags.indent(6).strip())
);
- assertFalse(results.output.ok(), results.toString());
+ assertEquals(1, results.output.results().size());
+ assertEquals("test output", results.output.results().get(0).example().name());
+ if (shouldBeOk) {
+ assertTrue(results.output.ok(), results.toString());
+ assertFalse(results.cliOutput.contains("FAIL"), "contained FAIL but should not have: " + results.cliOutput);
+ } else {
+ assertFalse(results.output.ok(), "Expected an issue, but there were none");
+ assertTrue(results.cliOutput.contains("FAIL"), "did not contain FAIL but should have: " + results.cliOutput);
+ }
}
@Test
diff --git a/planetiler-dist/pom.xml b/planetiler-dist/pom.xml
index 7af1b23c7a..86f3092ce1 100644
--- a/planetiler-dist/pom.xml
+++ b/planetiler-dist/pom.xml
@@ -43,6 +43,11 @@
planetiler-custommap
${project.parent.version}
+
+ com.onthegomap.planetiler
+ planetiler-experimental
+ ${project.parent.version}
+
com.onthegomap.planetiler
planetiler-examples
diff --git a/planetiler-dist/src/main/java/com/onthegomap/planetiler/Main.java b/planetiler-dist/src/main/java/com/onthegomap/planetiler/Main.java
index df949ed305..3ce174b325 100644
--- a/planetiler-dist/src/main/java/com/onthegomap/planetiler/Main.java
+++ b/planetiler-dist/src/main/java/com/onthegomap/planetiler/Main.java
@@ -10,6 +10,9 @@
import com.onthegomap.planetiler.examples.OsmQaTiles;
import com.onthegomap.planetiler.examples.ToiletsOverlay;
import com.onthegomap.planetiler.examples.ToiletsOverlayLowLevelApi;
+import com.onthegomap.planetiler.experimental.lua.GenerateLuaTypes;
+import com.onthegomap.planetiler.experimental.lua.LuaMain;
+import com.onthegomap.planetiler.experimental.lua.LuaValidator;
import com.onthegomap.planetiler.mbtiles.Verify;
import com.onthegomap.planetiler.util.TileSizeStats;
import com.onthegomap.planetiler.util.TopOsmTiles;
@@ -43,12 +46,20 @@ public class Main {
entry("generate-custom", ConfiguredMapMain::main),
entry("custom", ConfiguredMapMain::main),
+ entry("lua", LuaMain::main),
+ entry("lua-types", GenerateLuaTypes::main),
+
entry("generate-shortbread", bundledSchema("shortbread.yml")),
entry("shortbread", bundledSchema("shortbread.yml")),
- entry("verify", SchemaValidator::main),
+ entry("verify", validate()),
entry("verify-custom", SchemaValidator::main),
entry("verify-schema", SchemaValidator::main),
+ entry("verify-lua", LuaValidator::main),
+ entry("validate", validate()),
+ entry("validate-custom", SchemaValidator::main),
+ entry("validate-schema", SchemaValidator::main),
+ entry("validate-lua", LuaValidator::main),
entry("example-bikeroutes", BikeRouteOverlay::main),
entry("example-toilets", ToiletsOverlay::main),
@@ -73,6 +84,16 @@ private static EntryPoint bundledSchema(String path) {
).toArray(String[]::new));
}
+ private static EntryPoint validate() {
+ return args -> {
+ if (Arrays.stream(args).anyMatch(d -> d.endsWith(".lua"))) {
+ LuaValidator.main(args);
+ } else {
+ SchemaValidator.main(args);
+ }
+ };
+ }
+
public static void main(String[] args) throws Exception {
EntryPoint task = DEFAULT_TASK;
@@ -81,6 +102,9 @@ public static void main(String[] args) throws Exception {
if (maybeTask.matches("^.*\\.ya?ml$")) {
task = ConfiguredMapMain::main;
args[0] = "--schema=" + args[0];
+ } else if (maybeTask.matches("^.*\\.lua$")) {
+ task = LuaMain::main;
+ args[0] = "--script=" + args[0];
} else {
EntryPoint taskFromArg0 = ENTRY_POINTS.get(maybeTask);
if (taskFromArg0 != null) {
diff --git a/planetiler-experimental/pom.xml b/planetiler-experimental/pom.xml
new file mode 100644
index 0000000000..b11a29e351
--- /dev/null
+++ b/planetiler-experimental/pom.xml
@@ -0,0 +1,43 @@
+
+
+
+ 4.0.0
+
+ planetiler-experimental
+
+
+ com.onthegomap.planetiler
+ planetiler-parent
+ ${revision}
+
+
+
+
+ com.onthegomap.planetiler
+ planetiler-core
+ ${project.parent.version}
+
+
+
+ org.luaj
+ luaj-jse
+ 3.0.1
+
+
+ org.apache.bcel
+ bcel
+ 6.7.0
+
+
+
+
+ com.onthegomap.planetiler
+ planetiler-core
+ ${project.parent.version}
+ test-jar
+ test
+
+
+
diff --git a/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/GenerateLuaTypes.java b/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/GenerateLuaTypes.java
new file mode 100644
index 0000000000..b2444b27a7
--- /dev/null
+++ b/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/GenerateLuaTypes.java
@@ -0,0 +1,499 @@
+package com.onthegomap.planetiler.experimental.lua;
+
+import static com.onthegomap.planetiler.experimental.lua.JavaToLuaCase.transformMemberName;
+import static java.util.Map.entry;
+
+import com.google.common.base.CaseFormat;
+import com.google.common.reflect.Invokable;
+import com.google.common.reflect.TypeToken;
+import com.onthegomap.planetiler.util.Format;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.RecordComponent;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+import org.luaj.vm2.LuaDouble;
+import org.luaj.vm2.LuaInteger;
+import org.luaj.vm2.LuaNumber;
+import org.luaj.vm2.LuaString;
+import org.luaj.vm2.LuaTable;
+import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.lib.jse.LuaBindMethods;
+import org.luaj.vm2.lib.jse.LuaFunctionType;
+import org.luaj.vm2.lib.jse.LuaGetter;
+import org.luaj.vm2.lib.jse.LuaSetter;
+import org.luaj.vm2.lib.jse.LuaType;
+
+/**
+ * Generates a lua file with type definitions for the lua environment exposed by planetiler.
+ *
+ *
+ * java -jar planetiler.jar lua-types > types.lua
+ *
+ *
+ * @see Lua Language Server type annotations
+ */
+public class GenerateLuaTypes {
+ private static final Map, String> TYPE_NAMES = Map.ofEntries(
+ entry(Object.class, "any"),
+ entry(LuaInteger.class, "integer"),
+ entry(LuaDouble.class, "number"),
+ entry(LuaNumber.class, "number"),
+ entry(LuaString.class, "string"),
+ entry(LuaTable.class, "table"),
+ entry(Class.class, "userdata"),
+ entry(String.class, "string"),
+ entry(Number.class, "number"),
+ entry(byte[].class, "string"),
+ entry(Integer.class, "integer"),
+ entry(int.class, "integer"),
+ entry(Long.class, "integer"),
+ entry(long.class, "integer"),
+ entry(Short.class, "integer"),
+ entry(short.class, "integer"),
+ entry(Byte.class, "integer"),
+ entry(byte.class, "integer"),
+ entry(Double.class, "number"),
+ entry(double.class, "number"),
+ entry(Float.class, "number"),
+ entry(float.class, "number"),
+ entry(boolean.class, "boolean"),
+ entry(Boolean.class, "boolean"),
+ entry(Void.class, "nil"),
+ entry(void.class, "nil")
+ );
+ private static final TypeToken> LIST_TYPE = new TypeToken<>() {};
+ private static final TypeToken> MAP_TYPE = new TypeToken<>() {};
+ private final Deque debugStack = new LinkedList<>();
+ private final Set handled = new HashSet<>();
+ private final StringBuilder builder = new StringBuilder();
+ private static final String NEWLINE = System.lineSeparator();
+
+ GenerateLuaTypes() {
+ write("""
+ ---@meta
+ local types = {}
+ """);
+ }
+
+ public static void main(String[] args) {
+ var generator = new GenerateLuaTypes().generatePlanetiler();
+ System.out.println(generator.toString().replaceAll("[\r\n]+", NEWLINE));
+ }
+
+ private static String luaClassName(Class clazz) {
+ return clazz.getName().replaceAll("[\\$\\.]", "_");
+ }
+
+ private static boolean differentFromParents2(Invokable invokable, TypeToken superType) {
+ if (!invokable.getReturnType().equals(superType.resolveType(invokable.getReturnType().getType()))) {
+ return true;
+ }
+ var orig =
+ invokable.getParameters().stream()
+ .map(t -> invokable.getOwnerType().resolveType(t.getType().getType()))
+ .toList();
+ var resolved = invokable.getParameters().stream().map(t -> superType.resolveType(t.getType().getType())).toList();
+ return !orig.equals(resolved);
+ }
+
+ private static boolean hasMethod(Class clazz, Method method) {
+ try {
+ clazz.getMethod(method.getName(), method.getParameterTypes());
+ return true;
+ } catch (NoSuchMethodException e) {
+ return false;
+ }
+ }
+
+ private void write(String line) {
+ builder.append(line).append(NEWLINE);
+ }
+
+ GenerateLuaTypes generatePlanetiler() {
+ exportGlobalInstance("planetiler", LuaEnvironment.PlanetilerNamespace.class);
+ for (var clazz : LuaEnvironment.CLASSES_TO_EXPOSE) {
+ exportGlobalType(clazz);
+ }
+ return this;
+ }
+
+ void exportGlobalInstance(String name, Class clazz) {
+ write("---@class (exact) " + getInstanceTypeName(clazz));
+ write(name + " = {}");
+ }
+
+ void exportGlobalType(Class clazz) {
+ write("---@class (exact) " + getStaticTypeName(clazz));
+ write(clazz.getSimpleName() + " = {}");
+ }
+
+ private String getStaticTypeName(Class clazz) {
+ String name = luaClassName(clazz) + "__class";
+ debugStack.push(" -> " + clazz.getSimpleName());
+ try {
+ if (handled.add(name)) {
+ write(getStaticTypeDefinition(clazz));
+ }
+ return name;
+ } finally {
+ debugStack.pop();
+ }
+ }
+
+ private String getInstanceTypeName(TypeToken type) {
+ if (LIST_TYPE.isSupertypeOf(type)) {
+ return getInstanceTypeName(type.resolveType(LIST_TYPE.getRawType().getTypeParameters()[0])) + "[]";
+ } else if (MAP_TYPE.isSupertypeOf(type)) {
+ return "{[%s]: %s}".formatted(
+ getInstanceTypeName(type.resolveType(MAP_TYPE.getRawType().getTypeParameters()[0])),
+ getInstanceTypeName(type.resolveType(MAP_TYPE.getRawType().getTypeParameters()[1]))
+ );
+ }
+ return getInstanceTypeName(type.getRawType());
+ }
+
+ private String getInstanceTypeName(Class clazz) {
+ if (clazz.getPackageName().startsWith("com.google.protobuf")) {
+ return "any";
+ }
+ if (LuaValue.class.equals(clazz)) {
+ throw new IllegalArgumentException("Unhandled LuaValue: " + String.join("", debugStack));
+ }
+ debugStack.push(" -> " + clazz.getSimpleName());
+ try {
+ if (TYPE_NAMES.containsKey(clazz)) {
+ return TYPE_NAMES.get(clazz);
+ }
+ if (clazz.isArray()) {
+ return getInstanceTypeName(clazz.getComponentType()) + "[]";
+ }
+ if (LuaValue.class.isAssignableFrom(clazz)) {
+ return "any";
+ }
+
+ String name = luaClassName(clazz);
+ if (handled.add(name)) {
+ write(getTypeDefinition(clazz));
+ }
+ return name;
+ } finally {
+ debugStack.pop();
+ }
+ }
+
+ String getTypeDefinition(Class clazz) {
+ return generateLuaInstanceTypeDefinition(clazz).generate();
+ }
+
+ String getStaticTypeDefinition(Class clazz) {
+ return generateLuaTypeDefinition(clazz, "__class", true).generate();
+ }
+
+ private LuaTypeDefinition generateLuaInstanceTypeDefinition(Class clazz) {
+ return generateLuaTypeDefinition(clazz, "", false);
+ }
+
+ private LuaTypeDefinition generateLuaTypeDefinition(Class clazz, String suffix, boolean isStatic) {
+ TypeToken type = TypeToken.of(clazz);
+ var definition = new LuaTypeDefinition(type, suffix, isStatic);
+
+ if (!isStatic) {
+ Type superclass = clazz.getGenericSuperclass();
+ if (superclass != null && superclass != Object.class) {
+ definition.addParent(type.resolveType(superclass));
+ }
+ for (var iface : clazz.getGenericInterfaces()) {
+ definition.addParent(type.resolveType(iface));
+ }
+ }
+
+ for (var field : clazz.getFields()) {
+ TypeToken rawType = TypeToken.of(field.getDeclaringClass()).resolveType(field.getGenericType());
+ TypeToken typeOnThisClass = type.resolveType(field.getGenericType());
+ if (Modifier.isPublic(field.getModifiers()) && isStatic == Modifier.isStatic(field.getModifiers()) &&
+ (isStatic || field.getDeclaringClass() == clazz || !rawType.equals(typeOnThisClass))) {
+ definition.addField(field);
+ }
+ }
+
+ Set recordFields = clazz.isRecord() ? Arrays.stream(clazz.getRecordComponents())
+ .map(RecordComponent::getAccessor)
+ .collect(Collectors.toSet()) : Set.of();
+
+ // - declare public (static and nonstatic) methods
+ for (var method : clazz.getMethods()) {
+ if (Modifier.isPublic(method.getModifiers()) && isStatic == Modifier.isStatic(method.getModifiers())) {
+ Invokable invokable = type.method(method);
+ if (!isStatic && !invokable.getOwnerType().equals(type) && !differentFromParents(invokable, type)) {
+ continue;
+ }
+ if (hasMethod(Object.class, method)) {
+ // skip object methods
+ } else if (method.isAnnotationPresent(LuaGetter.class) ||
+ (method.getParameterCount() == 0 && recordFields.contains(method))) {
+ definition.addField(method, method.getGenericReturnType());
+ } else if (method.isAnnotationPresent(LuaSetter.class)) {
+ definition.addField(method, method.getParameterTypes()[0]);
+ } else {
+ definition.addMethod(method);
+ }
+ }
+ }
+
+ if (isStatic) {
+ for (var constructor : clazz.getConstructors()) {
+ if (Modifier.isPublic(constructor.getModifiers())) {
+ definition.addMethod("new", constructor, clazz);
+ }
+ }
+ }
+ return definition;
+ }
+
+ private boolean differentFromParents(Invokable invokable, TypeToken type) {
+ Class superclass = type.getRawType().getSuperclass();
+ if (superclass != null) {
+ var superType = TypeToken.of(superclass);
+ if (differentFromParents2(invokable, superType)) {
+ return true;
+ }
+ }
+ for (var iface : type.getTypes().interfaces()) {
+ if (differentFromParents2(invokable, iface)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public String toString() {
+ return builder.toString();
+ }
+
+ private record LuaFieldDefinition(String name, String type) {
+
+ void write(StringBuilder builder) {
+ builder.append("---@field %s %s%n".formatted(name, type));
+ }
+ }
+
+ private record LuaParameterDefinition(String name, String type) {}
+
+ private record LuaTypeParameter(String name, String superType) {
+
+ @Override
+ public String toString() {
+ return name +
+ ((superType.equals(luaClassName(Object.class)) || "any".equals(superType)) ? "" : (" : " + superType));
+ }
+ }
+
+ private record LuaMethodDefinitions(String name, List typeParameters,
+ List params, String returnType) {
+
+ void write(String typeName, StringBuilder builder) {
+ for (var typeParam : typeParameters) {
+ builder.append("---@generic %s%n".formatted(typeParam));
+ }
+ for (var param : params) {
+ builder.append("---@param %s %s%n".formatted(param.name, param.type));
+ }
+ builder.append("---@return %s%n".formatted(returnType));
+ builder.append("function types.%s:%s(%s) end%n".formatted(
+ typeName,
+ name,
+ params.stream().map(p -> p.name).collect(Collectors.joining(", "))
+ ));
+ }
+
+ public String functionTypeString() {
+ return "fun(%s): %s".formatted(
+ params.stream().map(p -> p.name + ": " + p.type).collect(Collectors.joining(", ")),
+ returnType
+ );
+ }
+
+ public void writeAsField(StringBuilder builder) {
+ builder.append("---@field %s %s%n".formatted(
+ name,
+ functionTypeString()
+ ));
+ }
+ }
+
+ private class LuaTypeDefinition {
+
+ private final TypeToken type;
+ private final boolean isStatic;
+ String name;
+ Set parents = new LinkedHashSet<>();
+ Map fields = new TreeMap<>();
+ Set methods = new TreeSet<>(Comparator.comparing(Record::toString));
+
+ LuaTypeDefinition(TypeToken type, String suffix, boolean isStatic) {
+ this.type = type;
+ this.name = luaClassName(type.getRawType()) + suffix;
+ this.isStatic = isStatic;
+ }
+
+ LuaTypeDefinition(TypeToken type) {
+ this(type, "", false);
+ }
+
+ void addParent(TypeToken type) {
+ parents.add(getInstanceTypeName(type));
+ }
+
+ LuaFieldDefinition addField(Member field, Type fieldType) {
+ try {
+ debugStack.push("." + field.getName());
+ String fieldName = transformMemberName(field.getName());
+ var fieldDefinition =
+ new LuaFieldDefinition(fieldName, getInstanceTypeName(type.resolveType(fieldType)));
+ fields.put(fieldName, fieldDefinition);
+ return fieldDefinition;
+ } finally {
+ debugStack.pop();
+ }
+ }
+
+ LuaFieldDefinition addField(Field field) {
+ if (field.getType().equals(LuaValue.class) && field.isAnnotationPresent(LuaFunctionType.class)) {
+ var functionDetails = field.getAnnotation(LuaFunctionType.class);
+ var target = functionDetails.target();
+ var targetMethod = functionDetails.method().isBlank() ?
+ CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, field.getName()) :
+ functionDetails.method();
+ var matchingMethods = Arrays.stream(target.getDeclaredMethods())
+ .filter(m -> m.getName().equals(targetMethod))
+ .toList();
+ if (matchingMethods.size() != 1) {
+ throw new IllegalArgumentException("Expected exactly 1 method named " + targetMethod +
+ " on " + target.getSimpleName() + ", found " + matchingMethods.size() + " " + String.join("", debugStack));
+ }
+ var definition = new LuaTypeDefinition(type);
+ var method = definition.createMethod(matchingMethods.get(0));
+ var fieldName = transformMemberName(field.getName());
+ var fieldDefinition = new LuaFieldDefinition(
+ fieldName,
+ method.functionTypeString()
+ );
+ fields.put(fieldName, fieldDefinition);
+ return fieldDefinition;
+ }
+ return addField(field, field.getGenericType());
+ }
+
+ void addMethod(Method method) {
+ methods.add(createMethod(method));
+ }
+
+ void addMethod(String methodName, Executable method, Type returnType) {
+ methods.add(createMethod(methodName, method, returnType));
+ }
+
+ private LuaMethodDefinitions createMethod(Method method) {
+ return createMethod(method.getName(), method, method.getGenericReturnType());
+ }
+
+ private LuaMethodDefinitions createMethod(String methodName, Executable method, Type returnType) {
+ methodName = transformMemberName(methodName);
+ List typeParameters = new ArrayList<>();
+ for (var param : method.getTypeParameters()) {
+ typeParameters.add(new LuaTypeParameter(
+ param.getName(),
+ getInstanceTypeName(type.resolveType(param.getBounds()[0]))
+ ));
+ }
+ List parameters = new ArrayList<>();
+ for (var param : method.getParameters()) {
+ parameters.add(new LuaParameterDefinition(
+ transformMemberName(param.getName()),
+ param.isAnnotationPresent(LuaType.class) ? param.getAnnotation(LuaType.class).value() :
+ param.getType() == Path.class ? "%s|string|string[]".formatted(getInstanceTypeName(Path.class)) :
+ resolveType(param.getParameterizedType(), method.getTypeParameters())
+ ));
+ }
+ return new LuaMethodDefinitions(
+ methodName,
+ typeParameters,
+ parameters,
+ resolveType(returnType, method.getTypeParameters())
+ );
+ }
+
+ private String resolveType(Type elementType, TypeVariable[] typeParameters) {
+ var resolvedType = type.resolveType(elementType);
+ // only return type parameter name when it is parameterized at the method level, see:
+ // https://github.com/LuaLS/lua-language-server/issues/734
+ // https://github.com/LuaLS/lua-language-server/issues/1861
+ if (resolvedType.getType() instanceof TypeVariable variable) {
+ for (var typeParam : typeParameters) {
+ if (typeParam.getName().equals(variable.getName())) {
+ return typeParam.getName();
+ }
+ }
+ }
+ return getInstanceTypeName(resolvedType);
+ }
+
+ void write(StringBuilder builder) {
+ String nameToUse = this.name;
+ if (type.getRawType().isEnum() && !isStatic) {
+ nameToUse += "__enum";
+ builder.append("---@alias %s%n".formatted(name));
+ builder.append("---|%s%n".formatted(nameToUse));
+ builder.append("---|integer").append(NEWLINE);
+ for (var constant : type.getRawType().getEnumConstants()) {
+ builder.append("---|%s%n".formatted(Format.quote(constant.toString())));
+ }
+ }
+ builder.append("---@class (exact) %s".formatted(nameToUse));
+ if (!parents.isEmpty()) {
+ builder.append(" : ").append(String.join(", ", parents));
+ }
+ builder.append(NEWLINE);
+ for (var field : fields.values()) {
+ field.write(builder);
+ }
+ boolean bindMethods = type.getRawType().isAnnotationPresent(LuaBindMethods.class);
+ if (bindMethods) {
+ for (var method : methods) {
+ method.writeAsField(builder);
+ }
+ }
+ builder.append("types.%s = {}%n".formatted(nameToUse));
+ if (!bindMethods) {
+ for (var method : methods) {
+ method.write(nameToUse, builder);
+ }
+ }
+ }
+
+ public String generate() {
+ StringBuilder tmp = new StringBuilder();
+ write(tmp);
+ return tmp.toString();
+ }
+
+ }
+}
diff --git a/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/JavaToLuaCase.java b/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/JavaToLuaCase.java
new file mode 100644
index 0000000000..18f445cacf
--- /dev/null
+++ b/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/JavaToLuaCase.java
@@ -0,0 +1,71 @@
+package com.onthegomap.planetiler.experimental.lua;
+
+import static java.lang.Character.isDigit;
+import static java.lang.Character.isLowerCase;
+import static java.lang.Character.isUpperCase;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * Converts conventional javaMemberNames to lua_member_names, and lua keywords to uppercase.
+ */
+public class JavaToLuaCase {
+ public static final Set LUA_KEYWORDS = Set.of(
+ "and", "break", "do", "else", "elseif",
+ "end", "false", "for", "function", "if",
+ "in", "local", "nil", "not", "or",
+ "repeat", "return", "then", "true", "until", "while"
+ );
+ private static final String LOWER = "[a-z]";
+ private static final String DIGIT = "\\d";
+ private static final String UPPER = "[A-Z]";
+ private static final String UPPER_OR_DIGIT = "[" + UPPER + DIGIT + "]";
+ private static final List BOUNDARIES = List.of(
+ // getUTF8string -> get_utf8_string
+ new Boundary(DIGIT, LOWER),
+ // fooBar -> foo_bar
+ new Boundary(LOWER, UPPER),
+ // ASCIIString -> ascii_string, UTF8String -> utf8_string
+ new Boundary(UPPER_OR_DIGIT, UPPER + LOWER)
+ );
+ private static final List BOUNDARY_PATTERNS = BOUNDARIES.stream()
+ .map(b -> Pattern.compile("(" + b.prev + ")(" + b.next + ")"))
+ .toList();
+
+ public static boolean isLowerCamelCase(String fieldName) {
+ var chars = fieldName.toCharArray();
+ if (!isLowerCase(chars[0])) {
+ return false;
+ }
+ boolean upper = false, lower = false, underscore = false;
+ for (char c : chars) {
+ upper |= isUpperCase(c) || isDigit(c);
+ lower |= isLowerCase(c);
+ underscore |= c == '_';
+ }
+ return upper && lower && !underscore;
+ }
+
+ public static String transformMemberName(String fieldName) {
+ if (isLowerCamelCase(fieldName)) {
+ fieldName = camelToSnake(fieldName);
+ }
+ if (LUA_KEYWORDS.contains(fieldName)) {
+ fieldName = Objects.requireNonNull(fieldName).toUpperCase(Locale.ROOT);
+ }
+ return fieldName;
+ }
+
+ private static String camelToSnake(String fieldName) {
+ for (Pattern pattern : BOUNDARY_PATTERNS) {
+ fieldName = pattern.matcher(fieldName).replaceAll("$1_$2");
+ }
+ return fieldName.toLowerCase();
+ }
+
+ private record Boundary(String prev, String next) {}
+}
diff --git a/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/LuaConversions.java b/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/LuaConversions.java
new file mode 100644
index 0000000000..8dd7e41665
--- /dev/null
+++ b/planetiler-experimental/src/main/java/com/onthegomap/planetiler/experimental/lua/LuaConversions.java
@@ -0,0 +1,206 @@
+package com.onthegomap.planetiler.experimental.lua;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import org.luaj.vm2.LuaTable;
+import org.luaj.vm2.LuaTables;
+import org.luaj.vm2.LuaUserdata;
+import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.lib.OneArgFunction;
+import org.luaj.vm2.lib.jse.CoerceJavaToLua;
+import org.luaj.vm2.lib.jse.CoerceLuaToJava;
+
+/**
+ * Helper methods to convert between lua and java types.
+ */
+public interface LuaConversions {
+
+ static LuaValue toLua(Object sourceFeature) {
+ return CoerceJavaToLua.coerce(sourceFeature);
+ }
+
+ static LuaTable toLuaTable(Collection list) {
+ return LuaValue.listOf(list.stream().map(LuaConversions::toLua).toArray(LuaValue[]::new));
+ }
+
+ static LuaTable toLuaTable(Map map) {
+ return LuaValue.tableOf(map.entrySet().stream()
+ .flatMap(entry -> Stream.of(toLua(entry.getKey()), toLua(entry.getValue())))
+ .toArray(LuaValue[]::new));
+ }
+
+ @SuppressWarnings("unchecked")
+ static T toJava(LuaValue value, Class clazz) {
+ return (T) CoerceLuaToJava.coerce(value, clazz);
+ }
+
+ static List