Migrate POI minZoom assigment from plain Java to MultiExpression rules (#539)

* Added base case POI zoom in new MultiExpression

* Moved initial zoom assignments to MultiExpression, seeing one unexplained failure with aerodrome/iata tags

* Moved a bunch of high-zoom point logic to MultiExpression

* Created Matcher.SourceFeatureWithComputedTags() to allow mutation of tags for zoom checks

* Fixed Matcher.SourceFeatureWithComputedTags() to require fewer signature changes

* Moved SourceFeatureWithComputedTags construction into computeExtraTags

* Moved selected small-area polygons into rules

* Moved some protomaps-basemaps: tags to private static strings

* Removed HashMap

* Moved all college/university zooms to rules with new withinRange expression

* Fixed zoom rule ordering failure

* Moved assorted green and other zoom-based polygons to rules

* Moved schools, cemeteries, and national parks to zoom-graded rules

* Corrected withinRange() bounds logic and moved height adjustments to rules

* Reorganized final adjustments for clarity

* Shorthanded a bunch of zoom rules

* Switched to overloaded withinRange() to allow for scientific notation in code

* Moved last top-level tag checks in processOsm() to rules

* De-duped some final logic to clarify identical point/polygon POI behavior

* Renamed and organized zoom rules for legibility

* Tweak, tweak, tweak

* More tweak, tweak, tweak

* Carved zoomsIndex into point-and-polygon-specific MultiExpressions

* Fixed overly-broad point matches on irrelevant tags

* Switched to constants for KIND and MINZOOM strings

* Cleanup

* Condensed some long booleans

* Uppercased more constants

* Bumped version number

* Applied automated code quality suggestions

* Applied additional code quality suggestions

* Committed trailing space removal in comment blocks due to .editorconfig settings

* Replaced single-bound version of withinRange() by atLeast()

Author: migurski

CHANGELOG.md

@@ -1,3 +1,7 @@
+Tiles 4.13.6
+------
+- Translate POI min_zoom= assignments to MultiExpression rules [#539]
+
 Tiles 4.13.5
 ------
 - Translate POI kind= assignments to MultiExpression rules [#537]

tiles/src/main/java/com/protomaps/basemap/Basemap.java

@@ -119,7 +119,7 @@ public String description() {
 
   @Override
   public String version() {
-    return "4.13.5";
+    return "4.13.6";
   }
 
   @Override

tiles/src/main/java/com/protomaps/basemap/feature/Matcher.java

@@ -2,33 +2,35 @@
 
 import com.onthegomap.planetiler.expression.Expression;
 import com.onthegomap.planetiler.expression.MultiExpression;
+import com.onthegomap.planetiler.geo.GeometryException;
 import com.onthegomap.planetiler.geo.GeometryType;
 import com.onthegomap.planetiler.reader.SourceFeature;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.locationtech.jts.geom.Geometry;
 
 /**
  * A utility class for matching source feature properties to values.
- * 
+ *
  * <p>
  * Use the {@link #rule} function to create entries for a Planetiler {@link MultiExpression}. A rule consists of
  * multiple contitions that get joined by a logical AND, and key-value pairs that should be used if all conditions of
  * the rule are true. The key-value pairs of rules that get added later override the key-value pairs of rules that were
  * added earlier.
  * </p>
- * 
+ *
  * <p>
  * The MultiExpression can be used on a source feature and the resulting list of matches can be used in
  * {@link #getString} and similar functions to retrieve a value.
  * </p>
- * 
+ *
  * <p>
  * Example usage:
  * </p>
- * 
+ *
  * <pre>
  * <code>
  *var index = MultiExpression.ofOrdered(List.of(rule(with("highway", "primary"), use("kind", "major_road")))).index();
@@ -42,16 +44,16 @@ public record Use(String key, Object value) {}
 
   /**
    * Creates a matching rule with conditions and values.
-   * 
+   *
    * <p>
    * Create conditions by calling the {@link #with} or {@link #without} functions. All conditions are joined by a
    * logical AND.
    * </p>
-   * 
+   *
    * <p>
    * Create key-value pairs with the {@link #use} function.
    * </p>
-   * 
+   *
    * @param arguments A mix of {@link Use} instances for key-value pairs and {@link Expression} instances for
    *                  conditions.
    * @return A {@link MultiExpression.Entry} containing the rule definition.
@@ -71,13 +73,13 @@ public static MultiExpression.Entry<Map<String, Object>> rule(Object... argument
 
   /**
    * Creates a {@link Use} instance representing a key-value pair to be supplied to the {@link #rule} function.
-   * 
+   *
    * <p>
    * While in principle any Object can be supplied as value, retrievalbe later on are only Strings with
    * {@link #getString}, Integers with {@link #getInteger}, Doubles with {@link #getDouble}, Booleans with
    * {@link #getBoolean}.
    * </p>
-   * 
+   *
    * @param key   The key.
    * @param value The value associated with the key.
    * @return A new {@link Use} instance.
@@ -88,30 +90,30 @@ public static Use use(String key, Object value) {
 
   /**
    * Creates an {@link Expression} that matches any of the specified arguments.
-   * 
+   *
    * <p>
    * If no argument is supplied, matches everything.
    * </p>
-   * 
+   *
    * <p>
    * If one argument is supplied, matches all source features that have this tag, e.g., {@code with("highway")} matches
    * to all source features with a highway tag.
    * </p>
-   * 
+   *
    * <p>
    * If two arguments are supplied, matches to all source features that have this tag-value pair, e.g.,
    * {@code with("highway", "primary")} matches to all source features with highway=primary.
    * </p>
-   * 
+   *
    * <p>
    * If more than two arguments are supplied, matches to all source features that have the first argument as tag and the
    * later arguments as possible values, e.g., {@code with("highway", "primary", "secondary")} matches to all source
    * features that have highway=primary or highway=secondary.
    * </p>
-   * 
+   *
    * <p>
    * If an argument consists of multiple lines, it will be broken up into one argument per line. Example:
-   * 
+   *
    * <pre>
    * <code>
    * with("""
@@ -122,7 +124,7 @@ public static Use use(String key, Object value) {
    * </code>
    * </pre>
    * </p>
-   * 
+   *
    * @param arguments Field names to match.
    * @return An {@link Expression} for the given field names.
    */
@@ -149,6 +151,82 @@ public static Expression without(String... arguments) {
     return Expression.not(with(arguments));
   }
 
+  /**
+   * Creates an {@link Expression} that matches when a numeric tag value is within a specified range.
+   *
+   * <p>
+   * The lower bound is inclusive. The upper bound, if provided, is exclusive.
+   * </p>
+   *
+   * <p>
+   * Tag values that cannot be parsed as numbers or missing tags will not match.
+   * </p>
+   *
+   * @param tagName    The name of the tag to check.
+   * @param lowerBound The inclusive lower bound.
+   * @param upperBound The exclusive upper bound.
+   * @return An {@link Expression} for the numeric range check.
+   */
+  public static Expression withinRange(String tagName, Integer lowerBound, Integer upperBound) {
+    return new WithinRangeExpression(tagName, Long.valueOf(lowerBound), Long.valueOf(upperBound));
+  }
+
+  /**
+   * Overload withinRange to accept lower bound integer and upper bound double
+   */
+  public static Expression withinRange(String tagName, Integer lowerBound, Double upperBound) {
+    return new WithinRangeExpression(tagName, Long.valueOf(lowerBound), upperBound.longValue());
+  }
+
+  /**
+   * Overload withinRange to accept bounds as doubles
+   */
+  public static Expression withinRange(String tagName, Double lowerBound, Double upperBound) {
+    return new WithinRangeExpression(tagName, lowerBound.longValue(), upperBound.longValue());
+  }
+
+  /**
+   * Creates an {@link Expression} that matches when a numeric tag value is greater or equal to a value.
+   *
+   * <p>
+   * Tag values that cannot be parsed as numbers or missing tags will not match.
+   * </p>
+   *
+   * @param tagName    The name of the tag to check.
+   * @param lowerBound The inclusive lower bound.
+   * @return An {@link Expression} for the numeric range check.
+   */
+  public static Expression atLeast(String tagName, Integer lowerBound) {
+    return new WithinRangeExpression(tagName, Long.valueOf(lowerBound), null);
+  }
+
+  /**
+   * Overload atLeast to accept just lower bound double
+   */
+  public static Expression atLeast(String tagName, Double lowerBound) {
+    return new WithinRangeExpression(tagName, lowerBound.longValue(), null);
+  }
+
+  /**
+   * Expression implementation for numeric range matching.
+   */
+  private record WithinRangeExpression(String tagName, long lowerBound, Long upperBound) implements Expression {
+
+    @Override
+    public boolean evaluate(com.onthegomap.planetiler.reader.WithTags input, List<String> matchKeys) {
+      if (!input.hasTag(tagName)) {
+        return false;
+      }
+      long value = input.getLong(tagName);
+      // getLong returns 0 for invalid values, so we need to check if 0 is actually the tag value
+      if (value == 0 && !"0".equals(input.getString(tagName))) {
+        // getLong returned 0 because parsing failed
+        return false;
+      }
+      return value >= lowerBound && (upperBound == null || value < upperBound);
+    }
+  }
+
   public static Expression withPoint() {
     return Expression.matchGeometryType(GeometryType.POINT);
   }
@@ -177,15 +255,15 @@ public record FromTag(String key) {}
 
   /**
    * Creates a {@link FromTag} instance representing a tag reference.
-   * 
+   *
    * <p>
    * Use this function if to retrieve a value from a source feature when calling {@link #getString} and similar.
    * </p>
-   * 
+   *
    * <p>
    * Example usage:
    * </p>
-   * 
+   *
    * <pre>
    * <code>
    *var index = MultiExpression.ofOrdered(List.of(rule(with("highway", "primary", "secondary"), use("kind", fromTag("highway"))))).index();
@@ -195,7 +273,7 @@ public record FromTag(String key) {}
    * </pre>
    * <p>
    * On a source feature with highway=primary the above will result in kind=primary.
-   * 
+   *
    * @param key The key of the tag.
    * @return A new {@link FromTag} instance.
    */
@@ -277,4 +355,66 @@ public static Boolean getBoolean(SourceFeature sf, List<Map<String, Object>> mat
     return defaultValue;
   }
 
+  /**
+   * Wrapper that combines a SourceFeature with computed tags without mutating the original. This allows MultiExpression
+   * matching to access both original and computed tags.
+   *
+   * <p>
+   * This is useful when you need to add computed tags (like area calculations or derived properties) that should be
+   * accessible to MultiExpression rules, but the original SourceFeature has immutable tags.
+   * </p>
+   */
+  public static class SourceFeatureWithComputedTags extends SourceFeature {
+    private final SourceFeature delegate;
+    private final Map<String, Object> combinedTags;
+
+    /**
+     * Creates a wrapper around a SourceFeature with additional computed tags.
+     *
+     * @param delegate     The original SourceFeature to wrap
+     * @param computedTags Additional computed tags to merge with the original tags
+     */
+    public SourceFeatureWithComputedTags(SourceFeature delegate, Map<String, Object> computedTags) {
+      super(new HashMap<>(delegate.tags()), delegate.getSource(), delegate.getSourceLayer(), null, delegate.id());
+      this.delegate = delegate;
+      this.combinedTags = new HashMap<>(delegate.tags());
+      this.combinedTags.putAll(computedTags);
+    }
+
+    @Override
+    public Map<String, Object> tags() {
+      return combinedTags;
+    }
+
+    @Override
+    public Geometry worldGeometry() throws GeometryException {
+      return delegate.worldGeometry();
+    }
+
+    @Override
+    public Geometry latLonGeometry() throws GeometryException {
+      return delegate.latLonGeometry();
+    }
+
+    @Override
+    public boolean isPoint() {
+      return delegate.isPoint();
+    }
+
+    @Override
+    public boolean canBePolygon() {
+      return delegate.canBePolygon();
+    }
+
+    @Override
+    public boolean canBeLine() {
+      return delegate.canBeLine();
+    }
+
+    @Override
+    public boolean hasRelationInfo() {
+      return delegate.hasRelationInfo();
+    }
+  }
+
 }