rigortype 0.2.7 → 0.2.9

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/schema_scanner.rb

@@ -6,16 +6,13 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class DrySchema < Rigor::Plugin::Base
-      # Walks project source for `Foo = Dry::Schema.{Params,JSON,define}
-      # { ... }` shapes and emits a
-      # `{schema_const_fqn => {required: {key => underlying_class}, optional: {…}}}`
-      # table covering each schema's typed-key surface.
+      # Walks project source for `Foo = Dry::Schema.{Params,JSON,define} { ... }` shapes and emits a
+      # `{schema_const_fqn => {required: {key => underlying_class}, optional: {…}}}` table covering each
+      # schema's typed-key surface.
       module SchemaScanner
-        # The dry-schema canonical-type symbols accepted as
-        # predicate arguments. Maps each to the underlying Ruby
-        # class name (the same vocabulary `rigor-dry-types`
-        # uses for `CANONICAL_ALIASES`, intersected with what
-        # dry-schema's predicate engine accepts).
+        # The dry-schema canonical-type symbols accepted as predicate arguments. Maps each to the
+        # underlying Ruby class name (the same vocabulary `rigor-dry-types` uses for `CANONICAL_ALIASES`,
+        # intersected with what dry-schema's predicate engine accepts).
         CANONICAL_TYPES = {
           string: "String",
           integer: "Integer",
@@ -30,12 +27,10 @@ module Rigor
           array: "Array"
         }.tap { |h| h[:nil] = "NilClass" }.freeze
 
-        # The dry-schema predicate verbs that accept a type
-        # argument. Each verb has a slightly different runtime
-        # semantic (`filled` = present + non-empty; `value` =
-        # present; `maybe` = present-or-nil; `each` = collection
-        # element type) but for Rigor's purposes they all
-        # contribute the same underlying class for the key.
+        # The dry-schema predicate verbs that accept a type argument. Each verb has a slightly different
+        # runtime semantic (`filled` = present + non-empty; `value` = present; `maybe` = present-or-nil;
+        # `each` = collection element type) but for Rigor's purposes they all contribute the same
+        # underlying class for the key.
         TYPE_BEARING_PREDICATES = %i[filled value maybe each].to_set.freeze
         private_constant :TYPE_BEARING_PREDICATES
 
@@ -45,17 +40,12 @@ module Rigor
 
         module_function
 
-        # @param paths [Array<String>] absolute paths to `.rb`
-        #   files the project's `paths:` resolves to.
-        # @param type_aliases [Hash{String => String}] the
-        #   ADR-9 `:dry_type_aliases` fact published by
-        #   `rigor-dry-types` when loaded. Used to resolve
-        #   `value(Types::Email)` references to their
-        #   underlying class. Empty when the plugin isn't
-        #   loaded.
-        # @return [Hash{String => Hash{Symbol => Hash{Symbol => String}}}]
-        #   frozen per-schema typed-key table. Empty when no
-        #   recognisable schema declaration is found.
+        # @param paths [Array<String>] absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @param type_aliases [Hash{String => String}] the ADR-9 `:dry_type_aliases` fact published by
+        #   `rigor-dry-types` when loaded. Used to resolve `value(Types::Email)` references to their
+        #   underlying class. Empty when the plugin isn't loaded.
+        # @return [Hash{String => Hash{Symbol => Hash{Symbol => String}}}] frozen per-schema typed-key
+        #   table. Empty when no recognisable schema declaration is found.
         def scan(paths:, type_aliases: {})
           table = {}
           paths.each do |path|
@@ -77,11 +67,9 @@ module Rigor
         end
         private_class_method :scan_file
 
-        # Walks the AST collecting `<Const> = Dry::Schema.X { ... }`
-        # assignments at any nesting level. Tracks the enclosing
-        # constant chain so a class-level `class Foo; SCHEMA =
-        # Dry::Schema.Params { ... }; end` registers as
-        # `"Foo::SCHEMA"`.
+        # Walks the AST collecting `<Const> = Dry::Schema.X { ... }` assignments at any nesting level.
+        # Tracks the enclosing constant chain so a class-level `class Foo; SCHEMA = Dry::Schema.Params
+        # { ... }; end` registers as `"Foo::SCHEMA"`.
         def collect_schemas(node, qualified_prefix, type_aliases)
           return {} if node.nil?
 
