tg_geometry 0.1.0 → 0.3.0

data/spec/{block_12_batch_packed_spec.rb → batch_packed_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 12 packed batch API" do
+RSpec.describe "Packed batch API" do
   let(:zone_a) { TG::Geometry.parse_wkt("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))") }
   let(:zone_b) { TG::Geometry.parse_wkt("POLYGON ((20 20, 30 20, 30 30, 20 30, 20 20))") }
 

data/spec/{block_20_concurrency_spec.rb → concurrency_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 20 concurrency hardening" do
+RSpec.describe "Concurrency hardening" do
   let(:zone_a) { '{"type":"Polygon","coordinates":[[[0,0],[10,0],[10,10],[0,10],[0,0]]]}' }
   let(:zone_b) { '{"type":"Polygon","coordinates":[[[5,5],[15,5],[15,15],[5,15],[5,5]]]}' }
   let(:zone_c) { '{"type":"Polygon","coordinates":[[[100,100],[110,100],[110,110],[100,110],[100,100]]]}' }

data/spec/constructors_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Constructors" do
+  let(:square) { [[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0], [0.0, 0.0]] }
+  let(:hole_a) { [[2.0, 2.0], [4.0, 2.0], [4.0, 4.0], [2.0, 4.0], [2.0, 2.0]] }
+  let(:hole_b) { [[6.0, 6.0], [8.0, 6.0], [8.0, 8.0], [6.0, 8.0], [6.0, 6.0]] }
+
+  describe ".line_string" do
+    it "builds a frozen two-point linestring" do
+      geom = TG::Geometry.line_string([[0.0, 0.0], [1.0, 1.0]])
+
+      expect(geom).to be_frozen
+      expect(geom.type).to eq(:linestring)
+      expect(geom.line.num_points).to eq(2)
+      expect(geom.srid).to be_nil
+    end
+
+    it "builds a 100-point linestring" do
+      points = 100.times.map { |i| [i.to_f, (i * 2).to_f] }
+      geom = TG::Geometry.line_string(points)
+
+      expect(geom.line.num_points).to eq(100)
+    end
+
+    it "supports explicit index values and srid metadata" do
+      %i[default natural ystripes none].each do |index|
+        geom = TG::Geometry.line_string([[0, 0], [1, 1]], index: index, srid: 4326)
+        expect(geom.srid).to eq(4326)
+      end
+    end
+
+    it "rejects too few points" do
+      expect { TG::Geometry.line_string([[0, 0]]) }
+        .to raise_error(TG::Geometry::ArgumentError, "line_string requires at least 2 points, got 1")
+      expect { TG::Geometry.line_string([]) }
+        .to raise_error(TG::Geometry::ArgumentError, "line_string requires at least 2 points, got 0")
+    end
+
+    it "rejects non-finite coordinates with the bad point index in the message" do
+      expect { TG::Geometry.line_string([[0, 0], [Float::NAN, 1]]) }
+        .to raise_error(TG::Geometry::ArgumentError, /point 1/)
+      expect { TG::Geometry.line_string([[0, 0], [1, Float::INFINITY]]) }
+        .to raise_error(TG::Geometry::ArgumentError, /point 1/)
+    end
+
+    it "rejects out-of-range srid" do
+      expect { TG::Geometry.line_string([[0, 0], [1, 1]], srid: -1) }
+        .to raise_error(TG::Geometry::ArgumentError)
+    end
+  end
+
+  describe ".polygon" do
+    it "builds a square polygon" do
+      geom = TG::Geometry.polygon(square)
+
+      expect(geom.type).to eq(:polygon)
+      expect(geom.polygon.num_holes).to eq(0)
+      expect(geom.covers_xy?(5, 5)).to be(true)
+    end
+
+    it "builds polygons with one or two holes" do
+      one_hole = TG::Geometry.polygon(square, holes: [hole_a], srid: 4326)
+      two_holes = TG::Geometry.polygon(square, holes: [hole_a, hole_b])
+
+      expect(one_hole.srid).to eq(4326)
+      expect(one_hole.polygon.num_holes).to eq(1)
+      expect(one_hole.covers_xy?(3, 3)).to be(false)
+      expect(two_holes.polygon.num_holes).to eq(2)
+    end
+
+    it "treats holes: [] like omitted holes" do
+      expect(TG::Geometry.polygon(square, holes: []).polygon.num_holes).to eq(0)
+      expect(TG::Geometry.polygon(square).polygon.num_holes).to eq(0)
+    end
+
+    it "rejects invalid rings without autoclosing" do
+      expect { TG::Geometry.polygon(square[0...-1]) }
+        .to raise_error(TG::Geometry::ArgumentError, "polygon exterior ring is not closed")
+      expect { TG::Geometry.polygon(square[0, 3]) }
+        .to raise_error(TG::Geometry::ArgumentError, "polygon exterior ring requires at least 4 points")
+      expect { TG::Geometry.polygon(square, holes: [hole_a[0...-1]]) }
+        .to raise_error(TG::Geometry::ArgumentError, "polygon hole 0 is not closed")
+      expect { TG::Geometry.polygon(square, holes: [hole_a[0, 3]]) }
+        .to raise_error(TG::Geometry::ArgumentError, "polygon hole 0 requires at least 4 points")
+    end
+  end
+
+  describe ".multi_polygon" do
+    it "builds empty and non-empty multipolygons" do
+      expect(TG::Geometry.multi_polygon([]).type).to eq(:multipolygon)
+
+      geom = TG::Geometry.multi_polygon([
+        { exterior: square, holes: [hole_a] },
+        [[20.0, 20.0], [21.0, 20.0], [21.0, 21.0], [20.0, 21.0], [20.0, 20.0]]
+      ], srid: 3857)
+
+      expect(geom.type).to eq(:multipolygon)
+      expect(geom.srid).to eq(3857)
+      expect(geom.num_polygons).to eq(2)
+    end
+  end
+end

data/spec/{block_13_error_hardening_spec.rb → error_hardening_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 13 error hardening" do
+RSpec.describe "Error hardening" do
   let(:geojson) { '{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}' }
   let(:wkb) { TG::Geometry.parse_geojson(geojson).to_wkb }
 

data/spec/feature_source_nogvl_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+
+RSpec.describe "FeatureSource no-GVL behavior" do
+  def polygon_feature_json(id, x, y)
+    <<~JSON.chomp
+      {"type":"Feature","properties":{"@id":"zone/#{id}"},"geometry":{"type":"Polygon","coordinates":[[[#{x},#{y}],[#{x + 0.8},#{y}],[#{x + 0.8},#{y + 0.8}],[#{x},#{y + 0.8}],[#{x},#{y}]]]}}
+    JSON
+  end
+
+  def write_large_feature_collection(count)
+    file = Tempfile.new(["tg_geometry_feature_source_nogvl", ".geojson"])
+    file.binmode
+    file.write('{"type":"FeatureCollection","features":[')
+    count.times do |i|
+      file.write(",") unless i.zero?
+      file.write(polygon_feature_json(i, i % 1000, i / 1000))
+    end
+    file.write("]}")
+    file.flush
+    file.close
+    file
+  end
+
+  it "lets other Ruby threads run during large FeatureSource file processing" do
+    count = 40_000
+    file = write_large_feature_collection(count)
+    ticks = 0
+    done = false
+
+    ticker = Thread.new do
+      until done
+        ticks += 1
+        sleep 0.005
+      end
+    end
+
+    index = TG::Geometry::FeatureSource.build_index_file(file.path, strategy: :flat)
+    done = true
+    ticker.join
+
+    expect(index.size).to eq(count)
+    expect(ticks).to be >= 1
+  ensure
+    done = true
+    ticker&.join
+    file&.unlink
+  end
+end

data/spec/feature_source_spec.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "stringio"
+
+RSpec.describe "FeatureSource" do
+  let(:fixture_dir) { File.join(__dir__, "fixtures", "feature_source") }
+  let(:simple_path) { File.join(fixture_dir, "simple_feature_collection.geojson") }
+  let(:simple_json) { File.binread(simple_path) }
+
+  it "defines TG::Geometry::FeatureSource" do
+    expect(TG::Geometry.const_defined?(:FeatureSource)).to be(true)
+  end
+
+  it "reads entries from JSON, file, and IO without parsing properties to Hash" do
+    expected = [["zone/a", /"Polygon"/], [2, /"MultiPolygon"/]]
+
+    [
+      TG::Geometry::FeatureSource.read_entries_json(simple_json),
+      TG::Geometry::FeatureSource.read_entries_file(simple_path),
+      TG::Geometry::FeatureSource.read_entries_io(StringIO.new(simple_json))
+    ].each do |entries|
+      expect(entries.size).to eq(2)
+      expected.each_with_index do |(id, geometry_matcher), i|
+        expect(entries[i][0]).to eq(id)
+        expect(entries[i][1]).to match(geometry_matcher)
+        expect(entries[i][1]).to be_a(String)
+      end
+    end
+  end
+
+  it "reads features with raw properties JSON" do
+    features = TG::Geometry::FeatureSource.read_features_json(simple_json)
+
+    expect(features.size).to eq(2)
+    expect(features[0][0]).to eq("zone/a")
+    expect(features[0][1]).to include('"Polygon"')
+    expect(features[0][2]).to include('"@id": "zone/a"')
+    expect(features[1][2]).to include('"@id": 2')
+  end
+
+  it "uses the OSM-style default id path [properties, @id]" do
+    json = File.binread(File.join(fixture_dir, "osm_like_feature_collection.geojson"))
+
+    entries = TG::Geometry::FeatureSource.read_entries_json(json)
+
+    expect(entries.first.first).to eq("relation/100")
+  end
+
+  it "filters non polygon types by default and reports filtered separately" do
+    json = File.binread(File.join(fixture_dir, "mixed_geometry_types.geojson"))
+
+    report = TG::Geometry::FeatureSource.read_entries_json(json, report: true)
+
+    expect(report[:entries].map(&:first)).to eq(["poly"])
+    expect(report[:filtered]).to eq(2)
+    expect(report[:skipped]).to eq(0)
+    expect(report[:errors]).to eq([])
+  end
+
+  it "supports only: nil for no geometry type filtering" do
+    json = File.binread(File.join(fixture_dir, "mixed_geometry_types.geojson"))
+
+    entries = TG::Geometry::FeatureSource.read_entries_json(json, only: nil)
+
+    expect(entries.map(&:first)).to eq(%w[poly point line])
+  end
+
+  it "requires report mode for skip options" do
+    expect do
+      TG::Geometry::FeatureSource.read_entries_json(simple_json, on_invalid: :skip)
+    end.to raise_error(TG::Geometry::ArgumentError)
+
+    expect do
+      TG::Geometry::FeatureSource.read_entries_json(simple_json, on_missing_id: :skip)
+    end.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "supports on_missing_id: :ordinal" do
+    json = File.binread(File.join(fixture_dir, "properties_null_missing.geojson"))
+
+    entries = TG::Geometry::FeatureSource.read_entries_json(json, on_missing_id: :ordinal)
+
+    expect(entries.map(&:first)).to eq(["feature/0", "feature/1"])
+  end
+
+  it "supports on_missing_id: :skip in report mode without requiring on_invalid: :skip" do
+    json = File.binread(File.join(fixture_dir, "properties_null_missing.geojson"))
+
+    report = TG::Geometry::FeatureSource.read_entries_json(json,
+                                                           report: true,
+                                                           on_missing_id: :skip)
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(2)
+    expect(report[:filtered]).to eq(0)
+    expect(report[:errors].map { |e| e[:feature_index] }).to eq([0, 1])
+  end
+
+  it "reports invalid geometry with capped errors and exact skipped count" do
+    json = File.binread(File.join(fixture_dir, "invalid_geometry_middle.geojson"))
+
+    report = TG::Geometry::FeatureSource.read_entries_json(json,
+                                                           report: true,
+                                                           on_invalid: :skip,
+                                                           max_errors: 1)
+
+    expect(report[:entries].map(&:first)).to eq(["ok-a", "ok-b"])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:errors].size).to eq(1)
+    expect(report[:errors].first[:feature_index]).to eq(1)
+    expect(report[:errors].first[:reason]).to include("invalid geometry")
+  end
+
+  it "raises ParseError for malformed JSON and non FeatureCollection roots" do
+    malformed = File.binread(File.join(fixture_dir, "malformed_json.geojson"))
+
+    expect { TG::Geometry::FeatureSource.read_entries_json(malformed) }
+      .to raise_error(TG::Geometry::ParseError)
+    expect { TG::Geometry::FeatureSource.read_entries_json('{"type":"Feature"}') }
+      .to raise_error(TG::Geometry::ParseError)
+  end
+
+  it "builds an Index directly from JSON, file, and IO" do
+    indexes = [
+      TG::Geometry::FeatureSource.build_index_json(simple_json, strategy: :flat),
+      TG::Geometry::FeatureSource.build_index_file(simple_path, strategy: :flat),
+      TG::Geometry::FeatureSource.build_index_io(StringIO.new(simple_json), strategy: :flat)
+    ]
+
+    indexes.each do |index|
+      expect(index).to be_a(TG::Geometry::Index)
+      expect(index).to be_frozen
+      expect(index.size).to eq(2)
+      expect(index.find_covering(5, 5)).to eq("zone/a")
+      expect(index.find_covering(25, 25)).to eq(2)
+    end
+  end
+
+  it "matches Index.build(read_entries, via: :geojson) behavior" do
+    entries = TG::Geometry::FeatureSource.read_entries_json(simple_json)
+    from_entries = TG::Geometry::Index.build(entries, via: :geojson, strategy: :flat)
+    direct = TG::Geometry::FeatureSource.build_index_json(simple_json, strategy: :flat)
+
+    [[5, 5], [25, 25], [100, 100]].each do |lon, lat|
+      expect(direct.find_covering(lon, lat)).to eq(from_entries.find_covering(lon, lat))
+    end
+  end
+
+
+  it "raises ParseError with a string reason for missing geometry" do
+    json = '{"type":"FeatureCollection","features":[{"type":"Feature","properties":{"@id":"x"}}]}'
+
+    expect { TG::Geometry::FeatureSource.read_entries_json(json) }
+      .to raise_error(TG::Geometry::ParseError, /feature 0.*missing geometry/)
+  end
+
+  it "reports missing geometry with a string reason in skip mode" do
+    json = '{"type":"FeatureCollection","features":[{"type":"Feature","properties":{"@id":"x"}}]}'
+
+    report = TG::Geometry::FeatureSource.read_entries_json(
+      json,
+      report: true,
+      on_invalid: :skip
+    )
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:filtered]).to eq(0)
+    expect(report[:errors].first[:reason]).to be_a(String)
+    expect(report[:errors].first[:reason]).to include("missing geometry")
+  end
+
+  it "skips invalid id type when on_invalid is skip and report is true" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"@id":false},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    report = TG::Geometry::FeatureSource.read_entries_json(
+      json,
+      report: true,
+      on_invalid: :skip
+    )
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:filtered]).to eq(0)
+    expect(report[:errors].first[:reason]).to include("invalid id")
+  end
+
+  it "skips fractional numeric id when on_invalid is skip and report is true" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"@id":1.2},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    report = TG::Geometry::FeatureSource.read_entries_json(
+      json,
+      report: true,
+      on_invalid: :skip
+    )
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:errors].first[:reason]).to include("numeric id must be an integer")
+  end
+
+  it "raises ParseError for malformed feature shapes" do
+    cases = [
+      '[1]',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":null}',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":"bad"}',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":{"coordinates":[]}}',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":{"type":1,"coordinates":[]}}'
+    ]
+
+    cases.each do |feature_json|
+      json = "{\"type\":\"FeatureCollection\",\"features\":[#{feature_json}]}"
+      expect { TG::Geometry::FeatureSource.read_entries_json(json) }
+        .to raise_error(TG::Geometry::ParseError)
+    end
+  end
+
+  it "raises ParseError for missing or non-array features" do
+    expect { TG::Geometry::FeatureSource.read_entries_json('{"type":"FeatureCollection"}') }
+      .to raise_error(TG::Geometry::ParseError, /features/)
+
+    expect { TG::Geometry::FeatureSource.read_entries_json('{"type":"FeatureCollection","features":{}}') }
+      .to raise_error(TG::Geometry::ParseError, /features/)
+  end
+
+  it "treats invalid properties type as invalid feature for read_features" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":[],"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    expect { TG::Geometry::FeatureSource.read_features_json(json, on_missing_id: :ordinal) }
+      .to raise_error(TG::Geometry::ParseError, /properties must be an object or null/)
+  end
+
+  it "rejects unknown keywords" do
+    expect { TG::Geometry::FeatureSource.read_entries_json(simple_json, typo: 1) }
+      .to raise_error(TG::Geometry::ArgumentError, /unknown keyword/)
+  end
+
+  it "surfaces missing file errors as file errors" do
+    missing = File.join(fixture_dir, "does_not_exist.geojson")
+
+    expect { TG::Geometry::FeatureSource.read_entries_file(missing) }
+      .to raise_error(Errno::ENOENT)
+  end
+
+  it "rejects invalid id types" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"@id":false},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    expect { TG::Geometry::FeatureSource.read_entries_json(json) }
+      .to raise_error(TG::Geometry::ArgumentError)
+  end
+end

