rigortype 0.1.9 → 0.1.11

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "prism"
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # Example plugin: validates state-machine references.
+    # Demonstrates the **two-pass DSL analysis** pattern many
+    # plugins reuse:
+    #
+    #   1. **Collect pass.** Walk the file once to gather every
+    #      state name declared inside a `state_machine do ... end`
+    #      block (`state :draft`, `state :submitted`, ...).
+    #   2. **Validate pass.** Walk the file again, validating each
+    #      `transition_to(:sym)` and `event :sym` reference against
+    #      the collected state set. Levenshtein distance ≤ 3 drives
+    #      the did-you-mean suggestions.
+    #
+    # Useful for `aasm` / `statesman` / hand-rolled DSLs and any
+    # framework where declarations and uses live in the same
+    # file. The same skeleton lifts to GraphQL types,
+    # ActiveModel validations, route declarations — anywhere a
+    # declarative DSL produces a closed namespace and the rest
+    # of the file references that namespace by literal symbol.
+    #
+    # ## Configuration
+    #
+    # Defaults match the `Statesman::Machine` API; override via
+    # `.rigor.yml` if your DSL uses different names:
+    #
+    #     plugins:
+    #       - gem: rigor-statesman
+    #         config:
+    #           dsl_method: state_machine    # the do-block opener
+    #           state_method: state          # state declaration inside the block
+    #           transition_method: transition_to  # call-site under check
+    #
+    # ## Diagnostics
+    #
+    # | Event                                    | Severity | Rule              |
+    # | ---                                      | ---      | ---               |
+    # | `transition_to(:known_state)`            | `:info`  | `known-state`     |
+    # | `transition_to(:typo)` (close match)     | `:error` | `unknown-state` (with did-you-mean) |
+    # | `transition_to(:typo)` (no close match)  | `:error` | `unknown-state`   |
+    # | file declares no state machine           | silent   | —                 |
+    class Statesman < Rigor::Plugin::Base
+      manifest(
+        id: "statesman",
+        version: "0.1.0",
+        description: "Validates state-machine transition references against declared states.",
+        config_schema: {
+          "dsl_method" => :string,
+          "state_method" => :string,
+          "transition_method" => :string
+        }
+      )
+
+      DEFAULT_DSL_METHOD = "state_machine"
+      DEFAULT_STATE_METHOD = "state"
+      DEFAULT_TRANSITION_METHOD = "transition_to"
+      DID_YOU_MEAN_DISTANCE = 3
+
+      def init(_services)
+        @dsl_method = config.fetch("dsl_method", DEFAULT_DSL_METHOD).to_sym
+        @state_method = config.fetch("state_method", DEFAULT_STATE_METHOD).to_sym
+        @transition_method = config.fetch("transition_method", DEFAULT_TRANSITION_METHOD).to_sym
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        states = collect_states(root)
+        return [] if states.empty?
+
+        validate_transitions(path, root, states)
+      end
+
+      private
+
+      # Pass 1 — every `state :foo` declaration inside a
+      # `<dsl_method> do ... end` block on the file. Returns a
+      # frozen Set of state name Symbols.
+      def collect_states(root)
+        states = Set.new
+        walk(root) do |node|
+          next unless dsl_call?(node)
+
+          walk(node.block) do |inner|
+            next unless state_declaration?(inner)
+
+            sym = literal_symbol_arg(inner, 0)
+            states << sym if sym
+          end
+        end
+        states.freeze
+      end
+
+      # Pass 2 — every `<transition_method>(:sym)` call.
+      def validate_transitions(path, root, states)
+        diagnostics = []
+        walk(root) do |node|
+          next unless transition_call?(node)
+
+          sym = literal_symbol_arg(node, 0)
+          next if sym.nil? # not a literal — defer to runtime
+
+          diagnostics << build_diagnostic(path, node, sym, states)
+        end
+        diagnostics
+      end
+
+      def build_diagnostic(path, node, sym, states)
+        if states.include?(sym)
+          diagnostic(
+            path, node,
+            severity: :info,
+            rule: "known-state",
+            message: "#{@transition_method}(:#{sym}) — declared state"
+          )
+        else
+          hint = did_you_mean(sym, states)
+          message = "unknown state :#{sym}"
+          message += " (did you mean :#{hint}?)" if hint
+          diagnostic(path, node, severity: :error, rule: "unknown-state", message: message)
+        end
+      end
+
+      def dsl_call?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == @dsl_method &&
+          node.block
+      end
+
+      def state_declaration?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == @state_method &&
+          !node.arguments.nil?
+      end
+
+      def transition_call?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == @transition_method &&
+          !node.arguments.nil?
+      end
+
+      def literal_symbol_arg(call, index)
+        node = call.arguments.arguments[index]
+        return nil unless node.is_a?(Prism::SymbolNode)
+
+        node.unescaped.to_sym
+      end
+
+      def walk(node, &)
+        return if node.nil?
+
+        yield node
+        node.compact_child_nodes.each { |child| walk(child, &) }
+      end
+
+      def did_you_mean(name, states)
+        target = name.to_s
+        best = nil
+        best_distance = DID_YOU_MEAN_DISTANCE + 1
+        states.each do |state|
+          distance = levenshtein(target, state.to_s)
+          if distance < best_distance
+            best = state
+            best_distance = distance
+          end
+        end
+        best
+      end
+
+      def levenshtein(a, b) # rubocop:disable Naming/MethodParameterName
+        return b.length if a.empty?
+        return a.length if b.empty?
+
+        rows = Array.new(a.length + 1) { |_i| Array.new(b.length + 1, 0) }
+        (0..a.length).each { |i| rows[i][0] = i }
+        (0..b.length).each { |j| rows[0][j] = j }
+
+        (1..a.length).each do |i|
+          (1..b.length).each do |j|
+            cost = a[i - 1] == b[j - 1] ? 0 : 1
+            rows[i][j] = [
+              rows[i - 1][j] + 1,
+              rows[i][j - 1] + 1,
+              rows[i - 1][j - 1] + cost
+            ].min
+          end
+        end
+        rows[a.length][b.length]
+      end
+
+      def diagnostic(path, node, severity:, rule:, message:)
+        location = node.location
+        Rigor::Analysis::Diagnostic.new(
+          path: path,
+          line: location.start_line,
+          column: location.start_column + 1,
+          message: message,
+          severity: severity,
+          rule: rule
+        )
+      end
+    end
+
+    Rigor::Plugin.register(Statesman)
+  end
+end

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

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

