lens_core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: afb85b28397a4ddf5ce37a849ed0c86ca3a8cb5a0d31bf1d827f57d398135ac6
+  data.tar.gz: 4d617c41ea6d3bae184a0a18f9beb589a9cfdc78f0d80e89fbd6ecc480f7250d
+SHA512:
+  metadata.gz: 60c91a54b74fb9c0c3fae2c14c98b753a950377834752576b452f824db7cc0746c6cf0a9778be3eab3a1a698c677ff644d90b66c61d53c4dd73fa7028210c032
+  data.tar.gz: 6f3b1d77bc94d6995cb5e47528b1e5b6931b5fc91026e485e1b33b02f78c54e3a3d68e77a9c58a3d64210d77342b4c4f0a5bca48dd188148a1a701f7219a187d

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "json_schemer"
+gem "rake"
+gem "rspec"
+gem "rubocop"
+gem "rubocop-performance"
+gem "rubocop-rake"
+gem "rubocop-rspec"

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Ribose
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.adoc

@@ -0,0 +1,62 @@
+= LensCore
+
+LensCore is a small, dependency-free model for conformance diagnostics: one
+report shape that any format checker can emit, with machine-readable (JSON,
+YAML) and human-readable output rendered from the same model.
+
+Each diagnostic records:
+
+* what is wrong (`kind`);
+* how serious it is (`severity`);
+* where it is: line and column for text formats, byte offset and record for
+  binary ones;
+* which rule of which specification or profile it breaks.
+
+== Usage
+
+[source,ruby]
+----
+require "lens_core"
+
+report = LensCore::Report.new(
+  producer: LensCore::Producer.new(name: "my-checker", version: "1.0.0"),
+  profile: LensCore::Profile.new(id: "my-profile"),
+  valid: false,
+  diagnostics: [
+    LensCore::Diagnostic.new(
+      severity: "error", kind: "bad_checksum", requirement_id: "REC-001",
+      message: "Record checksum does not match.",
+      location: LensCore::Location.binary(byte_offset: 0, record_index: 0)
+    )
+  ]
+)
+
+puts LensCore::Renderers::Json.render(report)
+puts LensCore::Renderers::Human.render(report)
+
+report = LensCore::Parsers::Json.parse(File.binread("report.json"))
+----
+
+Parsers and renderers are `LensCore::Parsers::Json`, `Parsers::Yaml` and
+`LensCore::Renderers::Json`, `Renderers::Yaml`, `Renderers::Human`. Failures
+are subclasses of `LensCore::Error`.
+
+== Schema
+
+The format is documented in link:docs/diagnostics-v1.adoc[docs/diagnostics-v1.adoc]
+and specified by `schemas/lens-diagnostics-v1.json` (also at
+`LensCore::Schema::PATH`). The gem version is `LensCore::VERSION`; the schema
+version is `LensCore::SCHEMA_VERSION` (`1`).
+
+== Status
+
+The v1 contract is a ready-to-tag candidate: the schema, model, renderers and
+the golden corpus (`spec/fixtures/v1/golden`) are pinned by SHA-256 in
+`spec/fixtures/v1/golden/manifest.yml`. Nothing is tagged or published yet.
+Adopt it by pinning an exact commit, never a branch; a host application that
+needs only LensCore is shown in `spec/fixtures/host_app`.
+
+== License
+
+The gem is available as open source under the terms of the BSD 2-Clause
+License.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/docs/diagnostics-v1.adoc