data/spec/fixtures/feature_source/invalid_geometry_middle.geojson

@@ -0,0 +1,8 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {"type":"Feature","properties":{"@id":"ok-a"},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]] }},
+    {"type":"Feature","properties":{"@id":"bad"},"geometry":{"type":"Polygon","coordinates":"not coordinates"}},
+    {"type":"Feature","properties":{"@id":"ok-b"},"geometry":{"type":"Polygon","coordinates":[[[2,2],[2,3],[3,3],[3,2],[2,2]]] }}
+  ]
+}

data/spec/fixtures/feature_source/malformed_json.geojson

@@ -0,0 +1 @@
+{"type":"FeatureCollection","features":[

data/spec/fixtures/feature_source/mixed_geometry_types.geojson

@@ -0,0 +1,8 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {"type":"Feature","properties":{"@id":"poly"},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}},
+    {"type":"Feature","properties":{"@id":"point"},"geometry":{"type":"Point","coordinates":[5,5]}},
+    {"type":"Feature","properties":{"@id":"line"},"geometry":{"type":"LineString","coordinates":[[0,0],[1,1]]}}
+  ]
+}

data/spec/fixtures/feature_source/osm_like_feature_collection.geojson

@@ -0,0 +1,10 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {"@id": "relation/100", "admin_level": "8"},
+      "geometry": {"type": "Polygon", "coordinates": [[[0,0],[0,1],[1,1],[1,0],[0,0]]]}
+    }
+  ]
+}

