rigortype 0.1.9 → 0.1.11

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

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "prism"
+
+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.
+      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).
+        CANONICAL_TYPES = {
+          string: "String",
+          integer: "Integer",
+          float: "Float",
+          decimal: "BigDecimal",
+          symbol: "Symbol",
+          bool: "TrueClass",
+          date: "Date",
+          date_time: "DateTime",
+          time: "Time",
+          hash: "Hash",
+          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.
+        TYPE_BEARING_PREDICATES = %i[filled value maybe each].to_set.freeze
+        private_constant :TYPE_BEARING_PREDICATES
+
+        # The three entry-point method names on `Dry::Schema`.
+        SCHEMA_ENTRY_NAMES = %i[Params JSON define].to_set.freeze
+        private_constant :SCHEMA_ENTRY_NAMES
+
+        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.
+        def scan(paths:, type_aliases: {})
+          table = {}
+          paths.each do |path|
+            scan_file(path, type_aliases).each do |schema_const, shape|
+              table[schema_const] ||= shape
+            end
+          end
+          table.freeze
+        end
+
+        def scan_file(path, type_aliases)
+          source = File.read(path)
+          parse_result = Prism.parse(source, filepath: path)
+          return {} unless parse_result.errors.empty?
+
+          collect_schemas(parse_result.value, [], type_aliases)
+        rescue StandardError
+          {}
+        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"`.
+        def collect_schemas(node, qualified_prefix, type_aliases)
+          return {} if node.nil?
+
+          case node
+          when Prism::ConstantWriteNode
+            collect_schema_assignment(node, qualified_prefix, type_aliases)
+          when Prism::ClassNode
+            inner_name = constant_name_for(node.constant_path)
+            return {} if inner_name.nil?
+
+            collect_schemas(node.body, qualified_prefix + [inner_name], type_aliases)
+          when Prism::ModuleNode
+            inner_name = constant_name_for(node.constant_path)
+            return {} if inner_name.nil?
+
+            collect_schemas(node.body, qualified_prefix + [inner_name], type_aliases)
+          else
+            node.compact_child_nodes.each_with_object({}) do |child, acc|
+              collect_schemas(child, qualified_prefix, type_aliases).each do |k, v|
+                acc[k] ||= v
+              end
+            end
+          end
+        end
+        private_class_method :collect_schemas
+
+        def collect_schema_assignment(node, qualified_prefix, type_aliases)
+          rhs = node.value
+          return {} unless schema_entry_call?(rhs)
+          return {} unless rhs.is_a?(Prism::CallNode) && rhs.block
+
+          schema_const = (qualified_prefix + [node.name.to_s]).join("::")
+          shape = collect_schema_shape(rhs.block, type_aliases)
+          { schema_const => shape }
+        end
+        private_class_method :collect_schema_assignment
+
+        # 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)
+
+          receiver = node.receiver
+          receiver.is_a?(Prism::ConstantPathNode) &&
+            receiver.name == :Schema &&
+            receiver.parent.is_a?(Prism::ConstantReadNode) &&
+            receiver.parent.name == :Dry
+        end
+        private_class_method :schema_entry_call?
+
+        def collect_schema_shape(block_node, type_aliases)
+          required = {}
+          optional = {}
+          walk_block_body(block_node) do |kind, key, type_info|
+            (kind == :required ? required : optional)[key] = type_info if type_info
+          end
+
+          remap_aliases!(required, type_aliases)
+          remap_aliases!(optional, type_aliases)
+
+          { required: required.freeze, optional: optional.freeze }.freeze
+        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.
+        def walk_block_body(block_node, &)
+          body = block_node.body
+          return if body.nil?
+
+          children = body.is_a?(Prism::StatementsNode) ? body.body : [body]
+          children.each { |child| visit_chain(child, &) }
+        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
+        # (`{type: <T>, list: false}`).
+        def visit_chain(node, &block)
+          return unless node.is_a?(Prism::CallNode)
+
+          key, kind = extract_key_and_kind(node)
+          return if key.nil?
+
+          type_info = walk_predicate_chain(node)
+          block.call(kind, key, type_info)
+        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.
+        def extract_key_and_kind(node)
+          current = node
+          while current.is_a?(Prism::CallNode)
+            if %i[required optional].include?(current.name)
+              key_node = current.arguments&.arguments&.first
+              return [nil, nil] unless key_node.is_a?(Prism::SymbolNode)
+
+              return [key_node.unescaped.to_sym, current.name]
+            end
+            current = current.receiver
+          end
+          [nil, nil]
+        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.
+        def walk_predicate_chain(node)
+          current = node
+          while current.is_a?(Prism::CallNode)
+            if TYPE_BEARING_PREDICATES.include?(current.name)
+              underlying = extract_type_from_predicate(current)
+              return { type: underlying, list: current.name == :each } if underlying
+            end
+            current = current.receiver
+          end
+          nil
+        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.
+        def extract_type_from_predicate(call_node)
+          arg = call_node.arguments&.arguments&.first
+          case arg
+          when Prism::SymbolNode
+            CANONICAL_TYPES[arg.unescaped.to_sym]
+          when Prism::ConstantReadNode
+            arg.name.to_s
+          when Prism::ConstantPathNode
+            constant_name_for(arg)
+          end
+        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.
+        def remap_aliases!(bucket, type_aliases)
+          canonical_set = CANONICAL_TYPES.values.to_set
+          bucket.each_pair.to_a.each do |key, info|
+            type_name = info.fetch(:type)
+            next if canonical_set.include?(type_name)
+
+            resolved = type_aliases[type_name]
+            if resolved
+              bucket[key] = info.merge(type: resolved)
+            else
+              bucket.delete(key)
+            end
+          end
+        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.
+        def constant_name_for(node)
+          return nil if node.nil?
+
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil then "::#{parts.join('::')}"
+            when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+        private_class_method :constant_name_for
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "rigor/plugin"
+
+require_relative "dry_schema/schema_scanner"
+
+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).
+    #
+    # Recognises the canonical dry-schema declaration shapes:
+    #
+    #     NewUserSchema = Dry::Schema.Params do
+    #       required(:email).filled(:string)
+    #       required(:age).value(:integer)
+    #       optional(:nickname).maybe(:string)
+    #     end
+    #
+    #     ProductJSON = Dry::Schema.JSON do
+    #       required(:sku).filled(:string)
+    #     end
+    #
+    #     RawSchema = Dry::Schema.define do
+    #       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.
+    #
+    # ## 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:
+    #
+    # - `: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.
+    # - 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.
+    # - 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
+    #   row's predicate or type symbol isn't recognised.
+    class DrySchema < Rigor::Plugin::Base
+      manifest(
+        id: "dry-schema",
+        version: "0.1.0",
+        description: "Recognises `Dry::Schema.{Params,JSON,define} { ... }` declarations " \
+                     "and publishes the per-schema typed-key table.",
+        produces: [:dry_schema_table],
+        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.
+      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)
+        return if table.empty?
+
+        services.fact_store.publish(
+          plugin_id: manifest.id,
+          name: :dry_schema_table,
+          value: table
+        )
+      end
+
+      def init(_services)
+        @scannable_paths = nil
+      end
+
+      private
+
+      def scannable_paths(services)
+        @scannable_paths ||= services.configuration.paths.flat_map do |entry|
+          if File.directory?(entry)
+            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+          elsif File.file?(entry) && entry.end_with?(".rb")
+            [entry]
+          else
+            []
+          end
+        end.uniq.freeze
+      end
+    end
+
+    Rigor::Plugin.register(DrySchema)
+  end
+end

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