@@ -0,0 +1,237 @@
+= LensCore diagnostics, schema version 1
+:toc:
+
+This document is the prose half of the diagnostics wire format. The machine
+half is `schemas/lens-diagnostics-v1.json` (JSON Schema 2020-12). The Ruby
+model in `lib/lens_core/` implements both. Where they differ, the difference
+is listed under <<beyond-schema>>.
+
+The gem version (`LensCore::VERSION`) and the schema version
+(`LensCore::SCHEMA_VERSION`, also `LensCore::Schema.version`) are separate
+constants. A host that embeds LensCore should report both.
+
+== Document shape
+
+A report is one JSON (or YAML) object. Members appear in the order shown.
+
+[cols="2,1,4",options="header"]
+|===
+| Member | Required | Meaning
+
+| `schema_version` | yes | The integer `1`. Written without a fraction.
+| `producer` | yes | The tool that made the report: `name`, `version`
+(non-empty strings).
+| `profile` | yes | The rule set checked against: `id` (non-empty string) and
+`citations` (array, may be empty).
+| `timestamp` | no | When the check ran, if the caller says so. RFC 3339 with an
+explicit offset. See <<timestamps>>.
+| `valid` | yes | Boolean verdict, stated by the producer.
+| `summary` | yes | `errors`, `warnings`, `infos`: integers derived from
+`diagnostics`.
+| `diagnostics` | yes | Array of diagnostics, in the producer's order (may be
+empty).
+|===
+
+=== Diagnostic
+
+[cols="2,1,4",options="header"]
+|===
+| Member | Required | Meaning
+
+| `severity` | yes | `error`, `warning` or `info`.
+| `kind` | yes | Non-empty string naming the sort of finding. Open
+vocabulary: see <<compatibility>>.
+| `requirement_id` | yes | Non-empty string identifying the requirement, stable
+across releases of the producer.
+| `message` | yes | Non-empty human-readable text. May contain newlines.
+| `citations` | no | Array of citations; `[]` when absent.
+| `remediation` | no | Non-empty text saying how to fix it.
+| `context` | no | JSON object of supporting values; `{}` when absent.
+| `location` | no | A location. Absent when the finding has no place.
+|===
+
+=== Citation
+
+`uri` (required): an absolute URI, that is a scheme followed by `:` and
+non-whitespace text (`https://...`, `urn:...`). `label` (optional): a
+non-empty human name for the cited text.
+
+=== Location
+
+`type` is required and is `xml` or `binary`. The other members are
+coordinates, all optional; a coordinate that is unknown is left out.
+
+[cols="1,2,4",options="header"]
+|===
+| Type | Member | Meaning
+
+| `xml` | `line` | Integer >= 1.
+| `xml` | `column` | Integer >= 1.
+| `xml` | `path` | Non-empty string, e.g. an element path.
+| `binary` | `byte_offset` | Integer >= 0.
+| `binary` | `byte_length` | Integer >= 0.
+| `binary` | `record_index` | Integer >= 0, counting from zero.
+| `binary` | `record_type` | Non-empty string.
+|===
+
+A coordinate that belongs to the other type (`line` on a `binary` location) is
+a schema violation. The two types are format-neutral examples; neither implies
+that any particular lens uses this gem.
+
+[[compatibility]]
+== Compatibility
+
+* A document whose `schema_version` is any integer other than the one this gem
+  implements is rejected with `LensCore::UnsupportedVersionError`. A
+  `schema_version` that is not an integer is a `LensCore::SchemaError`.
+* Within version 1, producers may add to a report. Consumers must accept:
+  - new `kind` values;
+  - additional (unknown) members on any object: the report, `producer`,
+    `profile`, a diagnostic, a citation, a location.
+* The Ruby model keeps unknown members as _extensions_ and writes them back
+  after the standard members (see <<ordering>>). The one exception is
+  `summary`: its counts are derived, so any other member inside it is ignored
+  and not written back.
+* Removing a member, changing a member's meaning or type, or adding a new
+  `severity` or location `type` is a new schema version.
+* Integers must be written as integers (`3`, not `3.0` or `3e0`). JSON Schema
+  validators treat `3.0` as an integer; LensCore does not.
+
+[[omission]]
+== Omission and null
+
+* An optional member that has no value is omitted. `null` is never a valid
+  value for a standard member; a document that contains one is a
+  `SchemaError`. (Extension members and values inside `context` may be `null`
+  like any JSON value.)
+* `citations` (on a diagnostic) and `context` read as `[]` and `{}` when
+  absent. The renderers always write them, so canonical output has them.
+* `timestamp`, `remediation` and `location` are written only when present.
+* Location coordinates are never defaulted. A zero is written only when the
+  coordinate is really zero.
+
+[[ordering]]
+== Ordering and canonical form
+
+* `diagnostics` keep the order given by the producer. Nothing sorts them.
+* Standard members appear in the order of the tables above: report members as
+  `schema_version`, `producer`, `profile`, `timestamp`, `valid`, `summary`,
+  `diagnostics`; diagnostic members as `severity`, `kind`, `requirement_id`,
+  `message`, `citations`, `remediation`, `context`, `location`.
+* Extension members follow the standard members, sorted lexically by bytes.
+* Keys inside `context` and inside extension values are sorted lexically, at
+  every depth.
+* `summary` is computed from the diagnostics: one count per severity.
+* Canonical JSON is `JSON.pretty_generate` output (two-space indent) plus one
+  final newline. Parsing canonical JSON and rendering it again returns the same
+  bytes. Non-canonical JSON (other key order, other spacing) parses to the same
+  model and renders in canonical form.
+* YAML carries the same content with the same key order, rendered with
+  `YAML.dump` and unbounded line width.
+
+[[timestamps]]
+== Timestamps
+
+LensCore never reads the clock. A `timestamp` appears only when the caller
+supplies one, as a `Time` or an RFC 3339 string with an explicit offset
+(`Z` or `+hh:mm`). It is rendered in UTC with a `Z` suffix, with sub-second
+digits only when there are some (`2026-10-23T10:00:00Z`,
+`2026-10-23T10:00:00.25Z`). A string without an offset is rejected rather
+than guessed at.
+
+In YAML, quote the timestamp (the renderer does). An unquoted RFC 3339
+timestamp is also accepted, in the `timestamp` member only.
+
+== Validity
+
+`valid` is the producer's verdict, because policy (do warnings fail a
+document?) belongs to the producer. One rule is fixed: `valid` cannot be
+`true` when the report contains an `error`.
+
+== Text and encoding
+
+* Documents are UTF-8. The parsers accept a String tagged UTF-8, US-ASCII or
+  binary and read its bytes as UTF-8; a String in any other encoding is
+  rejected, not transcoded.
+* A byte order mark is rejected.
+* Every string in a report, including object keys, must be valid UTF-8.
+
+== Renderers
+
+JSON::
+  `LensCore::Renderers::Json.render(report)`: canonical JSON.
+YAML::
+  `LensCore::Renderers::Yaml.render(report)`: canonical YAML.
+Human::
+  `LensCore::Renderers::Human.render(report)`: plain text with no colour or
+  wrapping. A header line (producer, profile, the timestamp if present), a
+  `VALID`/`INVALID` line with the three counts, then one block per diagnostic
+  in order, showing severity, requirement ID, kind, location (present
+  coordinates only), message, remediation, citations and context. It is meant
+  for reading, not parsing.
+
+All three show every diagnostic of every severity.
+
+== Parsers and failures
+
+`LensCore::Parsers::Json.parse(text)` and `LensCore::Parsers::Yaml.parse(text)`
+return a `LensCore::Report` or raise a subclass of `LensCore::Error`:
+
+[cols="2,4",options="header"]
+|===
+| Error class | Raised when
+
+| `LensCore::ParseError` | The text is not well-formed JSON or YAML, is not a
+String, or starts with a byte order mark.
+| `LensCore::UnsafeYamlError` | The YAML uses an object tag, a symbol, or an
+alias. Anchor declarations that nothing aliases are harmless and accepted.
+| `LensCore::InvalidEncodingError` | The input, or a string inside it, is not
+valid UTF-8, or the input is a String in another encoding.
+| `LensCore::UnsupportedVersionError` | `schema_version` is an integer other
+than 1.
+| `LensCore::SchemaError` | The document is well-formed but breaks the schema.
+`error.path` is the list of keys and indexes to the offending member;
+`error.message` renders it, e.g. `diagnostics[1].location.line: must be >= 1`.
+|===
+
+The same `SchemaError` and `InvalidEncodingError` are raised when a value
+object is built directly in Ruby with bad arguments.
+
+[[beyond-schema]]
+== Rules beyond JSON Schema
+
+JSON Schema validation alone accepts documents that LensCore rejects:
+
+* `summary` counts must equal the number of diagnostics of each severity.
+  JSON Schema cannot count array items by property.
+* Integer-valued numbers written with a fraction (`3.0`).
+* Unsafe YAML constructs and invalid UTF-8, which are rejected before a
+  schema applies.
+
+The schema does enforce that `valid: true` goes with `summary.errors` equal to
+zero.
+
+== Golden corpus
+
+`spec/fixtures/v1/golden` holds canonical v1 reports that every release must
+parse and render byte for byte, and that validate against the schema.
+`manifest.yml` records, for each file, its SHA-256, producer and version,
+schema version, source fixture and the LensCore contract commit used to render
+it; SVG exports also record the exact svg_conform commit. The schema's own
+SHA-256 is recorded too. Goldens omit timestamps.
+
+* `svg_conform/` holds three real exports: an SVG 1.1 CSS grammar error, an
+  SVG 2 secure-static external reference, and a four-channel report (error,
+  validity error, warning, info).
+* `examples/` holds format-neutral examples of the two location forms. The
+  binary example is a contract example only; it is not evidence of any PNG,
+  EMF or PostScript implementation.
+
+`ruby -Ilib script/refresh_svg_goldens PATH_TO_SVG_CONFORM` regenerates the
+three SVG files and their hashes. It refuses a checkout whose HEAD is not the
+commit named in the manifest, canonicalizes through LensCore, and writes only
+inside this repository.
+
+`spec/fixtures/host_app` is a minimal application whose bundle contains only
+LensCore. `bundle exec ruby read_reports.rb DIRECTORY` reads every report in a
+directory and prints profile, counts and locations.

