rigortype 0.1.9 → 0.1.11

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Graphql < Rigor::Plugin::Base
+      # Walks project source for `class T < GraphQL::Schema::Object`
+      # subclasses and emits a `{type_class_fqn => {field_name => {type:, nullable:}}}`
+      # table covering every `field :name, Type, null: ...` declaration
+      # inside the class body.
+      module TypeScanner
+        # The canonical GraphQL scalar type names accepted as
+        # `field`'s second positional argument. The plugin maps
+        # each to the underlying Ruby class name so downstream
+        # consumers can cross-reference against Ruby types
+        # without re-implementing the GraphQL→Ruby coercion
+        # table.
+        CANONICAL_TYPES = {
+          "String" => "String",
+          "Integer" => "Integer",
+          "Int" => "Integer",
+          "Boolean" => "TrueClass",
+          "Float" => "Float",
+          "ID" => "String"
+        }.freeze
+
+        # The base class name a Schema::Object subclass MUST
+        # inherit from to be recognised. Match is on the
+        # rightmost segment of the superclass constant chain so
+        # both `GraphQL::Schema::Object` and the locally-aliased
+        # `BaseObject = GraphQL::Schema::Object` shape work when
+        # the alias's RHS is the canonical path.
+        SCHEMA_OBJECT_TAIL = "Object"
+        SCHEMA_ENUM_TAIL = "Enum"
+        SCHEMA_INPUT_OBJECT_TAIL = "InputObject"
+        SCHEMA_MUTATION_TAIL = "Mutation"
+        # Common path-segment for `Schema::Object` / `Schema::Enum`
+        # / `Schema::InputObject` / `Schema::Mutation`; the
+        # second-to-last segment must be `Schema` (either
+        # fully-qualified `GraphQL::Schema::X` or lexically nested
+        # `Schema::X` inside `module GraphQL`).
+        SCHEMA_PARENT_SEGMENTS = %w[Schema GraphQL].freeze
+        private_constant :SCHEMA_OBJECT_TAIL, :SCHEMA_ENUM_TAIL,
+                         :SCHEMA_INPUT_OBJECT_TAIL, :SCHEMA_MUTATION_TAIL,
+                         :SCHEMA_PARENT_SEGMENTS
+
+        module_function
+
+        # @param paths [Array<String>] absolute paths to `.rb` files
+        #   the project's `paths:` resolves to.
+        # @return [Hash{Symbol => Hash}] frozen 3-key result with
+        #   `:types` (per-`Schema::Object` field table),
+        #   `:enums` (per-`Schema::Enum` value list), and
+        #   `:input_objects` (per-`Schema::InputObject` argument
+        #   table). Any subset may be empty when no recognisable
+        #   declaration of that kind is found.
+        def scan(paths:)
+          acc = empty_accumulator
+          paths.each do |path|
+            merge_accumulator(acc, scan_file(path))
+          end
+          freeze_accumulator(acc)
+        end
+
+        def empty_accumulator
+          { types: {}, enums: {}, input_objects: {}, mutations: {} }
+        end
+        private_class_method :empty_accumulator
+
+        def merge_accumulator(target, source)
+          source.each do |kind, table|
+            table.each { |k, v| target[kind][k] ||= v }
+          end
+          target
+        end
+        private_class_method :merge_accumulator
+
+        def freeze_accumulator(acc)
+          { types: acc[:types].freeze,
+            enums: acc[:enums].freeze,
+            input_objects: acc[:input_objects].freeze,
+            mutations: acc[:mutations].freeze }.freeze
+        end
+        private_class_method :freeze_accumulator
+
+        def scan_file(path)
+          source = File.read(path)
+          parse_result = Prism.parse(source, filepath: path)
+          return empty_accumulator unless parse_result.errors.empty?
+
+          collect_definitions(parse_result.value, [])
+        rescue StandardError
+          empty_accumulator
+        end
+        private_class_method :scan_file
+
+        # Walks the AST collecting `class X < GraphQL::Schema::Object`,
+        # `class X < GraphQL::Schema::Enum`, and
+        # `class X < GraphQL::Schema::InputObject` decls at any
+        # nesting level. Returns a 3-key hash so the caller can
+        # publish multiple cross-plugin facts from one walk.
+        def collect_definitions(node, qualified_prefix)
+          return empty_accumulator if node.nil?
+
+          case node
+          when Prism::ClassNode then collect_class_node(node, qualified_prefix)
+          when Prism::ModuleNode then collect_module_node(node, qualified_prefix)
+          else
+            node.compact_child_nodes.each_with_object(empty_accumulator) do |child, acc|
+              merge_accumulator(acc, collect_definitions(child, qualified_prefix))
+            end
+          end
+        end
+        private_class_method :collect_definitions
+
+        def collect_class_node(node, qualified_prefix)
+          inner_name = constant_name_for(node.constant_path)
+          return empty_accumulator if inner_name.nil?
+
+          new_prefix = qualified_prefix + [inner_name]
+          inner = collect_definitions(node.body, new_prefix)
+          register_subclass!(node, new_prefix, inner)
+          inner
+        end
+        private_class_method :collect_class_node
+
+        def register_subclass!(class_node, prefix, acc)
+          fqn = prefix.join("::")
+          if schema_subclass?(class_node, SCHEMA_OBJECT_TAIL)
+            fields = collect_fields(class_node.body)
+            acc[:types][fqn] ||= fields unless fields.empty?
+          elsif schema_subclass?(class_node, SCHEMA_ENUM_TAIL)
+            values = collect_values(class_node.body)
+            acc[:enums][fqn] ||= values unless values.empty?
+          elsif schema_subclass?(class_node, SCHEMA_INPUT_OBJECT_TAIL)
+            arguments = collect_arguments(class_node.body)
+            acc[:input_objects][fqn] ||= arguments unless arguments.empty?
+          elsif schema_subclass?(class_node, SCHEMA_MUTATION_TAIL)
+            arguments = collect_arguments(class_node.body)
+            fields = collect_fields(class_node.body)
+            shape = { arguments: arguments, fields: fields }
+            acc[:mutations][fqn] ||= shape unless arguments.empty? && fields.empty?
+          end
+        end
+        private_class_method :register_subclass!
+
+        def collect_module_node(node, qualified_prefix)
+          inner_name = constant_name_for(node.constant_path)
+          return empty_accumulator if inner_name.nil?
+
+          collect_definitions(node.body, qualified_prefix + [inner_name])
+        end
+        private_class_method :collect_module_node
+
+        # `class X < GraphQL::Schema::<Tail>` matches when the
+        # superclass's last two path segments are `Schema::<Tail>`.
+        # Matches both `< GraphQL::Schema::<Tail>` (fully qualified)
+        # and `< Schema::<Tail>` (lexically inside `module GraphQL`).
+        def schema_subclass?(class_node, tail)
+          superclass = class_node.superclass
+          return false if superclass.nil?
+
+          path = constant_path_segments(superclass)
+          return false if path.empty?
+          return false unless path.last == tail
+
+          SCHEMA_PARENT_SEGMENTS.include?(path[-2])
+        end
+        private_class_method :schema_subclass?
+
+        def collect_fields(body)
+          return {} if body.nil?
+
+          fields = {}
+          statement_nodes(body).each do |node|
+            next unless node.is_a?(Prism::CallNode) && node.name == :field
+
+            field = parse_field_call(node)
+            next if field.nil?
+
+            fields[field[:name]] = {
+              type: field[:type], nullable: field[:nullable], list: field[:list]
+            }
+          end
+          fields
+        end
+        private_class_method :collect_fields
+
+        def statement_nodes(body)
+          body.is_a?(Prism::StatementsNode) ? body.body : [body]
+        end
+        private_class_method :statement_nodes
+
+        # Walks every top-level `value "..."` call inside an
+        # enum subclass body and returns the value names as an
+        # Array<String>. Both shapes graphql-ruby accepts work:
+        #
+        #     value "ACTIVE"
+        #     value "DISABLED", value: :off, description: "..."
+        #
+        # The first positional must be a String literal — the
+        # graphql-ruby `value` API also accepts a Symbol form
+        # (`value :ACTIVE`) but the documented idiom is String.
+        # Slice 2b only stores the GraphQL-side value name; the
+        # optional `value:` kwarg (Ruby-side override) and
+        # `description:` stay out of the published table for
+        # the floor.
+        def collect_values(body)
+          return [] if body.nil?
+
+          values = []
+          statement_nodes(body).each do |node|
+            next unless node.is_a?(Prism::CallNode) && node.name == :value
+
+            arg = node.arguments&.arguments&.first
+            values << arg.unescaped if arg.is_a?(Prism::StringNode)
+          end
+          values
+        end
+        private_class_method :collect_values
+
+        # Walks every top-level `argument :name, Type, required: ...`
+        # call inside an InputObject (or Mutation) subclass body and
+        # returns the per-argument shape table. Argument syntax
+        # mirrors `field` except the nullability axis is named
+        # `required:` (default `false` — per graphql-ruby's
+        # `argument` default; the OPPOSITE polarity of `field`'s
+        # `null:`).
+        #
+        #     argument :name, String, required: true
+        #     argument :tags, [String], required: false
+        #     argument :status, Types::Status, required: true
+        def collect_arguments(body)
+          return {} if body.nil?
+
+          arguments = {}
+          statement_nodes(body).each do |node|
+            next unless node.is_a?(Prism::CallNode) && node.name == :argument
+
+            argument = parse_argument_call(node)
+            next if argument.nil?
+
+            arguments[argument[:name]] = {
+              type: argument[:type], required: argument[:required], list: argument[:list]
+            }
+          end
+          arguments
+        end
+        private_class_method :collect_arguments
+
+        def parse_argument_call(node)
+          args = node.arguments&.arguments
+          return nil if args.nil? || args.size < 2
+
+          name_node = args[0]
+          type_node = args[1]
+          return nil unless name_node.is_a?(Prism::SymbolNode)
+
+          type_info = resolve_field_type(type_node)
+          return nil if type_info.nil?
+
+          {
+            name: name_node.unescaped,
+            type: type_info[:type],
+            list: type_info[:list],
+            required: extract_required_flag(args)
+          }
+        end
+        private_class_method :parse_argument_call
+
+        # Mirror of `extract_nullability` but reads the `required:`
+        # kwarg, defaulting to `false` (graphql-ruby's argument
+        # default — the OPPOSITE polarity of `field`'s `null:` /
+        # nullability default).
+        # rubocop:disable Naming/PredicateMethod  -- extractor returns the literal required value
+        def extract_required_flag(args)
+          kwargs = args.last
+          return false unless kwargs.is_a?(Prism::KeywordHashNode)
+
+          pair = kwargs.elements.find do |el|
+            el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "required"
+          end
+          return false if pair.nil?
+
+          case pair.value
+          when Prism::TrueNode then true
+          when Prism::FalseNode then false
+          else false
+          end
+        end
+        # rubocop:enable Naming/PredicateMethod
+        private_class_method :extract_required_flag
+
+        # `field :name, Type, null: false` shape. The first
+        # positional is a Symbol (field name); the second is a
+        # constant reference (GraphQL type) OR a single-element
+        # ArrayNode (`[Type]`) for GraphQL list types; `null:` is
+        # the nullability keyword (defaults to TRUE per
+        # graphql-ruby's field defaults so we mirror that).
+        def parse_field_call(node)
+          args = node.arguments&.arguments
+          return nil if args.nil? || args.size < 2
+
+          name_node = args[0]
+          type_node = args[1]
+          return nil unless name_node.is_a?(Prism::SymbolNode)
+
+          type_info = resolve_field_type(type_node)
+          return nil if type_info.nil?
+
+          {
+            name: name_node.unescaped,
+            type: type_info[:type],
+            list: type_info[:list],
+            nullable: extract_nullability(args)
+          }
+        end
+        private_class_method :parse_field_call
+
+        # Resolves the `Type` positional argument to a
+        # `{type: "ClassName", list: bool}` tuple. ArrayNode
+        # forms (`[String]` / `[Types::User]`) unwrap the single
+        # element and mark `list: true`. Bare constant refs are
+        # not lists. Returns nil for unrecognised shapes (string
+        # types `"User"`, Proc lazy types, etc.) so callers drop
+        # the field.
+        def resolve_field_type(node)
+          if node.is_a?(Prism::ArrayNode)
+            element = node.elements.first
+            return nil if node.elements.size != 1 || element.nil?
+
+            inner = resolve_constant_type(element)
+            return nil if inner.nil?
+
+            { type: inner, list: true }
+          else
+            name = resolve_constant_type(node)
+            return nil if name.nil?
+
+            { type: name, list: false }
+          end
+        end
+        private_class_method :resolve_field_type
+
+        def resolve_constant_type(node)
+          name = constant_name_for(node)
+          return nil if name.nil?
+
+          tail = name.split("::").last
+          CANONICAL_TYPES[tail] || name
+        end
+        private_class_method :resolve_constant_type
+
+        # Defaults to `true` (matches graphql-ruby's `field`
+        # default nullability). Looks for an explicit `null:`
+        # keyword and reads its boolean literal.
+        # rubocop:disable Naming/PredicateMethod  -- extractor returns the literal nullability value
+        def extract_nullability(args)
+          kwargs = args.last
+          return true unless kwargs.is_a?(Prism::KeywordHashNode)
+
+          null_pair = kwargs.elements.find do |el|
+            el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "null"
+          end
+          return true if null_pair.nil?
+
+          case null_pair.value
+          when Prism::TrueNode then true
+          when Prism::FalseNode then false
+          else true
+          end
+        end
+        # rubocop:enable Naming/PredicateMethod
+        private_class_method :extract_nullability
+
+        # Returns the constant chain as an Array of String
+        # segments (`["GraphQL", "Schema", "Object"]`). Empty
+        # array for unrecognised node kinds.
+        def constant_path_segments(node)
+          case node
+          when Prism::ConstantReadNode then [node.name.to_s]
+          when Prism::ConstantPathNode
+            segments = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              segments.unshift(current.name.to_s)
+              current = current.parent
+            end
+            segments.unshift(current.name.to_s) if current.is_a?(Prism::ConstantReadNode)
+            segments
+          else
+            []
+          end
+        end
+        private_class_method :constant_path_segments
+
+        # Joined `::`-form of {.constant_path_segments}. Returns
+        # nil for unrecognised node kinds (so callers can short-
+        # circuit).
+        def constant_name_for(node)
+          segments = constant_path_segments(node)
+          segments.empty? ? nil : segments.join("::")
+        end
+        private_class_method :constant_name_for
+      end
+    end
+  end
+end

