rigortype 0.3.6 → 0.3.8

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      module TargetDetector
+        module_function
+
+        # Detects whether the project targets ffx or the classic ffi gem per WD6.
+        def detect(root:, config: {})
+          explicit = config["target"] || config[:target]
+          return explicit.to_sym if explicit && explicit != "auto"
+
+          return :ffx if extconf_uses_ffx?(root)
+          return :ffx if lockfile_has_ffx?(root)
+
+          :ffi
+        end
+
+        def extconf_uses_ffx?(root)
+          return false if root.nil?
+
+          Dir.glob(File.join(root.to_s, "ext/**/extconf.rb")).any? do |extconf|
+            File.read(extconf).include?("FFX.create_makefile")
+          rescue SystemCallError
+            false
+          end
+        end
+
+        def lockfile_has_ffx?(root)
+          return false if root.nil?
+
+          lockfile = File.join(root.to_s, "Gemfile.lock")
+          return false unless File.file?(lockfile)
+
+          File.foreach(lockfile) do |line|
+            return true if line =~ /^\s{4}ffx\s/
+          end
+          false
+        rescue SystemCallError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      module Types
+        # The 25 primitive type symbols supported by ffx and classic FFI
+        FFX_PRIMITIVE_TYPES = %i[
+          void
+          int uint short ushort long ulong
+          int8 int16 int32 int64
+          uint8 uint16 uint32 uint64
+          long_long ulong_long
+          size_t
+          float double
+          bool
+          char uchar
+          string
+          pointer
+        ].to_set.freeze
+
+        # Regex anchor must match end of string \z
+        NOMINAL_OPAQUE_REGEX = Regexp.new("(_ptr|_handle|Ptr|Handle)\\z")
+
+        BOOL_TYPE = Rigor::Type::Combinator.union(
+          Rigor::Type::Combinator.constant_of(true),
+          Rigor::Type::Combinator.constant_of(false)
+        ).freeze
+
+        NIL_TYPE = Rigor::Type::Combinator.constant_of(nil)
+
+        module_function
+
+        def nominal_opaque_pointer?(alias_name, exceptions: [])
+          sym_str = alias_name.to_s
+          return false if Array(exceptions).map(&:to_s).include?(sym_str)
+
+          NOMINAL_OPAQUE_REGEX.match?(sym_str)
+        end
+
+        def camelize(name)
+          name.to_s.split("_").map(&:capitalize).join
+        end
+
+        def return_type_for(type_sym, target: :ffi, module_name: nil, exceptions: [], typedefs: {}, callbacks: {})
+          sym = type_sym.is_a?(Symbol) ? type_sym : type_sym.to_s.to_sym
+
+          # Check if symbol is a defined callback
+          if callbacks.key?(sym)
+            return target == :ffx ? Rigor::Type::Combinator.nominal_of("Integer") : Rigor::Type::Combinator.nominal_of("FFI::Function")
+          end
+
+          if typedefs.key?(sym)
+            underlying = typedefs[sym]
+            if underlying == :pointer && nominal_opaque_pointer?(sym, exceptions: exceptions)
+              nominal = camelize(sym)
+              nominal = "#{module_name}::#{nominal}" if module_name && !module_name.empty?
+              return Rigor::Type::Combinator.nominal_of(nominal)
+            end
+            sym = underlying
+          end
+
+          case sym
+          when :void
+            NIL_TYPE
+          when :int, :uint, :short, :ushort, :long, :ulong,
+               :int8, :int16, :int32, :int64,
+               :uint8, :uint16, :uint32, :uint64,
+               :long_long, :ulong_long, :size_t, :char, :uchar
+            Rigor::Type::Combinator.nominal_of("Integer")
+          when :float, :double
+            Rigor::Type::Combinator.nominal_of("Float")
+          when :bool
+            BOOL_TYPE
+          when :string
+            Rigor::Type::Combinator.nominal_of("String")
+          when :pointer
+            if target == :ffx
+              Rigor::Type::Combinator.nominal_of("Integer")
+            else
+              Rigor::Type::Combinator.nominal_of("FFI::Pointer")
+            end
+          else
+            if nominal_opaque_pointer?(sym, exceptions: exceptions)
+              nominal = camelize(sym)
+              nominal = "#{module_name}::#{nominal}" if module_name && !module_name.empty?
+              Rigor::Type::Combinator.nominal_of(nominal)
+            else
+              Rigor::Type::Combinator.top
+            end
+          end
+        end
+
+        # Universal parameter widening per WD7
+        def param_type_for(type_sym, target: :ffi, module_name: nil, exceptions: [], typedefs: {}, callbacks: {})
+          sym = type_sym.is_a?(Symbol) ? type_sym : type_sym.to_s.to_sym
+
+          if callbacks.key?(sym)
+            return Rigor::Type::Combinator.union(
+              Rigor::Type::Combinator.nominal_of("Proc"),
+              Rigor::Type::Combinator.nominal_of("Method"),
+              Rigor::Type::Combinator.nominal_of("FFI::Pointer"),
+              Rigor::Type::Combinator.nominal_of("FFI::Function"),
+              NIL_TYPE
+            )
+          end
+
+          if typedefs.key?(sym)
+            underlying = typedefs[sym]
+            if underlying == :pointer && nominal_opaque_pointer?(sym, exceptions: exceptions)
+              nominal = camelize(sym)
+              nominal = "#{module_name}::#{nominal}" if module_name && !module_name.empty?
+              return Rigor::Type::Combinator.union(
+                Rigor::Type::Combinator.nominal_of(nominal),
+                Rigor::Type::Combinator.nominal_of("FFI::Pointer"),
+                NIL_TYPE
+              )
+            end
+            sym = underlying
+          end
+
+          case sym
+          when :pointer
+            if target == :ffx
+              Rigor::Type::Combinator.union(
+                Rigor::Type::Combinator.nominal_of("Integer"),
+                NIL_TYPE
+              )
+            else
+              Rigor::Type::Combinator.union(
+                Rigor::Type::Combinator.nominal_of("FFI::Pointer"),
+                Rigor::Type::Combinator.nominal_of("FFI::MemoryPointer"),
+                Rigor::Type::Combinator.nominal_of("FFI::AutoPointer"),
+                Rigor::Type::Combinator.nominal_of("FFI::Buffer"),
+                Rigor::Type::Combinator.nominal_of("Integer"),
+                Rigor::Type::Combinator.nominal_of("String"),
+                NIL_TYPE
+              )
+            end
+          when :int, :uint, :short, :ushort, :long, :ulong,
+               :int8, :int16, :int32, :int64,
+               :uint8, :uint16, :uint32, :uint64,
+               :long_long, :ulong_long, :size_t, :char, :uchar
+            Rigor::Type::Combinator.nominal_of("Integer")
+          when :float, :double
+            Rigor::Type::Combinator.union(
+              Rigor::Type::Combinator.nominal_of("Float"),
+              Rigor::Type::Combinator.nominal_of("Integer")
+            )
+          when :bool
+            BOOL_TYPE
+          when :string
+            Rigor::Type::Combinator.nominal_of("String")
+          else
+            Rigor::Type::Combinator.top
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+require_relative "ffi/binding_recognizer"
+require_relative "ffi/types"
+require_relative "ffi/target_detector"
+require_relative "ffi/analyzer"
+require_relative "ffi/catalog"
+require_relative "ffi/discoverer"
+
+module Rigor
+  module Plugin
+    class FFI < Base
+      manifest(
+        id: "ffi",
+        version: "0.1.0",
+        description: "Models FFI library bindings, struct layouts, callbacks, carrier types, and ffx target compatibility.",
+        signature_paths: ["sig"]
+      )
+
+      producer :ffi_catalog do
+        root = config["root"] || Dir.pwd
+        Discoverer.discover(root: root)
+      end
+
+      # Dynamic return rule for attached FFI functions
+      # Gated on known FFI library receivers and attached function names
+      dynamic_return receivers: -> { producer_value(:ffi_catalog)&.libraries || [] },
+                     methods: -> { producer_value(:ffi_catalog)&.function_method_names || [] } do |call_node, scope|
+        catalog = producer_value(:ffi_catalog)
+        next nil if catalog.nil?
+
+        receiver_type = call_node.receiver ? scope&.type_of(call_node.receiver) : scope&.self_type
+        receiver_class = case receiver_type
+                         when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
+                         end
+        next nil if receiver_class.nil?
+
+        fact = catalog.function_for(receiver_class, call_node.name)
+        next nil if fact.nil?
+
+        Types.return_type_for(
+          fact.return_type,
+          target: @target || :ffi,
+          module_name: fact.receiver_name,
+          exceptions: @exceptions || [],
+          typedefs: catalog.typedefs,
+          callbacks: catalog.callbacks
+        )
+      end
+
+      # Dynamic return rule for FFI struct field accessors
+      # Gated on known FFI struct class names and field names
+      dynamic_return receivers: -> { producer_value(:ffi_catalog)&.struct_names || [] },
+                     methods: -> { producer_value(:ffi_catalog)&.struct_field_names || [] } do |call_node, scope|
+        catalog = producer_value(:ffi_catalog)
+        next nil if catalog.nil?
+
+        receiver_type = call_node.receiver ? scope&.type_of(call_node.receiver) : scope&.self_type
+        receiver_class = case receiver_type
+                         when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
+                         end
+        next nil if receiver_class.nil?
+
+        fields = catalog.struct_fields(receiver_class)
+        next nil if fields.nil?
+
+        if call_node.name == :[]
+          arg = call_node.arguments&.arguments&.first
+          field_sym = Analyzer.extract_symbol(arg)
+          field_type = fields[field_sym]
+          next nil if field_type.nil?
+
+          Types.return_type_for(
+            field_type,
+            target: @target || :ffi,
+            module_name: receiver_class,
+            exceptions: @exceptions || [],
+            typedefs: catalog.typedefs,
+            callbacks: catalog.callbacks
+          )
+        elsif call_node.name.to_s.end_with?("=")
+          # For both .id = val and [:id] = val, the assigned value is the LAST argument
+          val_node = call_node.arguments&.arguments&.last
+          val_node ? scope&.type_of(val_node) : Rigor::Type::Combinator.top
+        elsif (field_type = fields[call_node.name])
+          Types.return_type_for(
+            field_type,
+            target: @target || :ffi,
+            module_name: receiver_class,
+            exceptions: @exceptions || [],
+            typedefs: catalog.typedefs,
+            callbacks: catalog.callbacks
+          )
+        end
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        Analyzer.ffx_diagnostics_for_call(node, path: path, target: @target || :ffi)
+      end
+
+      node_rule Prism::ClassNode do |node, _scope, path|
+        Analyzer.ffx_diagnostics_for_class(node, path: path, target: @target || :ffi)
+      end
+
+      def init(_services)
+        root = config["root"] || Dir.pwd
+        @target = TargetDetector.detect(root: root, config: config)
+        @exceptions = config["exceptions"] || []
+      end
+
+      def prepare(_services)
+        root = config["root"] || Dir.pwd
+        @target = TargetDetector.detect(root: root, config: config)
+        @exceptions = config["exceptions"] || []
+      end
+    end
+  end
+end
+
+Rigor::Plugin.register(Rigor::Plugin::FFI)

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

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

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