data/lens_core.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/lens_core/version"
+
+all_files_in_git = Dir.chdir(File.expand_path(__dir__)) do
+  `git ls-files -z`.split("\x0")
+end
+
+Gem::Specification.new do |spec|
+  spec.name = "lens_core"
+  spec.version = LensCore::VERSION
+  spec.authors = ["Ribose"]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Format-neutral conformance diagnostics model and renderers."
+  spec.description = "One diagnostics report shape (schema version 1) " \
+                     "that any format checker can emit, with JSON and " \
+                     "YAML parsers and JSON, YAML and human-readable " \
+                     "renderers. No runtime dependencies."
+  spec.homepage = "https://github.com/claricle/lens_core"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.1.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = all_files_in_git
+    .reject { |f| f.match(%r{\A(?:(?:test|spec|features|bin|script)/|\.)}) }
+  spec.require_paths = ["lib"]
+end

data/lib/lens_core/citation.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LensCore
+  # A pointer to the text a requirement comes from.
+  class Citation < Node
+    MEMBERS = %w[uri label].freeze
+
+    attr_reader :uri, :label
+
+    def self.from_h(hash)
+      known, extra = split(hash)
+      new(uri: known["uri"], label: known["label"], extensions: extra)
+    end
+
+    # Wire array -> frozen array of Citation; errors carry the array index.
+    def self.list_from_h(list, name = "citations")
+      Validation.array(list, name).each_with_index.map do |item, i|
+        from_h(item)
+      rescue SchemaError => e
+        raise e.within(i).within(name)
+      end.freeze
+    end
+
+    # Ruby array -> frozen array, every item a Citation.
+    def self.check_list(list, name = "citations")
+      Validation.array(list, name).each_with_index.map do |item, i|
+        unless item.is_a?(self)
+          Validation.fail_at("must be a LensCore::Citation",
+                             [name, i])
+        end
+        item
+      end.freeze
+    end
+
+    # @param uri [String] absolute URI (required)
+    # @param label [String, nil] human-readable name
+    def initialize(uri:, label: nil, extensions: {})
+      @uri = Validation.absolute_uri(uri, "uri")
+      @label = label.nil? ? nil : Validation.string(label, "label")
+      super(extensions: extensions)
+      freeze
+    end
+
+    private
+
+    def standard_members
+      { "uri" => uri, "label" => label }
+    end
+  end
+end