@@ -119,8 +107,7 @@ module Rigor
         end
         private_class_method :collect_schema_assignment
 
-        # Matches `Dry::Schema.Params { ... }` /
-        # `Dry::Schema.JSON { ... }` / `Dry::Schema.define { ... }`.
+        # Matches `Dry::Schema.Params { ... }` / `Dry::Schema.JSON { ... }` / `Dry::Schema.define { ... }`.
         def schema_entry_call?(node)
           return false unless node.is_a?(Prism::CallNode)
           return false unless SCHEMA_ENTRY_NAMES.include?(node.name)
@@ -147,10 +134,9 @@ module Rigor
         end
         private_class_method :collect_schema_shape
 
-        # Walks every top-level `required(:key).<predicate>(...)` /
-        # `optional(:key).<predicate>(...)` chain in the block
-        # body. The block's body is either a `Prism::StatementsNode`
-        # (multi-statement) or a single expression node.
+        # Walks every top-level `required(:key).<predicate>(...)` / `optional(:key).<predicate>(...)`
+        # chain in the block body. The block's body is either a `Prism::StatementsNode` (multi-statement)
+        # or a single expression node.
         def walk_block_body(block_node, &)
           body = block_node.body
           return if body.nil?
@@ -160,13 +146,10 @@ module Rigor
         end
         private_class_method :walk_block_body
 
-        # `required(:key).filled(:string)` parses as a CallNode
-        # whose receiver is the `required(:key)` call. Walk the
-        # chain inward looking for the type-bearing predicate at
-        # the head; the key sits on the chain's tail. The
-        # `each(<Type>)` predicate yields a list-of-element
-        # type info (`{type: <T>, list: true}`); other type-bearing
-        # predicates (`filled`/`value`/`maybe`) yield scalar info
+        # `required(:key).filled(:string)` parses as a CallNode whose receiver is the `required(:key)`
+        # call. Walk the chain inward looking for the type-bearing predicate at the head; the key sits on
+        # the chain's tail. The `each(<Type>)` predicate yields a list-of-element type info (`{type: <T>,
+        # list: true}`); other type-bearing predicates (`filled`/`value`/`maybe`) yield scalar info
         # (`{type: <T>, list: false}`).
         def visit_chain(node, &block)
           return unless node.is_a?(Prism::CallNode)
@@ -179,11 +162,9 @@ module Rigor
         end
         private_class_method :visit_chain
 
-        # `required(:key).filled(:string).value(...)...` — the
-        # OUTERMOST call's receiver chain ends in the
-        # `required(:key)` / `optional(:key)` call. Recurse on
-        # `node.receiver` until we hit the `required` /
-        # `optional` call, recording the key + kind.
+        # `required(:key).filled(:string).value(...)...` — the OUTERMOST call's receiver chain ends in
+        # the `required(:key)` / `optional(:key)` call. Recurse on `node.receiver` until we hit the
+        # `required` / `optional` call, recording the key + kind.
         def extract_key_and_kind(node)
           current = node
           while current.is_a?(Prism::CallNode)
@@ -199,11 +180,9 @@ module Rigor
         end
         private_class_method :extract_key_and_kind
 
-        # Walks the call chain finding the first type-bearing
-        # predicate (`filled` / `value` / `maybe` / `each`) and
-        # extracts its argument type. Returns a `{type:, list:}`
-        # tuple (`each` is the only verb that produces a list)
-        # or nil when no recognisable type sits on the chain.
+        # Walks the call chain finding the first type-bearing predicate (`filled` / `value` / `maybe` /
+        # `each`) and extracts its argument type. Returns a `{type:, list:}` tuple (`each` is the only
+        # verb that produces a list) or nil when no recognisable type sits on the chain.
         def walk_predicate_chain(node)
           current = node
           while current.is_a?(Prism::CallNode)
@@ -217,12 +196,10 @@ module Rigor
         end
         private_class_method :walk_predicate_chain
 