@@ -0,0 +1,8 @@
+# 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.
+require_relative "rigor/plugin/dry_schema"

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+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.
+    #
+    # 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
+    #         @attributes[#{key.inspect}]    #   @attributes[:city]
+    #       end
+    #     RUBY
+    #
+    # 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`.
+    #
+    # ## Floor / ceiling per ADR-16 WD13
+    #
+    # Slice 2 ships at the **floor**: the synthetic reader's return
+    # type degrades to `Dynamic[T]`. The manifest's `returns: "Object"`
+    # is recorded but not resolved — precise return-type promotion
+    # (so `attribute :city, Types::String` makes `address.city`
+    # return `String`) is the **ceiling**, deferred to slice 6
+    # (ADR-13 `Plugin::TypeNodeResolver` chain). The plugin's manifest
+    # value of `returns:` would today be the upstream gem's reader
+    # return shape; slice 6 unlocks precision without re-authoring.
+    #
+    # ## 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.
+    class DryStruct < Rigor::Plugin::Base
+      manifest(
+        id: "dry-struct",
+        version: "0.2.0",
+        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).
+        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].
+            emit: [{
+              name: "\#{name}",
+              returns_from_arg: {
+                position: 1,
+                lookup_via: { plugin_id: "dry-types", fact: :dry_type_aliases }
+              }
+            }]
+          ),
+          Rigor::Plugin::Macro::HeredocTemplate.new(
+            receiver_constraint: "Dry::Struct",
+            method_name: :attribute?,
+            symbol_arg_position: 0,
+            emit: [{
+              name: "\#{name}",
+              returns_from_arg: {
+                position: 1,
+                lookup_via: { plugin_id: "dry-types", fact: :dry_type_aliases }
+              }
+            }]
+          )
+        ]
+      )
+    end
+
+    Rigor::Plugin.register(DryStruct)
+  end
+end

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

@@ -0,0 +1,8 @@
+# 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.
+require_relative "rigor/plugin/dry_struct"