@@ -0,0 +1,67 @@
+module FFI
+  class Pointer
+    NULL: Pointer
+    def self.new: (Integer address) -> instance
+    def null?: () -> bool
+    def address: () -> Integer
+    def +: (Integer offset) -> Pointer
+    def read_string: (?Integer? length) -> String
+    def read_bytes: (Integer length) -> String
+    def write_string: (String str, ?Integer? length) -> Pointer
+    def write_bytes: (String str, ?Integer offset, ?Integer? length) -> Pointer
+  end
+
+  class MemoryPointer < Pointer
+    def self.new: (Symbol | Integer type, ?Integer count, ?bool clear) -> instance
+    def self.from_string: (String s) -> instance
+  end
+
+  class AutoPointer < Pointer
+    def self.new: (Pointer ptr, ?(Method | Proc | Symbol)? releaser) -> instance
+    def free: () -> void
+    def autorelease=: (bool val) -> bool
+  end
+
+  class Buffer < Pointer
+    def self.new: (Symbol | Integer type, ?Integer size, ?Integer count) -> instance
+  end
+
+  class Function < Pointer
+    def self.new: (Symbol return_type, Array[Symbol] param_types, ?Hash[Symbol, untyped] options) ?{ (*untyped) -> untyped } -> instance
+    def call: (*untyped) -> untyped
+  end
+
+  class Struct
+    def self.layout: (*untyped) -> void
+    def self.by_ref: () -> untyped
+    def self.ptr: () -> untyped
+    def self.size: () -> Integer
+    def pointer: () -> Pointer
+    def to_ptr: () -> Pointer
+    def null?: () -> bool
+    def []: (Symbol | String name) -> untyped
+    def []=: (Symbol | String name, untyped value) -> untyped
+  end
+
+  class Union < Struct
+  end
+
+  class ManagedStruct < Struct
+  end
+
+  module Library
+    def ffi_lib: (*(String | Array[String]) libs) -> untyped
+    def attach_function: (*untyped) -> untyped
+    def callback: (Symbol name, Array[Symbol] param_types, Symbol return_type) -> untyped
+    def typedef: (Symbol | String old_type, Symbol | String new_type) -> untyped
+    def enum: (*untyped) -> untyped
+    def bitmask: (*untyped) -> untyped
+  end
+end
+
+module FFX
+  module Library
+    def ffi_lib: (*(String | Array[String]) libs) -> untyped
+    def attach_function: (*untyped) -> untyped
+  end
+end

