rigortype 0.3.6 → 0.3.8

data/plugins/rigor-dry-monads/lib/rigor/plugin/dry_monads.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+require "rigor/inference/hkt_registry"
+require "rigor/inference/hkt_body_parser"
+
+module Rigor
+  module Plugin
+    # rigor-dry-monads — Tier A plugin for dry-monads Result and Maybe carriers per
+    # [ADR-20](../../../../../docs/adr/20-lightweight-hkt.md) Slice 4.
+    class DryMonads < Rigor::Plugin::Base
+      RESULT_REGISTRATION = Inference::HktRegistry::Registration.new(
+        uri: :"dry_monads::result",
+        arity: 2,
+        variance: %i[out out],
+        bound: Type::Combinator.result_of(Type::Combinator.untyped, Type::Combinator.untyped)
+      )
+
+      MAYBE_REGISTRATION = Inference::HktRegistry::Registration.new(
+        uri: :"dry_monads::maybe",
+        arity: 1,
+        variance: %i[out],
+        bound: Type::Combinator.maybe_of(Type::Combinator.untyped)
+      )
+
+      RESULT_DEFINITION = Inference::HktRegistry.definition_with_body_tree(
+        uri: :"dry_monads::result",
+        params: %i[T E],
+        body_tree: Inference::HktBodyParser.parse("Result[T, E]", params: %i[T E]),
+        source_path: __FILE__,
+        source_line: __LINE__
+      )
+
+      MAYBE_DEFINITION = Inference::HktRegistry.definition_with_body_tree(
+        uri: :"dry_monads::maybe",
+        params: %i[T],
+        body_tree: Inference::HktBodyParser.parse("Maybe[T]", params: %i[T]),
+        source_path: __FILE__,
+        source_line: __LINE__
+      )
+
+      CONSTRUCTOR_METHODS = %i[Success Failure Some None].freeze
+      UNWRAP_METHODS = %i[value! failure value_or].freeze
+
+      manifest(
+        id: "dry-monads",
+        version: "0.1.0",
+        description: "Lightweight HKT support for dry-monads Result and Maybe carriers",
+        hkt_registrations: [RESULT_REGISTRATION, MAYBE_REGISTRATION],
+        hkt_definitions: [RESULT_DEFINITION, MAYBE_DEFINITION]
+      )
+
+      dynamic_return methods: -> { CONSTRUCTOR_METHODS } do |call_node, scope|
+        args = call_node.arguments&.arguments || []
+        case call_node.name
+        when :Success
+          val = args.first ? scope.type_of(args.first) : Type::Combinator.untyped
+          Type::Combinator.result_of(val, Type::Combinator.bot)
+        when :Failure
+          err = args.first ? scope.type_of(args.first) : Type::Combinator.untyped
+          Type::Combinator.result_of(Type::Combinator.bot, err)
+        when :Some
+          val = args.first ? scope.type_of(args.first) : Type::Combinator.untyped
+          Type::Combinator.maybe_of(val)
+        when :None
+          Type::Combinator.maybe_of(Type::Combinator.bot)
+        end
+      end
+
+      dynamic_return receivers: %w[Dry::Monads::Result Dry::Monads::Maybe Result Maybe],
+                     methods: -> { UNWRAP_METHODS } do |call_node, scope|
+        receiver = call_node.receiver
+        next nil if receiver.nil?
+
+        rec_type = scope.type_of(receiver)
+        args = call_node.arguments&.arguments || []
+        case call_node.name
+        when :value!
+          if rec_type.is_a?(Type::Result)
+            rec_type.ok_type
+          elsif rec_type.is_a?(Type::Maybe)
+            rec_type.value_type
+          end
+        when :failure
+          rec_type.err_type if rec_type.is_a?(Type::Result)
+        when :value_or
+          fallback = args.first ? scope.type_of(args.first) : Type::Combinator.untyped
+          if rec_type.is_a?(Type::Result)
+            Type::Combinator.union(rec_type.ok_type, fallback)
+          elsif rec_type.is_a?(Type::Maybe)
+            Type::Combinator.union(rec_type.value_type, fallback)
+          end
+        end
+      end
+    end
+
+    Rigor::Plugin.register(DryMonads)
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Gem entry point for rigor-dry-monads. Required by Rigor's plugin loader when `.rigor.yml` lists
+# `rigor-dry-monads` under `plugins:`.
+require_relative "rigor/plugin/dry_monads"

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+require "rigor-ffi"
+
+module Rigor
+  module Plugin
+    class Ethon < Base
+      manifest(
+        id: "ethon",
+        version: "0.1.0",
+        description: "Models Ethon / Libcurl options, dynamic return types, and multi-loop operations.",
+        signature_paths: ["sig"]
+      )
+
+      # Option catalogue and return types for Easy methods
+      EASY_RETURN_TYPES = {
+        perform: -> { Rigor::Type::Combinator.nominal_of("Integer") },
+        response_code: -> { Rigor::Type::Combinator.nominal_of("Integer") },
+        return_code: -> { Rigor::Type::Combinator.nominal_of("Symbol") },
+        total_time: -> { Rigor::Type::Combinator.nominal_of("Float") },
+        response_body: -> { Rigor::Type::Combinator.nominal_of("String") },
+        response_headers: -> { Rigor::Type::Combinator.nominal_of("String") }
+      }.freeze
+
+      dynamic_return receivers: ["Ethon::Easy"], methods: EASY_RETURN_TYPES.keys do |call_node, _scope|
+        builder = EASY_RETURN_TYPES[call_node.name]
+        builder&.call
+      end
+    end
+  end
+end
+
+Rigor::Plugin.register(Rigor::Plugin::Ethon)

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/ethon"