-        # Reads the first positional argument of a `filled(:string)`
-        # / `value(:integer)` / `maybe(Types::Email)` call. Returns
-        # either the canonical-type-symbol's underlying class
-        # ("String" / "Integer" / …), or the constant's qualified
-        # name for downstream type-alias resolution. Returns nil
-        # for anything else.
+        # Reads the first positional argument of a `filled(:string)` / `value(:integer)` /
+        # `maybe(Types::Email)` call. Returns either the canonical-type-symbol's underlying class
+        # ("String" / "Integer" / …), or the constant's qualified name for downstream type-alias
+        # resolution. Returns nil for anything else.
         def extract_type_from_predicate(call_node)
           arg = call_node.arguments&.arguments&.first
           case arg
@@ -236,12 +213,10 @@ module Rigor
         end
         private_class_method :extract_type_from_predicate
 
-        # In-place: any value's `type:` slot in `bucket` that
-        # doesn't already match a canonical class (e.g.
-        # `"Types::Email"`) gets resolved through the
-        # type_aliases fact. Unresolvable values drop from the
-        # bucket (no fact contribution rather than misleading
-        # data). The `list:` slot rides along unchanged.
+        # In-place: any value's `type:` slot in `bucket` that doesn't already match a canonical class
+        # (e.g. `"Types::Email"`) gets resolved through the type_aliases fact. Unresolvable values drop
+        # from the bucket (no fact contribution rather than misleading data). The `list:` slot rides along
+        # unchanged.
         def remap_aliases!(bucket, type_aliases)
           canonical_set = CANONICAL_TYPES.values.to_set
           bucket.each_pair.to_a.each do |key, info|
@@ -258,9 +233,8 @@ module Rigor
         end
         private_class_method :remap_aliases!
 
-        # Constant-path serialiser: `Dry::Schema` -> "Dry::Schema",
-        # bare `Foo` -> "Foo". Returns nil for shapes Prism
-        # doesn't expose as ConstantRead/PathNode.
+        # Constant-path serialiser: `Dry::Schema` -> "Dry::Schema", bare `Foo` -> "Foo". Returns nil for
+        # shapes Prism doesn't expose as ConstantRead/PathNode.
         def constant_name_for(node)
           return nil if node.nil?
 

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema.rb

@@ -10,7 +10,8 @@ module Rigor
   module Plugin
     # rigor-dry-schema — Tier A per
     # [ADR-12](../../../../../docs/adr/12-dry-rb-packaging.md) and the
-    # slicing plan in [docs/design/20260517-dry-validation-slicing.md](../../../../../docs/design/20260517-dry-validation-slicing.md).
+    # slicing plan in
+    # [docs/design/20260517-dry-validation-slicing.md](../../../../../docs/design/20260517-dry-validation-slicing.md).
     #
     # Recognises the canonical dry-schema declaration shapes:
     #
@@ -28,51 +29,42 @@ module Rigor
     #       required(:foo).value(:string)
     #     end
     #
-    # and publishes the resulting
-    # `{schema_const_fqn => {required: {key => underlying_class}, optional: {…}}}`
-    # table as the `:dry_schema_table` cross-plugin fact (ADR-9).
-    # Downstream `rigor-dry-validation` consumes the fact for
-    # per-Contract typed-payload synthesis.
+    # and publishes the resulting `{schema_const_fqn => {required: {key => underlying_class}, optional:
+    # {…}}}` table as the `:dry_schema_table` cross-plugin fact (ADR-9). Downstream `rigor-dry-validation`
+    # consumes the fact for per-Contract typed-payload synthesis.
     #
     # ## Predicate type recognition
     #
-    # Each `required(:key).<predicate>(<arg>)` row maps the predicate
-    # argument to an underlying Ruby class via the dry-schema
-    # canonical-type vocabulary:
+    # Each `required(:key).<predicate>(<arg>)` row maps the predicate argument to an underlying Ruby
+    # class via the dry-schema canonical-type vocabulary:
     #