data/plugins/rigor-typescript-utility-types/lib/rigor/plugin/typescript_utility_types.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # Example plugin: ships the TypeScript-canonical utility-type
+    # aliases (`Pick<T, K>`, `Omit<T, K>`, `Partial<T>`,
+    # `Required<T>`, `Readonly<T>`) as opt-in vocabulary that
+    # resolves to the Rigor-canonical shape-projection type
+    # functions introduced in ADR-13.
+    #
+    # Background. `docs/type-specification/imported-built-in-types.md`
+    # § "Deferred or rejected imports" deliberately rejects
+    # TypeScript-canonical names from the Rigor core surface: the
+    # core stays RBS-canonical per ADR-0 / ADR-1, and the shape
+    # semantics live in core under `pick_of[T, K]` /
+    # `omit_of[T, K]` / `partial_of[T]` / `required_of[T]` /
+    # `readonly_of[T]` (added in ADR-13 slice 4). This plugin
+    # ships the TS spellings as an opt-in translation layer for
+    # users migrating from TypeScript / Sorbet / Flow-style RBI.
+    #
+    # Off by default — users add the gem to their `.rigor.yml`
+    # plugins list to enable.
+    #
+    # @example .rigor.yml
+    #   plugins:
+    #     - gem: rigor-typescript-utility-types
+    #
+    # Once loaded, an RBS::Extended payload such as
+    # `%a{rigor:v1:return: Pick[Foo, :a | :b]}` resolves through
+    # the chain: the parser builds a `Generic("Pick", …)` AST,
+    # the registry / built-in parametric builders decline, the
+    # chain consults `Resolvers::Pick`, which recursively
+    # resolves the two arguments to Rigor types and calls
+    # `Type::Combinator.pick_of` on them.
+    #
+    # ## Translation table
+    #
+    # | TypeScript spelling | Rigor core call                          |
+    # | --- | --- |
+    # | `Pick<T, K>`     | `Type::Combinator.pick_of(T, K)`     |
+    # | `Omit<T, K>`     | `Type::Combinator.omit_of(T, K)`     |
+    # | `Partial<T>`     | `Type::Combinator.partial_of(T)`     |
+    # | `Required<T>`    | `Type::Combinator.required_of(T)`    |
+    # | `Readonly<T>`    | `Type::Combinator.readonly_of(T)`    |
+    #
+    # ## Deferred TypeScript utility names
+    #
+    # `Parameters<F>` / `ReturnType<F>` / `InstanceType<C>` /
+    # `Awaited<P>` / `Uppercase<S>` / `Lowercase<S>` /
+    # `Capitalize<S>` / `Uncapitalize<S>` / `ThisParameterType<F>`
+    # / `OmitThisParameter<F>` / `ConstructorParameters<C>` /
+    # `NoInfer<T>` are NOT mapped today. The plugin returns `nil`
+    # from `#resolve` for those heads, leaving the parser's
+    # default Nominal-fallback to produce `Nominal[ReturnType, …]`
+    # etc. Function-type projection operators (`params_of[F]` /
+    # `return_of[F]`) and class projections (`instance_type[C]`)
+    # would unlock these — they remain deferred in core.
+    class TypescriptUtilityTypes < Rigor::Plugin::Base
+      module Resolvers
+        # Common helper: extract a single-arg utility-type Generic
+        # whose head matches `name`. Returns the resolved
+        # argument's `Rigor::Type` or `nil` (so the chain falls
+        # through).
+        module SingleArg
+          def self.resolve(node, scope, name)
+            return nil unless node.is_a?(Rigor::TypeNode::Generic)
+            return nil unless node.head == name
+            return nil unless node.args.size == 1
+
+            scope.resolver.resolve(node.args[0], scope)
+          end
+        end
+
+        # Common helper for two-arg utility types.
+        module TwoArg
+          def self.resolve(node, scope, name)
+            return nil unless node.is_a?(Rigor::TypeNode::Generic)
+            return nil unless node.head == name
+            return nil unless node.args.size == 2
+
+            [scope.resolver.resolve(node.args[0], scope),
+             scope.resolver.resolve(node.args[1], scope)]
+          end
+        end
+
+        # `Pick<T, K>` → `pick_of[T, K]`.
+        class Pick < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            resolved = TwoArg.resolve(node, scope, "Pick")
+            return nil if resolved.nil?
+
+            t_type, k_type = resolved
+            return nil if t_type.nil? || k_type.nil?
+
+            Rigor::Type::Combinator.pick_of(t_type, k_type)
+          end
+        end
+
+        # `Omit<T, K>` → `omit_of[T, K]`.
+        class Omit < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            resolved = TwoArg.resolve(node, scope, "Omit")
+            return nil if resolved.nil?
+
+            t_type, k_type = resolved
+            return nil if t_type.nil? || k_type.nil?
+
+            Rigor::Type::Combinator.omit_of(t_type, k_type)
+          end
+        end
+
+        # `Partial<T>` → `partial_of[T]`.
+        class Partial < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            t_type = SingleArg.resolve(node, scope, "Partial")
+            return nil if t_type.nil?
+
+            Rigor::Type::Combinator.partial_of(t_type)
+          end
+        end
+
+        # `Required<T>` → `required_of[T]`.
+        class Required < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            t_type = SingleArg.resolve(node, scope, "Required")
+            return nil if t_type.nil?
+
+            Rigor::Type::Combinator.required_of(t_type)
+          end
+        end
+
+        # `Readonly<T>` → `readonly_of[T]`.
+        class Readonly < Rigor::Plugin::TypeNodeResolver
+          def resolve(node, scope)
+            t_type = SingleArg.resolve(node, scope, "Readonly")
+            return nil if t_type.nil?
+
+            Rigor::Type::Combinator.readonly_of(t_type)
+          end
+        end
+      end
+
+      manifest(
+        id: "typescript-utility-types",
+        version: "0.1.0",
+        description: "Maps TypeScript-canonical utility-type aliases " \
+                     "(Pick, Omit, Partial, Required, Readonly) onto the " \
+                     "Rigor-canonical shape-projection type functions.",
+        type_node_resolvers: [
+          Resolvers::Pick.new,
+          Resolvers::Omit.new,
+          Resolvers::Partial.new,
+          Resolvers::Required.new,
+          Resolvers::Readonly.new
+        ]
+      )
+    end
+
+    register(TypescriptUtilityTypes)
+  end
+end