data/lib/lens_core/diagnostic.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module LensCore
+  # One finding. `kind` is an open vocabulary: producers may introduce new
+  # values, consumers must tolerate ones they do not know.
+  class Diagnostic < Node
+    SEVERITIES = %w[error warning info].freeze
+    MEMBERS = %w[severity kind requirement_id message citations remediation
+                 context location].freeze
+
+    attr_reader(*MEMBERS.map(&:to_sym))
+
+    def self.from_h(hash)
+      known, extra = split(hash)
+      new(
+        severity: known["severity"], kind: known["kind"],
+        requirement_id: known["requirement_id"], message: known["message"],
+        remediation: known["remediation"], context: known.fetch("context", {}),
+        citations: Citation.list_from_h(known.fetch("citations", [])),
+        location: location_from(known["location"]), extensions: extra
+      )
+    end
+
+    def self.location_from(value)
+      return nil if value.nil?
+
+      Location.from_h(value)
+    rescue SchemaError => e
+      raise e.within("location")
+    end
+    private_class_method :location_from
+
+    def initialize(severity:, kind:, requirement_id:, message:, citations: [],
+                   remediation: nil, context: {}, location: nil,
+                   extensions: {})
+      @severity = Validation.one_of(severity, SEVERITIES, "severity")
+      @kind = Validation.string(kind, "kind")
+      @requirement_id = Validation.string(requirement_id, "requirement_id")
+      @message = Validation.string(message, "message")
+      @citations = Citation.check_list(citations)
+      @remediation = Validation.optional_string(remediation, "remediation")
+      @context = Validation.context(context)
+      @location = check_location(location)
+      super(extensions: extensions)
+      freeze
+    end
+
+    SEVERITIES.each do |name|
+      define_method(:"#{name}?") { severity == name }
+    end
+
+    private
+
+    def check_location(location)
+      return location if location.nil? || location.is_a?(Location)
+
+      Validation.fail_at("must be a LensCore::Location", "location")
+    end
+
+    def standard_members
+      MEMBERS.to_h { |name| [name, public_send(name)] }.merge(
+        "citations" => citations.map(&:to_h), "location" => location&.to_h,
+      )
+    end
+  end
+end