data/plugins/rigor-graphql/lib/rigor/plugin/graphql.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "rigor/plugin"
+
+require_relative "graphql/type_scanner"
+
+module Rigor
+  module Plugin
+    # rigor-graphql — Tier 3 of the
+    # [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md)
+    # § "3D".
+    #
+    # Recognises `class T < GraphQL::Schema::Object` subclasses
+    # and walks every `field :name, Type, null: false` declaration
+    # inside, publishing the resulting field-type map as the
+    # `:graphql_type_table` cross-plugin fact (ADR-9). The macro
+    # expansion library survey at
+    # [docs/notes/20260515-macro-expansion-library-survey.md](../../../../../docs/notes/20260515-macro-expansion-library-survey.md)
+    # § "GraphQL-Ruby" documents WHY this is a pure metadata-recorder
+    # plugin rather than an ADR-16 substrate consumer: graphql-ruby's
+    # `field` DSL emits NO Ruby methods (it just records a
+    # `Schema::Field` on the class's `own_fields`). The user writes
+    # resolver methods themselves; rigor's value here is producing a
+    # static type table downstream consumers can cross-reference.
+    #
+    # ## What downstream consumers DO with `:graphql_type_table`
+    #
+    # The fact is the substrate for two future capabilities (both
+    # demand-driven, NOT in slice 1):
+    #
+    # - Resolver-method check: for each `field :name, Type` whose
+    #   `name` is also defined as a Ruby method on the class, verify
+    #   the method's return type matches `Type`'s underlying class.
+    # - Schema-query result typing: a future `rigor-graphql-execute`
+    #   plugin could type `Schema.execute(query).to_h` against the
+    #   queried fields.
+    #
+    # ## Floor / ceiling (slice 1)
+    #
+    # Slice 1 ships the **floor**:
+    #
+    # - Recognises `class T < GraphQL::Schema::Object` subclasses
+    #   (including nested namespaces: `class Types::User < ...`,
+    #   `module Types; class User < ...; end; end`).
+    # - Recognises the `field :name, Type, **opts` declaration with:
+    #   - `Type` as a `ConstantReadNode` / `ConstantPathNode` (`String`
+    #     / `Integer` / `Boolean` / `Float` / `ID`, or a user-defined
+    #     `Types::OtherObject`).
+    #   - `null: true` / `null: false` keyword extracts nullability.
+    # - Maps the canonical GraphQL scalar names to underlying Ruby
+    #   classes (`String` → `String`, `Integer` → `Integer`,
+    #   `Boolean` → `TrueClass`, `Float` → `Float`, `ID` → `String`).
+    # - Publishes the table; no user-facing diagnostics yet.
+    #
+    # The **ceiling** (future slices, demand-driven):
+    #
+    # - **`GraphQL::Schema::Enum`** with `value "ACTIVE"` calls.
+    # - **`GraphQL::Schema::Mutation`** + **`GraphQL::Schema::InputObject`**.
+    # - **List / Non-Null wrappers** (`[String]`, `String.array`).
+    # - **`resolver:` / `mutation:` reroute** recognition.
+    # - **String type expressions** (`field :foo, "User"`) — defeats
+    #   static resolution by design (graphql-ruby's `BuildType.parse_type`
+    #   constantizes at runtime); a future slice could surface these
+    #   as `graphql.string-type` `:info` diagnostics that point the
+    #   user at the constant-reference form for static typing.
+    class Graphql < Rigor::Plugin::Base
+      manifest(
+        id: "graphql",
+        version: "0.1.0",
+        description: "Recognises `class T < GraphQL::Schema::{Object,Enum,InputObject,Mutation}` " \
+                     "subclasses; publishes the per-type field-type table, the per-enum value " \
+                     "list, the per-input-object argument table, and the per-mutation arguments+fields " \
+                     "table.",
+        produces: %i[graphql_type_table graphql_enum_table graphql_input_object_table graphql_mutation_table]
+      )
+
+      def prepare(services)
+        scanned = TypeScanner.scan(paths: scannable_paths(services))
+        publish_if_present(services, :graphql_type_table, scanned.fetch(:types))
+        publish_if_present(services, :graphql_enum_table, scanned.fetch(:enums))
+        publish_if_present(services, :graphql_input_object_table, scanned.fetch(:input_objects))
+        publish_if_present(services, :graphql_mutation_table, scanned.fetch(:mutations))
+      end
+
+      def init(_services)
+        @scannable_paths = nil
+      end
+
+      private
+
+      def publish_if_present(services, name, value)
+        return if value.nil? || value.empty?
+
+        services.fact_store.publish(plugin_id: manifest.id, name: name, value: value)
+      end
+
+      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(Graphql)
+  end
+end