data/spec/fixtures/feature_source/properties_null_missing.geojson

@@ -0,0 +1,7 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {"type":"Feature","properties":null,"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}},
+    {"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[2,2],[2,3],[3,3],[3,2],[2,2]]]}}
+  ]
+}

data/spec/fixtures/feature_source/simple_feature_collection.geojson

@@ -0,0 +1,15 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {"@id": "zone/a", "name": "A"},
+      "geometry": {"type": "Polygon", "coordinates": [[[0,0],[0,10],[10,10],[10,0],[0,0]]]}
+    },
+    {
+      "type": "Feature",
+      "properties": {"@id": 2},
+      "geometry": {"type": "MultiPolygon", "coordinates": [[[[20,20],[20,30],[30,30],[30,20],[20,20]]]]}
+    }
+  ]
+}

data/spec/fixtures/postgis/README.md

@@ -0,0 +1,16 @@
+# PostGIS / EWKB fixtures
+
+These files are committed binary EWKB fixtures used by the v0.3.0 SRID/EWKB tests.
+They are intentionally small and are not generated at spec runtime.
+
+Canonical PostGIS generation examples:
+
+```sql
+SELECT ST_AsEWKB(ST_GeomFromText('POINT(37.6 55.7)', 4326));
+SELECT ST_AsEWKB(ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0))', 4326));
+SELECT ST_AsEWKB(ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(2 2,4 2,4 4,2 4,2 2))', 4326));
+SELECT ST_AsEWKB(ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0))', 3857));
+```
+
+`multipolygon_large.ewkb` is a synthetic large multipolygon fixture with about 7000 points.
+It stands in for a real imported polygon while keeping the repository small.