data/lib/lens_core/errors.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module LensCore
+  # Base class of every error LensCore raises for bad input.
+  class Error < StandardError; end
+
+  # The text is not well-formed JSON or YAML (or is not a document at all).
+  class ParseError < Error; end
+
+  # The YAML uses a feature that is not safe to load: an object tag, a symbol,
+  # or an alias.
+  class UnsafeYamlError < Error; end
+
+  # The text, or a string inside it, is not valid UTF-8.
+  class InvalidEncodingError < Error; end
+
+  # The document declares a schema version other than LensCore::SCHEMA_VERSION.
+  class UnsupportedVersionError < Error; end
+
+  # The document is well-formed but breaks the schema. `path` names the
+  # offending member, e.g. "diagnostics[2].location.line".
+  class SchemaError < Error
+    attr_reader :detail, :path
+
+    def initialize(detail, path = [])
+      @detail = detail
+      @path = path.freeze
+      super(path.empty? ? detail : "#{format_path}: #{detail}")
+    end
+
+    # The same error, located one level further out.
+    def within(segment)
+      self.class.new(detail, [segment, *path])
+    end
+
+    private
+
+    def format_path
+      path.each_with_index.map do |seg, i|
+        if seg.is_a?(Integer)
+          "[#{seg}]"
+        else
+          (i.zero? ? seg.to_s : ".#{seg}")
+        end
+      end.join
+    end
+  end
+end

data/lib/lens_core/location.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module LensCore
+  # Where a diagnostic applies. `type` says which coordinates are meaningful;
+  # a coordinate that is not known is nil and is omitted from output, never
+  # replaced by a placeholder.
+  #
+  #   xml     line, column (1-based), path
+  #   binary  byte_offset, byte_length, record_index (0-based), record_type
+  class Location < Node
+    TYPES = %w[xml binary].freeze
+    FIELDS = {
+      "xml" => %w[line column path],
+      "binary" => %w[byte_offset byte_length record_index record_type],
+    }.freeze
+    MEMBERS = (["type"] + FIELDS.values.flatten).freeze
+    MINIMUMS = {
+      "line" => 1, "column" => 1,
+      "byte_offset" => 0, "byte_length" => 0, "record_index" => 0
+    }.freeze
+
+    attr_reader :type, :coordinates
+
+    def self.from_h(hash)
+      known, extra = split(hash)
+      type = Validation.one_of(known["type"], TYPES, "type")
+      new(type: type, **known.except("type").transform_keys(&:to_sym),
+          extensions: extra)
+    end
+
+    def self.xml(line: nil, column: nil, path: nil, extensions: {})
+      new(type: "xml", line: line, column: column, path: path,
+          extensions: extensions)
+    end
+
+    def self.binary(byte_offset: nil, byte_length: nil, record_index: nil,
+                    record_type: nil, extensions: {})
+      new(type: "binary", byte_offset: byte_offset, byte_length: byte_length,
+          record_index: record_index, record_type: record_type,
+          extensions: extensions)
+    end
+
+    def initialize(type:, extensions: {}, **fields)
+      @type = Validation.one_of(type, TYPES, "type")
+      @coordinates = coordinates_from(fields)
+      super(extensions: extensions)
+      freeze
+    end
+
+    FIELDS.values.flatten.each do |name|
+      define_method(name) { coordinates[name] }
+    end
+
+    private
+
+    def coordinates_from(fields)
+      applicable = FIELDS.fetch(type)
+      reject_stray(fields, applicable)
+      applicable.to_h { |name| [name, check(name, fields[name.to_sym])] }
+        .compact.freeze
+    end
+
+    def reject_stray(fields, applicable)
+      stray = fields.keys.map(&:to_s) - applicable
+      return if stray.empty?
+
+      Validation.fail_at("is not a #{type} coordinate", stray.first)
+    end
+
+    def check(name, value)
+      return nil if value.nil?
+      return Validation.string(value, name) unless MINIMUMS.key?(name)
+
+      Validation.integer(value, name, min: MINIMUMS.fetch(name))
+    end
+
+    def standard_members
+      { "type" => type }.merge(coordinates)
+    end
+  end
+end