data/plugins/rigor-ethon/sig/ethon.rbs

@@ -0,0 +1,27 @@
+module Ethon
+  class Easy
+    def initialize: (?Hash[Symbol, untyped] options) -> void
+    def url=: (String url) -> String
+    def url: () -> String?
+    def perform: () -> Integer
+    def response_code: () -> Integer
+    def return_code: () -> Symbol
+    def total_time: () -> Float
+    def response_body: () -> String
+    def response_headers: () -> String
+    def handle: () -> FFI::Pointer
+  end
+
+  class Multi
+    def initialize: (?Hash[Symbol, untyped] options) -> void
+    def add: (Easy easy) -> void
+    def perform: () -> void
+  end
+
+  module Curl
+    def self.easy_init: () -> FFI::Pointer
+    def self.easy_cleanup: (FFI::Pointer handle) -> void
+    def self.easy_perform: (FFI::Pointer handle) -> Integer
+    def self.set_option: (Symbol option, untyped value, FFI::Pointer handle) -> Integer
+  end
+end

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -51,9 +51,10 @@ module Rigor
         def ruby_files_under(roots)
           roots.flat_map do |root|
             absolute = File.expand_path(root)
-            if File.file?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            if @io_boundary.file?(absolute)
               [absolute]
-            elsif File.directory?(absolute)
+            elsif @io_boundary.directory?(absolute)
               Dir.glob(File.join(absolute, "**", "*.rb"))
             else
               []

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/analyzer.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      module Analyzer
+        module_function
+
+        def extract_symbol(node)
+          case node
+          when Prism::SymbolNode
+            node.unescaped.to_sym
+          when Prism::StringNode
+            node.unescaped.to_sym
+          when Prism::CallNode
+            extract_symbol(node.receiver) if node.name == :to_sym && node.receiver
+          end
+        end
+
+        def extract_type_symbol(node)
+          case node
+          when Prism::SymbolNode
+            node.unescaped.to_sym
+          when Prism::StringNode
+            node.unescaped.to_sym
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
+            node.slice.to_sym
+          when Prism::CallNode
+            # e.g. MyStruct.ptr or MyStruct.by_ref
+            node.slice.to_sym
+          end
+        end
+
+        # Universal binding extractor for attach_function, sodium_function, etc.
+        def extract_function_binding(call_node, method_name:, module_name: nil, default_return: :void)
+          return nil unless call_node.is_a?(Prism::CallNode) && call_node.name == method_name
+
+          all_args = call_node.arguments&.arguments || []
+          return nil if all_args.empty?
+
+          # Strip trailing keyword options hash if present
+          pos_args = all_args.grep_v(Prism::KeywordHashNode)
+          return nil if pos_args.empty?
+
+          ruby_name = extract_symbol(pos_args[0])
+          return nil if ruby_name.nil?
+
+          if pos_args.size >= 4
+            # Form B: ruby_name, c_name, arg_types, return_type
+            c_name = extract_symbol(pos_args[1]) || ruby_name
+            args_node = pos_args[2]
+            ret_node = pos_args[3]
+          elsif pos_args.size == 3
+            # Form A: ruby_name, arg_types, return_type
+            c_name = ruby_name
+            args_node = pos_args[1]
+            ret_node = pos_args[2]
+          elsif pos_args.size == 2
+            c_name = ruby_name
+            args_node = nil
+            ret_node = pos_args[1]
+          else
+            return nil
+          end
+
+          arg_types = []
+          if args_node.is_a?(Prism::ArrayNode)
+            arg_types = (args_node.elements || []).map { |elem| extract_type_symbol(elem) }.compact
+          elsif args_node.is_a?(Prism::ConstantReadNode) || args_node.is_a?(Prism::ConstantPathNode)
+            arg_types = [args_node.slice.to_sym]
+          end
+
+          return_type = ret_node ? (extract_type_symbol(ret_node) || default_return) : default_return
+
+          AttachFunctionFact.new(
+            ruby_name: ruby_name,
+            c_name: c_name,
+            arg_types: arg_types,
+            return_type: return_type,
+            node: call_node,
+            receiver_name: module_name
+          )
+        end
+
+        def extract_attach_function(call_node, module_name: nil)
+          extract_function_binding(call_node, method_name: :attach_function, module_name: module_name, default_return: :void)
+        end
+
+        def ffx_diagnostics_for_call(call_node, path:, target:)
+          return [] unless target == :ffx && call_node.is_a?(Prism::CallNode)
+
+          diagnostics = []
+
+          case call_node.name
+          when :callback
+            diagnostics << Rigor::Analysis::Diagnostic.new(
+              path: path,
+              line: call_node.location.start_line,
+              column: call_node.location.start_column + 1,
+              rule: "ffx.unsupported-callback",
+              message: "callback declarations are not supported by ffx (C extensions use native function pointers)",
+              severity: :error
+            )
+          when :typedef
+            diagnostics << Rigor::Analysis::Diagnostic.new(
+              path: path,
+              line: call_node.location.start_line,
+              column: call_node.location.start_column + 1,
+              rule: "ffx.unsupported-typedef",
+              message: "typedef declarations are not supported by ffx",
+              severity: :error
+            )
+          when :enum, :bitmask
+            diagnostics << Rigor::Analysis::Diagnostic.new(
+              path: path,
+              line: call_node.location.start_line,
+              column: call_node.location.start_column + 1,
+              rule: "ffx.unsupported-enum",
+              message: "#{call_node.name} declarations are not supported by ffx",
+              severity: :error
+            )
+          when :attach_function
+            args = call_node.arguments&.arguments || []
+            pos_args = args.grep_v(Prism::KeywordHashNode)
+
+            args_node = pos_args.size >= 4 ? pos_args[2] : pos_args[1]
+            ret_node = pos_args.size >= 4 ? pos_args[3] : pos_args[2]
+
+            if args_node.is_a?(Prism::ArrayNode)
+              args_node.elements.each do |elem|
+                type_sym = extract_type_symbol(elem)
+                if type_sym == :varargs
+                  diagnostics << Rigor::Analysis::Diagnostic.new(
+                    path: path,
+                    line: elem.location.start_line,
+                    column: elem.location.start_column + 1,
+                    rule: "ffx.unsupported-varargs",
+                    message: "varargs are not supported by ffx",
+                    severity: :error
+                  )
+                elsif type_sym && !Types::FFX_PRIMITIVE_TYPES.include?(type_sym)
+                  diagnostics << Rigor::Analysis::Diagnostic.new(
+                    path: path,
+                    line: elem.location.start_line,
+                    column: elem.location.start_column + 1,
+                    rule: "ffx.unsupported-type",
+                    message: "type :#{type_sym} is not supported by ffx (expected one of 25 primitive types)",
+                    severity: :error
+                  )
+                end
+              end
+            end
+
+            if ret_node
+              ret_sym = extract_type_symbol(ret_node)
+              if ret_sym && !Types::FFX_PRIMITIVE_TYPES.include?(ret_sym)
+                diagnostics << Rigor::Analysis::Diagnostic.new(
+                  path: path,
+                  line: ret_node.location.start_line,
+                  column: ret_node.location.start_column + 1,
+                  rule: "ffx.unsupported-type",
+                  message: "return type :#{ret_sym} is not supported by ffx (expected one of 25 primitive types)",
+                  severity: :error
+                )
+              end
+            end
+          end
+
+          diagnostics
+        end
+
+        def ffx_diagnostics_for_class(class_node, path:, target:)
+          return [] unless target == :ffx && class_node.is_a?(Prism::ClassNode)
+
+          superclass_name = class_node.superclass&.slice
+          return [] unless superclass_name
+
+          if ["FFI::Struct", "::FFI::Struct", "FFI::Union", "::FFI::Union", "FFI::ManagedStruct", "::FFI::ManagedStruct"].include?(superclass_name)
+            [
+              Rigor::Analysis::Diagnostic.new(
+                path: path,
+                line: class_node.location.start_line,
+                column: class_node.location.start_column + 1,
+                rule: "ffx.unsupported-struct",
+                message: "FFI::Struct and FFI::Union are not supported by ffx",
+                severity: :error
+              )
+            ]
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/binding_recognizer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      # Fact yielded by a registered BindingRecognizer or emitted from literal attach_function.
+      AttachFunctionFact = Data.define(
+        :ruby_name,
+        :c_name,
+        :arg_types,
+        :return_type,
+        :blocking,
+        :node,
+        :receiver_name
+      ) do
+        def initialize(
+          ruby_name:,
+          c_name: ruby_name,
+          arg_types: [],
+          return_type: :void,
+          blocking: false,
+          node: nil,
+          receiver_name: nil
+        )
+          super(
+            ruby_name: ruby_name.to_sym,
+            c_name: (c_name || ruby_name).to_sym,
+            arg_types: Array(arg_types),
+            return_type: return_type,
+            blocking: blocking,
+            node: node,
+            receiver_name: receiver_name&.to_s
+          )
+        end
+      end
+
+      # Extension point for sub-plugins to register custom DSL recognizers (WD2).
+      class BindingRecognizer
+        attr_reader :name, :block
+
+        def initialize(name, &block)
+          @name = name.to_sym
+          @block = block
+        end
+
+        def recognize(node, scope)
+          Array(@block.call(node, scope))
+        rescue StandardError
+          []
+        end
+      end
+
+      class << self
+        def binding_recognizers
+          @binding_recognizers ||= []
+        end
+
+        def register_binding_recognizer(name, &)
+          binding_recognizers << BindingRecognizer.new(name, &)
+        end
+      end
+    end
+
+    class Base
+      def self.ffi_binding_recognizers
+        @ffi_binding_recognizers ||= []
+      end
+
+      def self.ffi_binding_recognizer(name, &)
+        ffi_binding_recognizers << Rigor::Plugin::FFI::BindingRecognizer.new(name, &)
+        Rigor::Plugin::FFI.register_binding_recognizer(name, &)
+      end
+    end
+  end
+end

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/catalog.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      class FFICatalog
+        attr_reader :functions,
+                    :functions_by_receiver,
+                    :libraries,
+                    :structs,
+                    :typedefs,
+                    :enums,
+                    :callbacks,
+                    :function_method_names,
+                    :struct_field_names,
+                    :struct_names,
+                    :all_receiver_names,
+                    :all_method_names
+
+        def initialize(functions: {}, functions_by_receiver: {}, libraries: Set.new, structs: {}, typedefs: {}, enums: {}, callbacks: {})
+          @functions = functions
+          @functions_by_receiver = functions_by_receiver
+          @libraries = libraries
+          @structs = structs
+          @typedefs = typedefs
+          @enums = enums
+          @callbacks = callbacks
+
+          @function_method_names = Set.new(functions.keys.map(&:to_sym)).freeze
+
+          field_names = Set.new
+          structs.each_value do |fields|
+            fields.each_key do |f|
+              field_names << f.to_sym
+            end
+          end
+          field_names << :[]
+          field_names << :[]=
+          @struct_field_names = field_names.freeze
+          @struct_names = structs.keys.freeze
+
+          @all_receiver_names = (libraries.to_a + structs.keys).freeze
+          @all_method_names = (@function_method_names + @struct_field_names).freeze
+        end
+
+        def function_for(receiver_name, method_name)
+          if receiver_name
+            scoped = @functions_by_receiver[[receiver_name.to_s, method_name.to_sym]]
+            return scoped if scoped
+          end
+
+          # Fallback if receiver matches any registered library
+          return unless receiver_name.nil? || @libraries.include?(receiver_name.to_s)
+
+          @functions[method_name.to_sym]&.first
+        end
+
+        def struct_fields(struct_name)
+          @structs[struct_name.to_s]
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/discoverer.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      class Discoverer
+        def self.discover(root:)
+          new(root: root).discover
+        end
+
+        def initialize(root:)
+          @root = root
+        end
+
+        def discover
+          functions = {}
+          functions_by_receiver = {}
+          libraries = Set.new
+          structs = {}
+          typedefs = {}
+          enums = {}
+          callbacks = {}
+
+          ruby_files.each do |file_path|
+            parse_result = Prism.parse_file(file_path)
+            next unless parse_result.value
+
+            walk_tree(parse_result.value, nil) do |node, mod_name|
+              case node
+              when Prism::CallNode
+                handle_call(
+                  node,
+                  mod_name,
+                  functions,
+                  functions_by_receiver,
+                  libraries,
+                  structs,
+                  typedefs,
+                  enums,
+                  callbacks
+                )
+              when Prism::ClassNode
+                handle_class(node, mod_name, structs)
+              end
+            end
+          end
+
+          FFICatalog.new(
+            functions: functions,
+            functions_by_receiver: functions_by_receiver,
+            libraries: libraries,
+            structs: structs,
+            typedefs: typedefs,
+            enums: enums,
+            callbacks: callbacks
+          )
+        end
+
+        private
+
+        def ruby_files
+          return [] unless @root && File.directory?(@root)
+
+          Dir.glob(File.join(@root, "**", "*.rb")).reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
+        end
+
+        def walk_tree(node, current_module, &)
+          return unless node
+
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            name = node.constant_path.slice
+            full_name = current_module ? "#{current_module}::#{name}" : name
+            yield node, full_name
+            node.body&.child_nodes&.each { |child| walk_tree(child, full_name, &) }
+          else
+            yield node, current_module
+            node.child_nodes.each { |child| walk_tree(child, current_module, &) }
+          end
+        end
+
+        def handle_call(node, mod_name, functions, functions_by_receiver, libraries, structs, typedefs, enums, callbacks)
+          case node.name
+          when :extend
+            arg = node.arguments&.arguments&.first
+            if arg && ["FFI::Library", "::FFI::Library", "FFX::Library", "::FFX::Library"].include?(arg.slice) && mod_name
+              libraries << mod_name
+            end
+          when :attach_function
+            fact = Analyzer.extract_attach_function(node, module_name: mod_name)
+            if fact
+              (functions[fact.ruby_name] ||= []) << fact
+              if mod_name
+                libraries << mod_name
+                functions_by_receiver[[mod_name, fact.ruby_name]] = fact
+              end
+            end
+          when :callback
+            # Issue 4 fix: extract callback definitions
+            args = node.arguments&.arguments || []
+            if args.size >= 3
+              cb_name = Analyzer.extract_symbol(args[0])
+              cb_params = []
+              if args[1].is_a?(Prism::ArrayNode)
+                cb_params = (args[1].elements || []).map { |elem| Analyzer.extract_type_symbol(elem) }.compact
+              end
+              cb_ret = Analyzer.extract_type_symbol(args[2]) || :void
+              if cb_name
+                callbacks[cb_name] = { params: cb_params, return_type: cb_ret }
+                typedefs[cb_name] = :pointer
+                libraries << mod_name if mod_name
+              end
+            end
+          when :typedef
+            args = node.arguments&.arguments || []
+            if args.size >= 2
+              old_t = Analyzer.extract_type_symbol(args[0])
+              new_t = Analyzer.extract_symbol(args[1])
+              typedefs[new_t] = old_t if old_t && new_t
+              libraries << mod_name if mod_name
+            end
+          when :enum, :bitmask
+            args = node.arguments&.arguments || []
+            if args.size >= 2
+              enum_name = Analyzer.extract_symbol(args[0])
+              enums[enum_name] = true if enum_name
+              libraries << mod_name if mod_name
+            end
+          when :layout
+            # Struct layout definition
+            if mod_name
+              fields = structs[mod_name] ||= {}
+              args = node.arguments&.arguments || []
+              i = 0
+              while i < args.size
+                f_name = Analyzer.extract_symbol(args[i])
+                f_type = Analyzer.extract_type_symbol(args[i + 1])
+                fields[f_name] = f_type if f_name && f_type
+                i += 2
+              end
+            end
+          else
+            # Issue 5 fix: pass mod_name to sub-plugin recognizers
+            FFI.binding_recognizers.each do |recognizer|
+              facts = recognizer.recognize(node, mod_name)
+              Array(facts).each do |fact|
+                next unless fact.is_a?(AttachFunctionFact)
+
+                (functions[fact.ruby_name] ||= []) << fact
+                rec = fact.receiver_name || mod_name
+                if rec
+                  libraries << rec
+                  functions_by_receiver[[rec, fact.ruby_name]] = fact
+                end
+              end
+            end
+          end
+        end
+
+        def handle_class(node, mod_name, structs)
+          superclass_name = node.superclass&.slice
+          return unless superclass_name
+
+          return unless ["FFI::Struct", "::FFI::Struct", "FFI::Union", "::FFI::Union"].include?(superclass_name)
+
+          structs[mod_name] ||= {} if mod_name
+        end
+      end
+    end
+  end
+end