data/plugins/rigor-typescript-utility-types/lib/rigor-typescript-utility-types.rb

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

data/sig/rigor/analysis/baseline.rbs

@@ -0,0 +1,39 @@
+module Rigor
+  module Analysis
+    # ADR-22 Slice 1 — per-project baseline filter.
+    # See lib/rigor/analysis/baseline.rb for the full contract.
+    class Baseline
+      class LoadError < ::StandardError
+      end
+
+      # Load a baseline file from disk.
+      # Returns `nil` when `path` is nil (no baseline configured).
+      # Raises {LoadError} on malformed or unsupported content.
+      def self.load: (::String? path) -> Baseline?
+
+      # Build a baseline from a current run's diagnostic stream.
+      def self.from_diagnostics: (untyped diagnostics, ?match_mode: :rule | :message) -> Baseline
+
+      attr_reader buckets: untyped
+
+      def initialize: (untyped buckets) -> void
+
+      # Apply the baseline filter. Returns [surfaced_diagnostics, silenced_count].
+      def filter: (untyped diagnostics) -> [untyped, ::Integer]
+
+      # Report bucket-level drift for each recorded baseline bucket.
+      def audit: (untyped diagnostics) -> untyped
+
+      # Return a new Baseline with the given buckets removed.
+      def without: (untyped buckets_to_drop) -> Baseline
+
+      # Serialise to a YAML string.
+      def to_yaml: () -> ::String
+
+      # Number of recorded buckets.
+      def size: () -> ::Integer
+
+      def empty?: () -> bool
+    end
+  end
+end