-    # - `:string` / `:integer` / `:float` / `:decimal` / `:symbol` /
-    #   `:bool` / `:nil` / `:date` / `:date_time` / `:time` / `:hash`
-    #   / `:array` map to their underlying class.
-    # - The four predicate verbs `filled` / `value` / `maybe` /
-    #   `each` are accepted on the same row; their semantic
-    #   difference (whether the value is nullable or coerced) does
-    #   not change the underlying class for Rigor's purposes.
-    # - References to dry-types aliases (`value(Types::Email)`,
-    #   `filled(Types::String)`) resolve through the
-    #   `:dry_type_aliases` ADR-9 fact published by `rigor-dry-types`
-    #   when that plugin is loaded; without it the row degrades to
-    #   "no type contribution from this key".
+    # - `:string` / `:integer` / `:float` / `:decimal` / `:symbol` / `:bool` / `:nil` / `:date` /
+    #   `:date_time` / `:time` / `:hash` / `:array` map to their underlying class.
+    # - The four predicate verbs `filled` / `value` / `maybe` / `each` are accepted on the same row; their
+    #   semantic difference (whether the value is nullable or coerced) does not change the underlying
+    #   class for Rigor's purposes.
+    # - References to dry-types aliases (`value(Types::Email)`, `filled(Types::String)`) resolve through
+    #   the `:dry_type_aliases` ADR-9 fact published by `rigor-dry-types` when that plugin is loaded;
+    #   without it the row degrades to "no type contribution from this key".
     #
     # ## Floor / ceiling (slice 1)
     #
     # Slice 1 ships the **floor**:
     #
-    # - Top-level `Foo = Dry::Schema.{Params,JSON,define} { ... }`
-    #   assignments. Class-level constants (`class Bar; SCHEMA =
-    #   Dry::Schema.Params { ... }; end`) work too — the walker
-    #   prefixes the enclosing constant chain.
-    # - `required(:key).<predicate>(:type_symbol_or_constant)` rows
-    #   for the canonical-type vocabulary above.
+    # - Top-level `Foo = Dry::Schema.{Params,JSON,define} { ... }` assignments. Class-level constants
+    #   (`class Bar; SCHEMA = Dry::Schema.Params { ... }; end`) work too — the walker prefixes the
+    #   enclosing constant chain.
+    # - `required(:key).<predicate>(:type_symbol_or_constant)` rows for the canonical-type vocabulary
+    #   above.
     # - Publishes the table; no user-facing diagnostics yet.
     #
     # The **ceiling** (slice 2+):
     #
-    # - Synthesise typed `result.to_h` returns from each schema
-    #   via ADR-16 Tier C heredoc-template substrate.
+    # - Synthesise typed `result.to_h` returns from each schema via ADR-16 Tier C heredoc-template
+    #   substrate.
     # - Nested schemas (`schema(do ... end)` inside another row).
     # - `predicates(:size?)` / `each { ... }` recursion.
-    # - Per-row `dry-schema.unknown-predicate` /
-    #   `dry-schema.unknown-type` `:info` diagnostics when a
+    # - Per-row `dry-schema.unknown-predicate` / `dry-schema.unknown-type` `:info` diagnostics when a
     #   row's predicate or type symbol isn't recognised.
     class DrySchema < Rigor::Plugin::Base
       manifest(
@@ -84,10 +76,9 @@ module Rigor
         consumes: [{ plugin_id: "dry-types", name: :dry_type_aliases, optional: true }]
       )
 
-      # Walks every project file once during `prepare(services)` to
-      # build the schema table, then publishes via the ADR-9 fact
-      # store. Mirrors the rigor-dry-types `#prepare` shape — the
-      # walk is bounded by `paths:`, parse errors degrade silently.
+      # Walks every project file once during `prepare(services)` to build the schema table, then publishes
+      # via the ADR-9 fact store. Mirrors the rigor-dry-types `#prepare` shape — the walk is bounded by
+      # `paths:`, parse errors degrade silently.
       def prepare(services)
         type_aliases = services.fact_store.read(plugin_id: "dry-types", name: :dry_type_aliases) || {}
         table = SchemaScanner.scan(paths: scannable_paths(services), type_aliases: type_aliases)