data/plugins/rigor-graphql/lib/rigor-graphql.rb

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

data/plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Hanami < Rigor::Plugin::Base
+      # Checks the "presence" half of the Hanami::Action
+      # ADR-28 protocol contract.
+      #
+      # Every class defined in a file matching a contract's
+      # `path_glob` must declare `#handle(request, response)`.
+      # The "provide" half — binding `Hanami::Action::Request`
+      # and `Hanami::Action::Response` into the method body —
+      # is handled engine-side by
+      # `Inference::MethodParameterBinder`. Return type is
+      # void so no conformance check is performed here.
+      class ActionChecker
+        FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+        def initialize(contracts:)
+          @contracts = contracts
+        end
+
+        def check(path:, root:)
+          @contracts.flat_map do |contract|
+            next [] unless path_matches?(contract.path_glob, path)
+
+            class_nodes(root).filter_map do |class_node|
+              handle_def = find_handle(class_node, contract)
+              if handle_def.nil?
+                missing_handle_diagnostic(contract, path, class_node)
+              else
+                handle_arity_mismatch_diagnostic(contract, path, class_node, handle_def)
+              end
+            end
+          end
+        end
+
+        private
+
+        # Contract globs are project-root-relative; the analyzer
+        # may supply a relative or absolute path, so the glob is
+        # matched both directly and with a `**/`-prefixed suffix.
+        def path_matches?(glob, path)
+          return false if path.nil?
+
+          File.fnmatch?(glob, path, FNMATCH_FLAGS) ||
+            File.fnmatch?(File.join("**", glob), path, FNMATCH_FLAGS)
+        end
+
+        def class_nodes(root)
+          found = []
+          walk(root) { |node| found << node if node.is_a?(Prism::ClassNode) }
+          found
+        end
+
+        def find_handle(class_node, contract)
+          direct_defs(class_node).find do |def_node|
+            def_node.name == contract.method_name &&
+              !def_node.receiver.is_a?(Prism::SelfNode)
+          end
+        end
+
+        def direct_defs(class_node)
+          defs = []
+          collect_direct_defs(class_node.body, defs)
+          defs
+        end
+
+        def collect_direct_defs(node, defs)
+          return if node.nil?
+
+          case node
+          when Prism::DefNode then defs << node
+          when Prism::ClassNode, Prism::ModuleNode then nil # nested scopes own their own defs
+          else node.compact_child_nodes.each { |child| collect_direct_defs(child, defs) }
+          end
+        end
+
+        def handle_arity_mismatch_diagnostic(contract, path, class_node, def_node)
+          req_count = def_node.parameters ? def_node.parameters.requireds.size : 0
+          return nil if req_count == 2
+
+          location = def_node.location
+          Rigor::Analysis::Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "`#{class_name(class_node)}#handle` must accept exactly 2 parameters " \
+                     "(request, response), got #{req_count}",
+            severity: contract.severity,
+            rule: "handle-arity-mismatch"
+          )
+        end
+
+        def missing_handle_diagnostic(contract, path, class_node)
+          location = (class_node.constant_path || class_node).location
+          Rigor::Analysis::Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "`#{class_name(class_node)}` must define `#handle(request, response)` — " \
+                     "required of every Hanami action under `#{contract.path_glob}`",
+            severity: contract.severity,
+            rule: "missing-handle-method"
+          )
+        end
+
+        def class_name(class_node)
+          path = class_node.constant_path
+          path.respond_to?(:slice) ? path.slice : class_node.name.to_s
+        end
+
+        def walk(node, &)
+          return if node.nil?
+
+          yield node
+          node.compact_child_nodes.each { |child| walk(child, &) }
+        end
+      end
+    end
+  end
+end