mailschema 0.2.0 → 0.3.0

data/contexts/map-0.2.jsonld

@@ -1,91 +0,0 @@
-{
-  "@context": {
-    "@version": 1.1,
-    "map": "https://mailschema.org/ns/map#",
-    "schema": "https://schema.org/",
-    "MailAction": "map:MailAction",
-    "profile": {
-      "@id": "map:profile",
-      "@type": "@id"
-    },
-    "type": {
-      "@id": "map:interactionType",
-      "@context": {
-        "id": {
-          "@id": "map:id",
-          "@type": "@id"
-        }
-      }
-    },
-    "version": "schema:version",
-    "contractDigest": "map:contractDigest",
-    "describedAt": {
-      "@id": "schema:dateCreated",
-      "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
-    },
-    "expiresAt": {
-      "@id": "schema:expires",
-      "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
-    },
-    "service": {
-      "@id": "schema:provider",
-      "@context": {
-        "id": {
-          "@id": "map:id",
-          "@type": "@id"
-        }
-      }
-    },
-    "name": "schema:name",
-    "authority": "map:authority",
-    "onBehalfOf": {
-      "@id": "map:onBehalfOf",
-      "@context": {
-        "id": {
-          "@id": "map:id",
-          "@type": "@id"
-        }
-      }
-    },
-    "resource": {
-      "@id": "map:resource",
-      "@type": "@id"
-    },
-    "execution": "map:execution",
-    "url": {
-      "@id": "schema:url",
-      "@type": "@id"
-    },
-    "resultUrlTemplate": "map:resultUrlTemplate",
-    "resultRetentionSeconds": "map:resultRetentionSeconds",
-    "humanUrl": {
-      "@id": "map:humanUrl",
-      "@type": "@id"
-    },
-    "target": {
-      "@id": "schema:object",
-      "@context": {
-        "id": {
-          "@id": "map:id",
-          "@type": "@id"
-        }
-      }
-    },
-    "recipient": "schema:recipient",
-    "details": {
-      "@id": "map:details",
-      "@type": "@json"
-    },
-    "revision": "schema:version",
-    "title": "schema:name",
-    "digest": "map:digest",
-    "operations": {
-      "@id": "schema:potentialAction",
-      "@container": "@set",
-      "@context": {
-        "id": "map:operationId"
-      }
-    },
-    "description": "schema:description"
-  }
-}