data/plugins/rigor-dry-schema/lib/rigor-dry-schema.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# Gem entry point. Required by Rigor's plugin loader when
-# `.rigor.yml` lists `rigor-dry-schema` under `plugins:`. The
-# loader expects this `require` to side-effect a call to
-# `Rigor::Plugin.register`, which the body of
-# `lib/rigor/plugin/dry_schema.rb` performs at load time.
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-dry-schema` under
+# `plugins:`. The loader expects this `require` to side-effect a call to `Rigor::Plugin.register`,
+# which the body of `lib/rigor/plugin/dry_schema.rb` performs at load time.
 require_relative "rigor/plugin/dry_schema"

data/plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb

@@ -4,16 +4,13 @@ require "rigor/plugin"
 
 module Rigor
   module Plugin
-    # ADR-16 Tier C worked plugin: recognises dry-struct's class-
-    # level `attribute :name, T` DSL and synthesises a reader on
-    # the enclosing `Dry::Struct` subclass.
+    # ADR-16 Tier C worked plugin: recognises dry-struct's class-level `attribute :name, T` DSL and
+    # synthesises a reader on the enclosing `Dry::Struct` subclass.
     #
-    # dry-struct's `Dry::Struct::ClassInterface#attribute` (per the
-    # per-library survey, `lib/dry/struct/class_interface.rb:86-88`
-    # in the upstream gem) is the textbook Tier C target — a
-    # class-level DSL call enumerates a literal Symbol argument, and
-    # `class_interface.rb:452-464` `class_eval`s a heredoc
-    # interpolating that Symbol into a getter:
+    # dry-struct's `Dry::Struct::ClassInterface#attribute` (per the per-library survey,
+    # `lib/dry/struct/class_interface.rb:86-88` in the upstream gem) is the textbook Tier C target — a
+    # class-level DSL call enumerates a literal Symbol argument, and `class_interface.rb:452-464`
+    # `class_eval`s a heredoc interpolating that Symbol into a getter:
     #
     #     class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
     #       def #{key}                       # def city
@@ -21,44 +18,36 @@ module Rigor
     #       end
     #     RUBY
     #
-    # The substrate replays the same contract statically. For
-    # source like:
+    # The substrate replays the same contract statically. For source like:
     #
     #     class Address < Dry::Struct
     #       attribute :city, Types::String
     #       attribute :country, Types::String
     #     end
     #
-    # the pre-pass scans the file, sees `attribute :city, ...`, and
-    # synthesises `Address#city` as a SyntheticMethod the dispatcher
-    # surfaces below RBS dispatch. Bare `address.city` calls in
-    # other files then dispatch through the synthetic record rather
-    # than falling through to `call.undefined-method`.
+    # the pre-pass scans the file, sees `attribute :city, ...`, and synthesises `Address#city` as a
+    # SyntheticMethod the dispatcher surfaces below RBS dispatch. Bare `address.city` calls in other
+    # files then dispatch through the synthetic record rather than falling through to
+    # `call.undefined-method`.
     #
     # ## Precision model (ADR-16 WD13 + ADR-18)
     #
-    # The synthetic reader's return type is resolved via ADR-18's
-    # `returns_from_arg:` fact lookup: the call-site's second argument
-    # (`Types::String` etc.) is looked up through the `:dry_type_aliases`
-    # fact published by `rigor-dry-types`, yielding `Nominal[String]`
-    # for common cases. When the lookup misses (e.g. inline method-chain
-    # argument whose chain-head isn't currently extracted), the row
+    # The synthetic reader's return type is resolved via ADR-18's `returns_from_arg:` fact lookup: the
+    # call-site's second argument (`Types::String` etc.) is looked up through the `:dry_type_aliases`
+    # fact published by `rigor-dry-types`, yielding `Nominal[String]` for common cases. When the lookup
+    # misses (e.g. inline method-chain argument whose chain-head isn't currently extracted), the row
     # falls back to `Dynamic[Top]` silently.
     #
     # ## Scope (slice 2c minimum)
     #
     # - Recognises `attribute :name, T` at class body top level.