data/spec/fixtures/postgis/boundary_point_cases.geojson

@@ -0,0 +1,83 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {
+        "name": "inside_simple"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": [
+          1.0,
+          1.0
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "name": "boundary_simple"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": [
+          0.0,
+          5.0
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "name": "hole_center"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": [
+          3.0,
+          3.0
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "name": "between_hole_and_outer"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": [
+          1.0,
+          1.0
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "name": "large_inside"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": [
+          100.0,
+          50.0
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "name": "large_outside"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": [
+          200.0,
+          50.0
+        ]
+      }
+    }
+  ]
+}

data/spec/{expansion_d_format_coverage_spec.rb → format_coverage_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Expansion Block D format coverage" do
+RSpec.describe "Format coverage" do
   it "roundtrips Hex" do
     geom = TG::Geometry.parse_wkt("POINT (1 2)")
     hex = geom.to_hex

data/spec/{block_20_fuzz_spec.rb → fuzz_spec.rb}

@@ -3,7 +3,7 @@
 require "spec_helper"
 require "fileutils"
 
-RSpec.describe "Release Core Block 20 fuzz hardening" do
+RSpec.describe "Fuzz hardening" do
   ITERATIONS = Integer(ENV.fetch("TG_GEOMETRY_FUZZ_ITERATIONS", "2000")).freeze
   SEED = Integer(ENV.fetch("TG_GEOMETRY_FUZZ_SEED", "20260524")).freeze
   CORPUS_DIR = File.expand_path("fixtures/fuzz_corpus", __dir__).freeze

data/spec/{block_4_geom_api_spec.rb → geom_api_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 4 Geom API" do
+RSpec.describe "Geom API" do
   let(:polygon_wkt) { "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))" }
   let(:inner_point_wkt) { "POINT (5 5)" }
   let(:boundary_point_wkt) { "POINT (0 5)" }

data/spec/{block_3_geom_parse_spec.rb → geom_parse_spec.rb}

@@ -3,7 +3,7 @@
 require "spec_helper"
 require "objspace"
 
-RSpec.describe "Release Core Block 3 Geom parsing" do
+RSpec.describe "Geom parsing" do
   let(:geojson_point) { %({"type":"Point","coordinates":[1.0,2.0]}) }
   let(:wkt_point) { "POINT (1 2)" }
   let(:wkb_point) { [1, 1].pack("CL<") + [1.0, 2.0].pack("E2") }