data/lib/mailschema/capability.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# The possession capability and the rules its URLs meet.
-module Mailschema
-  # The possession capability: the last segment of the execution URL path as written.
-  def self.capability(description)
-    written_path(description.dig("service", "execution", "url")).split("/", -1).last.to_s
-  end
-
-  # The path of an absolute URL exactly as written, with no dot segments removed and
-  # nothing decoded.
-  def self.written_path(url) = url.to_s[%r{\A[A-Za-z][A-Za-z0-9+.-]*://[^/?#]*([^?#]*)}, 1].to_s
-
-  # The rules a possession description's capability URLs must meet when it is issued.
-  module Capability
-    UNGUESSABLE = /\A[A-Za-z0-9_-]{22,}\z/
-    DOT_SEGMENT = /\A(?:\.|%2e){1,2}\z/i
-
-    module_function
-
-    def problems(description)
-      execution = description.dig("service", "execution")
-      capability = Mailschema.capability(description)
-      problems = []
-      problems << "The capability is too short to be unguessable." unless UNGUESSABLE.match?(capability)
-      if [execution.fetch("url"), execution.fetch("resultUrlTemplate")].any? { |url| dot_segment?(url) }
-        problems << "A capability URL must not contain dot segments."
-      end
-      unless execution.fetch("resultUrlTemplate").start_with?("#{execution.fetch("url")}/")
-        problems << "The result template must extend the execution URL and its capability."
-      end
-      if description.dig("service", "humanUrl").include?(capability)
-        problems << "The human route must not carry the capability."
-      end
-      problems
-    end
-
-    def dot_segment?(url) = Mailschema.written_path(url).split("/", -1).any? { |segment| DOT_SEGMENT.match?(segment) }
-  end
-  private_constant :Capability
-end

data/lib/mailschema/document.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-# Parsing MAP documents as I-JSON within the core limits.
-module Mailschema
-  class Error < StandardError; end
-
-  # A MAP document that is not I-JSON within the core limits.
-  class InvalidDocument < Error; end
-
-  MAX_BYTES = 64 * 1024
-  # Unicode's noncharacters: U+FDD0 to U+FDEF, and the last two code points of every plane.
-  NONCHARACTER = Regexp.new(
-    "[\u{FDD0}-\u{FDEF}#{(0..16).flat_map { |plane| [0xFFFE, 0xFFFF].map { (plane << 16) + _1 } }.pack("U*")}]"
-  )
-  private_constant :NONCHARACTER
-  MAX_DEPTH = 32
-  EXACT_NUMBER = (2**53) - 1
-
-  # Parse a MAP document as I-JSON (RFC 7493) within the core limits: valid UTF-8,
-  # at most 64 KiB, no duplicate member names, no lone surrogates, noncharacters or
-  # U+0000 in any string, every number within ±(2^53−1), and arrays and objects nested at most 32
-  # deep, the outermost counting as one. Comments and every other leniency RFC 8259 forbids are refused.
-  # A number with no fractional part parses as an Integer: I-JSON numbers are
-  # doubles, so 1 and 1.0 are one number, as they are to JavaScript.
-  def self.parse(json)
-    raise InvalidDocument, "a MAP document is JSON text" unless json.is_a?(String)
-
-    text = json.b.force_encoding(Encoding::UTF_8)
-    raise InvalidDocument, "the MAP document exceeds #{MAX_BYTES} bytes" if text.bytesize > MAX_BYTES
-    raise InvalidDocument, "the MAP document is not valid UTF-8" unless text.valid_encoding?
-
-    i_json(
-      JSON.parse(
-        text,
-        allow_duplicate_key: false, allow_comments: false, allow_nan: false,
-        allow_trailing_comma: false, max_nesting: MAX_DEPTH, decimal_class: BigDecimal
-      )
-    )
-  rescue JSON::ParserError => e
-    raise InvalidDocument, e.message
-  end
-
-  # The parsed value, checked for what I-JSON forbids and the parser allows. A lone
-  # surrogate escape parses into invalid UTF-8, and a number beyond the exact range
-  # parses as a Ruby Integer or decimal. Each decimal becomes the double nearest its
-  # exact value, as ECMAScript reads it; the parser's own float conversion misreads
-  # long exponents. Depth is counted here because the parser's nesting limit does not
-  # count empty arrays.
-  def self.i_json(value, depth = 0)
-    case value
-    when Hash, Array
-      raise InvalidDocument, "arrays and objects nest deeper than #{MAX_DEPTH}" if depth >= MAX_DEPTH
-
-      if value.is_a?(Hash)
-        value.to_h { |name, member| [i_json(name), i_json(member, depth + 1)] }
-      else
-        value.map { |item| i_json(item, depth + 1) }
-      end
-    when String
-      raise InvalidDocument, "the MAP document contains a lone surrogate" unless value.valid_encoding?
-      raise InvalidDocument, "the MAP document contains U+0000" if value.include?("\0")
-      raise InvalidDocument, "the MAP document contains a noncharacter" if NONCHARACTER.match?(value)
-
-      value
-    when Numeric then number(value)
-    else value
-    end
-  end
-
-  # A number as ECMAScript reads it: a decimal becomes the nearest double, and a
-  # number with no fractional part an Integer.
-  def self.number(value)
-    number = value.is_a?(BigDecimal) ? value.to_f : value
-    raise InvalidDocument, "a number is outside ±(2^53−1)" unless number.finite? && number.abs <= EXACT_NUMBER
-
-    number.to_i == number ? number.to_i : number
-  end
-  private_class_method :i_json, :number
-end

data/lib/mailschema/documents.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-# Building MAP results and problems, and the lifecycle rules every service applies.
-module Mailschema
-  # The HTTP status of every MAP problem code, as the core schema fixes it.
-  PROBLEM_STATUS = {
-    "invalid-request" => 400,
-    "authentication-required" => 401,
-    "refused" => 403,
-    "result-not-found" => 404,
-    "stale-target" => 409,
-    "idempotency-conflict" => 409,
-    "request-in-progress" => 409,
-    "already-decided" => 409,
-    "expired-interaction" => 410,
-    "unsupported-type" => 422,
-    "unsupported-operation" => 422
-  }.freeze
-  PROBLEM_TYPES = "https://mailschema.org/problems/"
-  NON_TERMINAL_STATES = %w[pending approval-required].freeze
-
-  # A result for a request, with every correlation member. `approval_url` is given
-  # exactly for approval-required and `reason` exactly for failed. Like every builder
-  # here, it raises ArgumentError rather than return a document the core refuses.
-  def self.result(request, state:, target:, result_url:, recorded_at:, output: {}, reason: nil, approval_url: nil,
-                  actor: nil)
-    if (state == "approval-required") == approval_url.nil?
-      raise ArgumentError, "approval_url is given exactly when the state is approval-required"
-    end
-    raise ArgumentError, "reason is given exactly when the state is failed" if (state == "failed") == reason.nil?
-
-    built({
-      "kind" => "MapResult",
-      "profile" => PROFILE,
-      "requestId" => request.fetch("requestId"),
-      "interactionId" => request.fetch("interactionId"),
-      "descriptionDigest" => request.fetch("descriptionDigest"),
-      "type" => request.fetch("type"),
-      "operation" => request.fetch("operation"),
-      "state" => state,
-      "target" => target,
-      "recordedAt" => timestamp(recorded_at),
-      "resultUrl" => result_url,
-      "actor" => actor,
-      "approvalUrl" => approval_url,
-      "reason" => reason,
-      "output" => output
-    }.compact, :result_errors)
-  end
-
-  # The next state of a pending or approval-required result. Every correlation member
-  # and the actor stay; the state, reason, output and recording time change.
-  def self.transition(result, state:, recorded_at:, reason: nil, output: {})
-    unless NON_TERMINAL_STATES.include?(result.fetch("state"))
-      raise ArgumentError, "a #{result["state"]} result is terminal"
-    end
-    raise ArgumentError, "a transition ends pending work" if NON_TERMINAL_STATES.include?(state)
-    raise ArgumentError, "reason is given exactly when the state is failed" if (state == "failed") == reason.nil?
-
-    built(result.except("approvalUrl", "reason")
-                .merge("state" => state, "reason" => reason, "output" => output, "recordedAt" => timestamp(recorded_at))
-                .compact, :result_errors)
-  end
-
-  # A problem. With `request_id` it is correlated and carries `instance`, `profile`,
-  # `requestId`, `interactionId` and `code`; without, it is plain RFC 9457. It stays
-  # within the core limits: a long detail is cut, each input error is bounded, and
-  # only as many of the first 100 errors as fit within 64 KiB are kept.
-  def self.problem(code, title:, detail:, request_id: nil, interaction_id: nil, result_url: nil, target: nil,
-                   errors: nil)
-    status = PROBLEM_STATUS.fetch(code)
-    title, detail, errors = Limits.problem_members(title, detail, errors)
-    body = { "type" => "#{PROBLEM_TYPES}#{code}", "title" => title, "status" => status, "detail" => detail }
-    raise ArgumentError, "an interaction is named only with its request" if interaction_id && !request_id
-    if request_id && code == "authentication-required"
-      raise ArgumentError, "authentication-required is never correlated"
-    end
-    if errors && !(request_id && code == "invalid-request")
-      raise ArgumentError, "errors belong to a correlated invalid-request"
-    end
-
-    body.merge!(correlation(code, request_id, interaction_id, result_url, target)) if request_id
-    built(Limits.within_document(body.merge("target" => target, "errors" => errors).compact), :problem_errors)
-  end
-
-  def self.correlation(code, request_id, interaction_id, result_url, target)
-    raise ArgumentError, "a correlated problem names its result URL" unless result_url
-    if interaction_id.nil? && code != "result-not-found"
-      raise ArgumentError, "a correlated problem names its interaction"
-    end
-    raise ArgumentError, "a stale-target problem carries the current target" if code == "stale-target" && target.nil?
-
-    { "instance" => result_url, "profile" => PROFILE, "requestId" => request_id,
-      "interactionId" => interaction_id, "code" => code }
-  end
-  private_class_method :correlation
-
-  # The HTTP status of a result: 202 while work is pending, otherwise 200.
-  def self.result_status(result) = NON_TERMINAL_STATES.include?(result.fetch("state")) ? 202 : 200
-
-  # Results stay retrievable until the later of the interaction's expiry and the
-  # retention interval measured from the latest recorded state.
-  def self.retain_until(description, recorded_at)
-    retention = description.dig("service", "execution", "resultRetentionSeconds")
-    [Time.iso8601(description.fetch("expiresAt")), recorded_at + retention].max
-  end
-
-  # An undecided approval ends as failed, with reason expired, at the interaction's
-  # expiry, whether or not anyone looks. The settled result, or nil when nothing changes.
-  def self.settle(result, description, now)
-    return unless result.fetch("state") == "approval-required" && reached?(now, description.fetch("expiresAt"))
-
-    transition(result, state: "failed", reason: "expired", recorded_at: Time.iso8601(description.fetch("expiresAt")))
-  end
-
-  def self.timestamp(time) = time.to_time.utc.iso8601(3)
-  private_class_method :timestamp
-
-  # The document, once the core definition `check` names accepts it.
-  def self.built(document, check)
-    refused = public_send(check, document)
-    raise ArgumentError, "the core refuses this document: #{refused.first(3).join("; ")}" if refused.any?
-
-    document
-  end
-  private_class_method :built
-end

data/lib/mailschema/forms.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Mailschema
-  # The form fields block of forms 0.1: the rules JSON Schema cannot state, and the
-  # schema the values of a block satisfy.
-  module Forms
-    # The core definitions that give a text field's `format` its lexical form.
-    FORMATS = { "email" => "address", "uri" => "identifier", "date" => "date", "date-time" => "dateTime" }.freeze
-
-    module_function
-
-    # Every required field exists, choices are distinct, and defaults are among the
-    # choices.
-    def problems(fields)
-      properties = fields.fetch("properties", {})
-      undefined = fields.fetch("required", []).reject { |name| properties.key?(name) }
-      problems = undefined.map { |name| "required field #{name} is not defined" }
-      properties.each do |name, field|
-        choices = (field["oneOf"] || field.dig("items", "anyOf") || []).map { |choice| choice["const"] }
-        problems << "field #{name} repeats a choice" unless choices.uniq.size == choices.size
-        defaults = field.key?("default") ? Array(field["default"]) : []
-        if choices.any? && defaults.any? { |value| !choices.include?(value) }
-          problems << "field #{name} defaults to a value it does not offer"
-        end
-      end
-      problems
-    end
-
-    # The schema the values of a fields block satisfy: only its fields, each with a
-    # text field's `format` read as the core lexical form of that name.
-    def values_schema(fields)
-      properties = fields.fetch("properties", {}).transform_values do |field|
-        next field unless field.key?("format")
-
-        field.except("format").merge("$ref" => "#{CORE_SCHEMA}#/$defs/#{FORMATS.fetch(field["format"])}")
-      end
-      fields.merge("properties" => properties, "additionalProperties" => false)
-    end
-  end
-  private_constant :Forms
-end

data/lib/mailschema/http.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-# The HTTP binding: which requests the execution URL admits, and where results live.
-module Mailschema
-  # Whether a Content-Type admits a request rather than a 415: the media type
-  # application/json, compared case-insensitively, with no parameter other than a
-  # UTF-8 charset. Only HTTP's optional whitespace, spaces and tabs, may surround
-  # each part, and empty parameter slots are ignored, as RFC 9110 permits. Bytes that
-  # are not text admit nothing.
-  def self.json_request?(content_type)
-    text = content_type.to_s
-    return false unless text.valid_encoding?
-
-    type, *parameters = text.split(";", -1).map { |part| part.gsub(/\A[ \t]+|[ \t]+\z/, "").downcase }
-    type == "application/json" &&
-      parameters.all? { |parameter| parameter.empty? || parameter.match?(/\Acharset=(?:utf-8|"utf-8")\z/) }
-  end
-
-  # The result resource of a request: the description's template, with the request
-  # identifier encoded as ECMAScript's encodeURIComponent encodes it.
-  def self.result_url(description, request_id)
-    encoded = request_id.to_s.b.gsub(/[^A-Za-z0-9\-_.!~*'()]/n) { |byte| format("%%%02X", byte.ord) }
-    description.dig("service", "execution", "resultUrlTemplate").sub("{requestId}") { encoded }
-  end
-end

data/lib/mailschema/limits.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Mailschema
-  # MAP documents within the core limits, with lengths counted in code points as JSON
-  # Schema counts them.
-  module Limits
-    TITLE = 240
-    DETAIL = 4000
-    POINTER = 1000
-    ERROR_DETAIL = 2000
-    ERRORS = 100
-
-    module_function
-
-    # The text, or its first limit - 1 code points and an ellipsis.
-    def cut(text, limit) = text.length > limit ? "#{text[0, limit - 1]}…" : text
-
-    # An input error within the core problem's limits. A pointer too long to report
-    # names its nearest ancestor that fits, with a detail that says so, and a detail
-    # too long is cut.
-    def input_error(detail, pointer)
-      if pointer.length > POINTER
-        pointer = Pointer.within(pointer, POINTER)
-        detail = "A member within this value does not satisfy the contract."
-      end
-      { "detail" => cut(detail, ERROR_DETAIL), "pointer" => pointer }
-    end
-
-    # A problem's title, detail and input errors within the core limits. An empty or
-    # overlong title, an empty detail or an empty error list is the caller's mistake.
-    def problem_members(title, detail, errors)
-      raise ArgumentError, "a problem title is 1 to #{TITLE} characters" unless title.length.between?(1, TITLE)
-      raise ArgumentError, "a problem detail is not empty" if detail.empty?
-
-      [title, cut(detail, DETAIL), errors && bounded_errors(errors)]
-    end
-
-    def bounded_errors(errors)
-      raise ArgumentError, "errors, when given, name at least one input error" if errors.empty?
-      raise ArgumentError, "an input error has a detail" if errors.any? { |error| error.fetch("detail").empty? }
-
-      errors.first(ERRORS).map { |error| input_error(error.fetch("detail"), error.fetch("pointer")) }
-    end
-
-    # The problem with as many of its errors, in order, as fit within the document limit.
-    def within_document(problem)
-      errors = problem["errors"]
-      return problem unless errors
-
-      errors = errors.dup
-      errors.pop while errors.size > 1 && JSON.generate(problem.merge("errors" => errors)).bytesize > MAX_BYTES
-      problem.merge("errors" => errors)
-    end
-  end
-  private_constant :Limits
-end

data/lib/mailschema/pointer.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Mailschema
-  # JSON Pointer (RFC 6901).
-  module Pointer
-    # What a pointer names when nothing is there, as distinct from null.
-    MISSING = Object.new.freeze
-    INDEX = /\A(?:0|[1-9][0-9]*)\z/
-
-    module_function
-
-    def escape(name) = name.to_s.gsub("~", "~0").gsub("/", "~1")
-
-    def segments(pointer) = pointer.split("/", -1).drop(1).map { |segment| segment.gsub("~1", "/").gsub("~0", "~") }
-
-    # The pointer, or its nearest ancestor no longer than limit characters.
-    def within(pointer, limit)
-      tokens = pointer.split("/", -1)
-      tokens.pop while tokens.join("/").length > limit
-      tokens.join("/")
-    end
-
-    # The value a pointer names through objects and arrays, or MISSING.
-    def resolve(value, pointer)
-      segments(pointer).reduce(value) do |current, name|
-        case current
-        when Hash then current.fetch(name) { return MISSING }
-        when Array then INDEX.match?(name) && name.to_i < current.size ? current[name.to_i] : (return MISSING)
-        else return MISSING
-        end
-      end
-    end
-
-    # The value a pointer names through object members only, or MISSING. The contract
-    # rules bind form fields only through object properties, so no binding indexes an
-    # array.
-    def member(value, pointer)
-      segments(pointer).reduce(value) do |current, name|
-        return MISSING unless current.is_a?(Hash) && current.key?(name)
-
-        current[name]
-      end
-    end
-  end
-  private_constant :Pointer
-end

data/lib/mailschema/references.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Mailschema
-  # The references of a contract's schemas. Each must name a schema inside a pinned
-  # dependency when the contract loads, so none can fail when a request arrives.
-  module References
-    # A plain JSON Pointer fragment: nothing percent-encoded, nothing to decode.
-    FRAGMENT = %r{\A(?:/[A-Za-z0-9._~!$&'()*+,;=:@-]*)*\z}
-    SCHEMA = [Hash, TrueClass, FalseClass].freeze
-    # Keywords that resolve by scope rather than by a pinned address.
-    UNPINNED = %w[$dynamicRef $recursiveRef $dynamicAnchor $recursiveAnchor $anchor].freeze
-
-    module_function
-
-    # Raises InvalidContract for the first keyword in the contract's schemas, or the
-    # pinned schemas the gem does not bundle, that resolves by scope. In the contract's
-    # own schemas, it raises for an $id or $schema anywhere but the request schema's
-    # root, which would move references or change the dialect a subschema is read in;
-    # for a type list; for autocomplete, the form fields block's annotation; and for a
-    # reference that is not a string or names no schema in the pinned documents, by URL.
-    def verify(inline, request_schema, pinned, unbundled)
-      [*inline, request_schema, *unbundled].each do |schema|
-        found = UNPINNED.find { |keyword| SchemaWalk.values(schema, keyword).any? }
-        raise InvalidContract, "#{found} is not pinned by any digest" if found
-      end
-      [*inline, request_schema].each do |schema|
-        nodes = SchemaWalk.nodes(schema)
-        verify_keywords(schema.equal?(request_schema) ? nodes.drop(1) : nodes, nodes)
-        refs = SchemaWalk.values(schema, "$ref")
-        raise InvalidContract, "a $ref is not a string" unless refs.all?(String)
-
-        refs.each { |ref| verify_one(ref, pinned) }
-      end
-    end
-
-    # `nested` are the schema objects that may not declare $id or $schema.
-    def verify_keywords(nested, nodes)
-      raise InvalidContract, "a nested $id would move references" if nested.any? { _1.key?("$id") }
-      raise InvalidContract, "a nested $schema would change the dialect" if nested.any? { _1.key?("$schema") }
-      raise InvalidContract, "type names one type, never a list" if nodes.any? { _1["type"].is_a?(Array) }
-      return unless nodes.any? { _1.key?("autocomplete") }
-
-      raise InvalidContract, "autocomplete belongs to the form fields block"
-    end
-
-    def verify_one(ref, pinned)
-      base, fragment = ref.split("#", 2)
-      raise InvalidContract, "#{ref} is not a pinned dependency" unless pinned.key?(base)
-
-      fragment = fragment.to_s
-      unless fragment.empty? || fragment.start_with?("/")
-        raise InvalidContract, "#{ref} names an anchor, not a JSON Pointer"
-      end
-      raise InvalidContract, "#{ref} is not a plain JSON Pointer" unless FRAGMENT.match?(fragment)
-
-      target = Pointer.resolve(pinned[base], fragment)
-      raise InvalidContract, "#{ref} does not name a schema" unless SCHEMA.include?(target.class)
-    end
-    private_class_method :verify_one
-  end
-  private_constant :References
-end

data/lib/mailschema/schema_walk.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Mailschema
-  # The schema objects within a schema, as JSON Schema 2020-12 nests them.
-  module SchemaWalk
-    # The keywords whose value is a schema, a list of schemas, or a map from names to
-    # schemas. A name in a map is never a keyword, whatever it is called.
-    SUBSCHEMA = %w[additionalProperties propertyNames items contains not if then else unevaluatedItems
-                   unevaluatedProperties contentSchema].freeze
-    LISTS = %w[allOf anyOf oneOf prefixItems].freeze
-    MAPS = %w[properties patternProperties $defs dependentSchemas].freeze
-
-    module_function
-
-    # Every schema object within a schema, the schema itself first.
-    def nodes(schema)
-      return [] unless schema.is_a?(Hash)
-
-      [schema] +
-        SUBSCHEMA.flat_map { |keyword| nodes(schema[keyword]) } +
-        LISTS.flat_map { |keyword| schema[keyword].is_a?(Array) ? schema[keyword].flat_map { nodes(_1) } : [] } +
-        MAPS.flat_map { |keyword| schema[keyword].is_a?(Hash) ? schema[keyword].values.flat_map { nodes(_1) } : [] }
-    end
-
-    # Every value a keyword has in the schema objects within a schema.
-    def values(schema, keyword) = nodes(schema).filter_map { |node| node[keyword] if node.key?(keyword) }
-  end
-  private_constant :SchemaWalk
-end