-    # - Recognises `attribute? :name, T` via a separate template
-    #   entry (omittable attribute; same reader name, `?` stripped).
-    # - Synthesises **only the reader** — the other survey-listed
-    #   emit rows (`schema` key, `to_h` row, `[:key]` access, `.new`
-    #   kwarg) are not yet wired by the substrate (they require
-    #   either RBS-level shape synthesis or additional substrate
-    #   primitives). Slice 2c stops at the reader.
-    # - Nested-block form (`attribute :details do ... end` minting
-    #   `Address::Details`) is out of scope for slice 2c; that
-    #   pattern needs Tier A + Tier C composition + const_set
-    #   emission. Deferred.
+    # - Recognises `attribute? :name, T` via a separate template entry (omittable attribute; same reader
+    #   name, `?` stripped).
+    # - Synthesises **only the reader** — the other survey-listed emit rows (`schema` key, `to_h` row,
+    #   `[:key]` access, `.new` kwarg) are not yet wired by the substrate (they require either RBS-level
+    #   shape synthesis or additional substrate primitives). Slice 2c stops at the reader.
+    # - Nested-block form (`attribute :details do ... end` minting `Address::Details`) is out of scope
+    #   for slice 2c; that pattern needs Tier A + Tier C composition + const_set emission. Deferred.
     class DryStruct < Rigor::Plugin::Base
       manifest(
         id: "dry-struct",
@@ -66,26 +55,20 @@ module Rigor
         description: "Recognises dry-struct `attribute :name, T` DSL via ADR-16 Tier C; " \
                      "promotes the reader's return type through ADR-18's `returns_from_arg:` " \
                      "by consuming `rigor-dry-types`'s `:dry_type_aliases` fact.",
-        # ADR-9 consumption — the precision-promotion path
-        # below uses `:dry_type_aliases` published by
-        # `rigor-dry-types`. The fact is optional: when the
-        # `rigor-dry-types` plugin isn't loaded, the
-        # `returns_from_arg:` lookup misses and the synthetic
-        # readers fall back to `Dynamic[Top]` (the pre-ADR-18
-        # floor).
+        # ADR-9 consumption — the precision-promotion path below uses `:dry_type_aliases` published by
+        # `rigor-dry-types`. The fact is optional: when the `rigor-dry-types` plugin isn't loaded, the
+        # `returns_from_arg:` lookup misses and the synthetic readers fall back to `Dynamic[Top]` (the
+        # pre-ADR-18 floor).
         consumes: [{ plugin_id: "dry-types", name: :dry_type_aliases, optional: true }],
         heredoc_templates: [
           Rigor::Plugin::Macro::HeredocTemplate.new(
             receiver_constraint: "Dry::Struct",
             method_name: :attribute,
             symbol_arg_position: 0,
-            # ADR-18 — the synthetic reader's return type comes
-            # from the call site's second argument
-            # (`Types::String` etc.), resolved through the
-            # `:dry_type_aliases` fact. When the lookup misses
-            # (e.g. inline `attribute :tag, Types::String.constrained(...)`,
-            # whose receiver chain head isn't currently
-            # extracted), the row falls back to Dynamic[Top].
+            # ADR-18 — the synthetic reader's return type comes from the call site's second argument
+            # (`Types::String` etc.), resolved through the `:dry_type_aliases` fact. When the lookup
+            # misses (e.g. inline `attribute :tag, Types::String.constrained(...)`, whose receiver chain
+            # head isn't currently extracted), the row falls back to Dynamic[Top].
             emit: [{
               name: "\#{name}",
               returns_from_arg: {

data/plugins/rigor-dry-struct/lib/rigor-dry-struct.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# Gem entry point. Required by Rigor's plugin loader when
-# `.rigor.yml` lists `rigor-dry-struct` under `plugins:`. The
-# loader expects this `require` to side-effect a call to
-# `Rigor::Plugin.register`, which the body of
-# `lib/rigor/plugin/dry_struct.rb` performs at load time.
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-dry-struct` under
+# `plugins:`. The loader expects this `require` to side-effect a call to `Rigor::Plugin.register`,
+# which the body of `lib/rigor/plugin/dry_struct.rb` performs at load time.
 require_relative "rigor/plugin/dry_struct"