data/plugins/rigor-ffi-rzmq/lib/rigor/plugin/ffi_rzmq.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+require "rigor-ffi"
+
+module Rigor
+  module Plugin
+    class FFIRZMQ < Base
+      manifest(
+        id: "ffi-rzmq",
+        version: "0.1.0",
+        description: "Models ffi-rzmq / LibZMQ wrappers, socket operations, and cross-gem bindings.",
+        signature_paths: ["sig"]
+      )
+    end
+  end
+end
+
+Rigor::Plugin.register(Rigor::Plugin::FFIRZMQ)

data/plugins/rigor-ffi-rzmq/lib/rigor-ffi-rzmq.rb

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

data/plugins/rigor-ffi-rzmq/sig/ffi_rzmq.rbs

@@ -0,0 +1,29 @@
+module ZMQ
+  REQ: Integer
+  REP: Integer
+  PUB: Integer
+  SUB: Integer
+  DONTWAIT: Integer
+  SNDMORE: Integer
+
+  class Context
+    def self.new: (?Integer io_threads) -> instance
+    def socket: (Integer type) -> Socket?
+    def terminate: () -> Integer
+  end
+
+  class Socket
+    def connect: (String endpoint) -> Integer
+    def bind: (String endpoint) -> Integer
+    def send_string: (String message, ?Integer flags) -> Integer
+    def recv_string: (String message, ?Integer flags) -> Integer
+    def close: () -> Integer
+  end
+end
+
+module LibZMQ
+  def self.zmq_ctx_new: () -> FFI::Pointer
+  def self.zmq_socket: (FFI::Pointer context, Integer type) -> FFI::Pointer
+  def self.zmq_close: (FFI::Pointer socket) -> Integer
+  def self.zmq_msg_init: (FFI::Pointer msg) -> Integer
+end

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

