#MoonGeoCodec

#Status

#WKT parser

let geometry = match @moon_geocodec.parse_wkt(
  "POLYGON ((0 0, 1 0, 1 1, 0 0))",
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(geometry.kind(), @moon_geocodec.GeometryKind::Polygon)

#WKT writer

let text = match @moon_geocodec.format_wkt(geometry) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(text, "POLYGON ((0 0, 1 0, 1 1, 0 0))")

#WKT2 and EWKT

let wkt2 = match @moon_geocodec.parse_wkt2(
  "MULTIPOINT ((1 2), (3 4))",
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(
  @moon_geocodec.format_wkt2(wkt2),
  Ok("MULTIPOINT ((1 2), (3 4))"),
)

let ewkt = match @moon_geocodec.parse_ewkt(
  "SRID=4326;POINT (1 2)",
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(ewkt.srid, Some(4326))
assert_eq(
  @moon_geocodec.format_ewkt(ewkt),
  Ok("SRID=4326;POINT (1 2)"),
)

#WKB reader

let geometry = match @moon_geocodec.parse_wkb(
  bytes.exact_view(),
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}

#WKB writer

let bytes = match @moon_geocodec.format_wkb(geometry) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
let big_endian = match @moon_geocodec.format_wkb_with_order(
  geometry,
  @moon_geocodec.WkbByteOrder::BigEndian,
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}

#EWKB

let value = match @moon_geocodec.parse_ewkb(
  ewkb_bytes.exact_view(),
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
let encoded = match @moon_geocodec.format_ewkb(value) {
  Ok(bytes) => bytes
  Err(err) => fail(err.to_string())
}

#GeoJSON import

let geometry = match @moon_geocodec.parse_geojson(
  "{\"type\":\"Point\",\"coordinates\":[1,2]}",
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(
  geometry,
  @moon_geocodec.Geometry::Point(
    @moon_geocodec.Coordinate::xy(1.0, 2.0),
  ),
)

#GeoJSON export and conversions

let text = match @moon_geocodec.format_geojson(geometry) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(
  text,
  "{\"type\":\"Point\",\"coordinates\":[1,2]}",
)

• wkt_to_geojson
• geojson_to_wkt
• wkb_to_geojson
• geojson_to_wkb

#Geometry validation and normalization

let normalized = match @moon_geocodec.normalize_geometry(geometry) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(@moon_geocodec.validate_geometry(normalized), Ok(()))

#3D bounds and centroids

let bounds = geometry.bounds_3d()
let center = geometry.centroid()

#CLI

moon run cmd/main -- inspect wkt "POINT Z (1 2 3)"
moon run cmd/main -- validate wkt "POLYGON ((0 0, 1 0, 1 1, 0 0))"
moon run cmd/main -- convert wkt geojson "POINT (1 2)"
moon run cmd/main -- convert ewkt ewkb "SRID=4326;POINT (1 2)"

#Interoperability vectors

python -m pip install -r interop/requirements.txt
python interop/verify_shapely.py

#Fuzzing and hardening

#Examples and release

moon run examples/quickstart

#WKT lexer

let tokens = match @moon_geocodec.tokenize_wkt(
  "POINT Z (1 2 3)",
  @moon_geocodec.GeoLimits::default(),
) {
  Ok(value) => value
  Err(err) => fail(err.to_string())
}
assert_eq(tokens[0].text(), "POINT")
assert_eq(tokens[1].text(), "Z")

#Scope

• Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection
• 2D, XYZ, XYM, and XYZM coordinates
• Strict WKT 1/2 parsing and canonical formatting
• WKB and EWKB binary codecs with endian and SRID support
• GeoJSON import/export
• Bounded parsing with typed diagnostics
• CLI inspection, validation, and conversion commands
• Interoperability vectors for WKB, EWKB, and GeoJSON

#Explicit non-goals

#Install

moon add ggbond44439/moon_geocodec@0.2.0

#Build and test

moon check --target all
moon test --target all
moon build

#License