data/sig/rigor/environment.rbs

@@ -15,11 +15,12 @@ module Rigor
     attr_reader hkt_registry: untyped?
 
     def self.default: () -> Environment
-    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> Environment
+    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?source_rbs_synthesis_reporter: untyped?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> Environment
 
-    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> void
+    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?source_rbs_synthesis_reporter: untyped?, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> void
     def rbs_extended_reporter: () -> untyped?
     def boundary_cross_reporter: () -> untyped?
+    def source_rbs_synthesis_reporter: () -> untyped?
     def attach_reporters!: (rbs_extended_reporter: untyped?, boundary_cross_reporter: untyped?) -> nil
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?

data/sig/rigor/type.rbs

@@ -266,6 +266,10 @@ module Rigor
       def self?.non_numeric_string: () -> Refined
       def self?.literal_string_carrier?: (Type::t refined) -> bool
       def self?.literal_string_compatible?: (Type::t type) -> bool
+      def self?.non_empty_string_compatible?: (Type::t type) -> bool
+      def self?.non_empty_string_difference?: (Type::t diff) -> bool
+      def self?.non_zero_int_compatible?: (Type::t type) -> bool
+      def self?.non_zero_int_difference?: (Type::t diff) -> bool
       def self?.intersection: (*Type::t members) -> Type::t
       def self?.non_empty_lowercase_string: () -> Type::t
       def self?.non_empty_uppercase_string: () -> Type::t

data/sig/rigor.rbs

@@ -12,6 +12,8 @@ module Rigor
     attr_reader baseline_path: String?
 
     def self.load: (?String path) -> Configuration
+    def self.discover: () -> String?
+    def self.load_with_includes: (String path, ?visited: Set[String]) -> Hash[String, untyped]
     def initialize: (?Hash[String, untyped] data) -> void
     def to_h: () -> Hash[String, untyped]
   end