@@ -254,7 +254,7 @@ module Rigor
         # 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
+        # rubocop:disable-next Naming/PredicateMethod  -- extractor returns the literal required value
         def extract_required_flag(args)
           kwargs = args.last
           return false unless kwargs.is_a?(Prism::KeywordHashNode)
@@ -270,7 +270,6 @@ module Rigor
           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
@@ -331,7 +330,7 @@ module Rigor
 
         # 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
+        # rubocop:disable-next Naming/PredicateMethod  -- extractor returns the literal nullability value
         def extract_nullability(args)
           kwargs = args.last
           return true unless kwargs.is_a?(Prism::KeywordHashNode)
@@ -347,7 +346,6 @@ module Rigor
           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"]`).

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/authorization_scan.rb

@@ -69,7 +69,8 @@ module Rigor
         def ruby_files_under(roots)
           roots.flat_map do |root|
             absolute = File.expand_path(root)
-            next [] unless File.directory?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
 
             Dir.glob(File.join(absolute, "**", "*.rb"))
           end

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_discoverer.rb

@@ -58,7 +58,8 @@ module Rigor
         def ruby_files_under(roots)
           roots.flat_map do |root|
             absolute = File.expand_path(root)
-            next [] unless File.directory?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
 
             Dir.glob(File.join(absolute, "**", "*.rb"))
           end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb

@@ -88,7 +88,8 @@ module Rigor
         def locale_files
           @search_paths.flat_map do |root|
             absolute = File.expand_path(root)
-            next [] unless File.directory?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
 
             Dir.glob(File.join(absolute, "**", "*.{yml,yaml}"))
           end.sort

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -177,7 +177,8 @@ module Rigor
       def view_files
         @view_search_paths.flat_map do |root|
           absolute = File.expand_path(root)
-          next [] unless File.directory?(absolute)
+          # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+          next [] unless io_boundary.directory?(absolute)
 
           Dir.glob(File.join(absolute, "**", "*.{erb,haml,slim}"))
         end.sort

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -164,7 +164,8 @@ module Rigor
       def each_ruby_file(dirs, &)
         dirs.each do |dir|
           absolute = File.expand_path(dir)
-          next unless File.directory?(absolute)
+          # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+          next unless io_boundary.directory?(absolute)
 
           Dir.glob(File.join(absolute, "**", "*.rb")).each(&)
         end