@ai-ecoverse/wasix-ruby 3.4.11-20 → 3.4.11-21

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/test/setup.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "rbs"
+require "rbs/test"
+require "optparse"
+require "shellwords"
+require "rbs/cli"
+
+include RBS::Test::SetupHelper
+
+logger = Logger.new(STDERR)
+
+begin
+  opts = Shellwords.shellsplit(ENV["RBS_TEST_OPT"] || "-I sig")
+  filter = ENV.fetch('RBS_TEST_TARGET', "").split(',').map! { |e| e.strip }
+  skips = (ENV['RBS_TEST_SKIP'] || '').split(',').map! { |e| e.strip }
+  RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
+  logger.level = RBS.logger_level
+  sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
+  double_class = to_double_class(ENV['RBS_TEST_DOUBLE_SUITE'])
+  unchecked_classes = (ENV['RBS_TEST_UNCHECKED_CLASSES'] || '').split(',').map! { |unchecked_class| unchecked_class.strip }.push(*double_class)
+rescue InvalidSampleSizeError => exception
+  RBS.logger.error exception.message
+  exit 1
+end
+
+if filter.empty?
+  STDERR.puts "rbs/test/setup handles the following environment variables:"
+  STDERR.puts "  [REQUIRED] RBS_TEST_TARGET: test target class name, `Foo::Bar,Foo::Baz` for each class or `Foo::*` for all classes under `Foo`"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_SKIP: skip testing classes"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_OPT: options for signatures (`-r` for libraries or `-I` for signatures)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_LOGLEVEL: one of debug|info|warn|error|fatal (defaults to info)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_SAMPLE_SIZE: sets the amount of values in a collection to be type-checked (Set to `ALL` to type check all the values)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_DOUBLE_SUITE: sets the double suite in use (currently supported: minitest | rspec)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_UNCHECKED_CLASSES: sets the classes that would not be checked"
+  exit 1
+end
+
+options = RBS::CLI::LibraryOptions.new()
+
+OptionParser.new do |opts|
+  options.setup_library_options(opts)
+end.parse!(opts)
+
+loader = options.loader
+env = RBS::Environment.from_loader(loader).resolve_type_names
+
+def match(filter, name)
+  if filter.end_with?("*")
+    size = filter.size
+    name.start_with?(filter[0, size - 1]) || name == filter[0, size-3]
+  else
+    filter == name
+  end
+end
+
+def to_absolute_typename(type_name)
+  RBS::Factory.new().type_name(type_name).absolute!
+end
+
+tester = RBS::Test::Tester.new(env: env)
+
+module_name = Module.instance_method(:name)
+
+TracePoint.trace :end do |tp|
+  class_name = module_name.bind(tp.self).call&.yield_self {|name| to_absolute_typename name }
+
+  if class_name
+    if filter.any? {|f| match(to_absolute_typename(f).to_s, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
+      if env.module_name?(class_name)
+        logger.info "Setting up hooks for #{class_name}"
+        tester.install!(tp.self, sample_size: sample_size, unchecked_classes: unchecked_classes)
+      end
+    end
+  end
+end
+
+at_exit do
+  if $!.nil? || $!.is_a?(SystemExit) && $!.success?
+    if tester.targets.empty?
+      logger.debug { "No type checker was installed!" }
+    end
+  end
+end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/test/setup_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module SetupHelper
+      class InvalidSampleSizeError < StandardError
+        attr_reader :string
+
+        def initialize(string)
+          @string = string
+          super("Sample size should be a positive integer: `#{string}`")
+        end
+      end
+
+      DEFAULT_SAMPLE_SIZE = 100
+
+      def get_sample_size(string)
+        case string
+        when ""
+          DEFAULT_SAMPLE_SIZE
+        when 'ALL'
+          nil
+        else
+          int_size = string.to_i
+          raise InvalidSampleSizeError.new(string) unless int_size.positive?
+          int_size
+        end
+      end
+
+      def to_double_class(double_suite)
+        return nil unless double_suite
+
+        case double_suite.downcase.strip
+        when 'rspec'
+          [
+            '::RSpec::Mocks::Double',
+            '::RSpec::Mocks::InstanceVerifyingDouble',
+            '::RSpec::Mocks::ObjectVerifyingDouble',
+            '::RSpec::Mocks::ClassVerifyingDouble',
+          ]
+        when 'minitest'
+          ['::Minitest::Mock']
+        else
+          RBS.logger.warn "Unknown test suite - defaults to nil"
+          nil
+        end
+      end
+    end
+  end
+end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/test/tester.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    class Tester
+      attr_reader :env
+      attr_reader :targets
+      attr_reader :instance_testers
+      attr_reader :singleton_testers
+
+      def initialize(env:)
+        @env = env
+        @targets = []
+        @instance_testers = {}
+        @singleton_testers = {}
+      end
+
+      def factory
+        @factory ||= Factory.new
+      end
+
+      def builder
+        @builder ||= DefinitionBuilder.new(env: env)
+      end
+
+      def skip_method?(type_name, method)
+        if method.implemented_in == type_name
+          if method.annotations.any? {|a| a.string == "rbs:test:skip" }
+            :skip
+          else
+            false
+          end
+        else
+          if method.annotations.any? {|a| a.string == "rbs:test:target" }
+            false
+          else
+            :implemented_in
+          end
+        end
+      end
+
+      def install!(klass, sample_size:, unchecked_classes:)
+        RBS.logger.info { "Installing runtime type checker in #{klass}..." }
+
+        type_name = factory.type_name(klass.name).absolute!
+
+        builder.build_instance(type_name).tap do |definition|
+          instance_key = new_key(type_name, "InstanceChecker")
+          tester, set = instance_testers[klass] ||= [
+            MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size, unchecked_classes: unchecked_classes),
+            Set[]
+          ]
+          Observer.register(instance_key, tester)
+
+          definition.methods.each do |name, method|
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
+              end
+            else
+              if !set.include?(name) && (
+                  name == :initialize ||
+                  klass.instance_methods(false).include?(name) ||
+                  klass.private_instance_methods(false).include?(name))
+                RBS.logger.info { "Setting up method hook in ##{name}..." }
+                Hook.hook_instance_method klass, name, key: instance_key
+                set << name
+              end
+            end
+          end
+        end
+
+        builder.build_singleton(type_name).tap do |definition|
+          singleton_key = new_key(type_name, "SingletonChecker")
+          tester, set = singleton_testers[klass] ||= [
+            MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size, unchecked_classes: unchecked_classes),
+            Set[]
+          ]
+          Observer.register(singleton_key, tester)
+
+          definition.methods.each do |name, method|
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping .#{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.methods(false).include?(name) && !set.include?(name)
+                RBS.logger.info { "Setting up method hook in .#{name}..." }
+                Hook.hook_singleton_method klass, name, key: singleton_key
+                set << name
+              end
+            end
+          end
+        end
+
+        targets << klass
+      end
+
+      def new_key(type_name, prefix)
+        "#{prefix}__#{type_name}__#{SecureRandom.hex(10)}"
+      end
+
+      class TypeError < Exception
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+
+          super "TypeError: #{errors.map {|e| Errors.to_string(e) }.join(", ")}"
+        end
+      end
+
+      class MethodCallTester
+        attr_reader :self_class
+        attr_reader :definition
+        attr_reader :builder
+        attr_reader :kind
+        attr_reader :sample_size
+        attr_reader :unchecked_classes
+
+        def initialize(self_class, builder, definition, kind:, sample_size:, unchecked_classes:)
+          @self_class = self_class
+          @definition = definition
+          @builder = builder
+          @kind = kind
+          @sample_size = sample_size
+          @unchecked_classes = unchecked_classes
+        end
+
+        def env
+          builder.env
+        end
+
+        def check
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size, unchecked_classes: unchecked_classes)
+        end
+
+        def format_method_name(name)
+          case kind
+          when :instance
+            "##{name}"
+          when :singleton
+            ".#{name}"
+          end
+        end
+
+        def call(receiver, trace)
+          method_name = trace.method_name
+          method = definition.methods[method_name]
+          if method
+            RBS.logger.debug { "Type checking `#{self_class}#{format_method_name(method_name)}`..."}
+            errors = check.overloaded_call(method, method_name, trace, errors: [])
+
+            if errors.empty?
+              RBS.logger.debug { "No type error detected 👏" }
+            else
+              RBS.logger.debug { "Detected type error 🚨" }
+              raise TypeError.new(errors)
+            end
+          else
+            RBS.logger.error { "Type checking `#{self_class}#{method_name}` call but no method found in definition" }
+          end
+        end
+      end
+    end
+  end
+end