rbs 0.3.1 → 0.8.0

data/lib/rbs/test/observer.rb

@@ -0,0 +1,17 @@
+module RBS
+  module Test
+    module Observer
+      @@observers = {}
+
+      class <<self
+        def notify(key, *args)
+          @@observers[key]&.call(*args)
+        end
+
+        def register(key, object = nil, &block)
+          @@observers[key] = object || block
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/setup.rb

@@ -1,58 +1,74 @@
 require "rbs"
 require "rbs/test"
-
 require "optparse"
 require "shellwords"
 
+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(",")
-  skips = (ENV["RBS_TEST_SKIP"] || "").split(",")
-  logger.level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
-  raise_on_error = ENV["RBS_TEST_RAISE"]
-rescue
+  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")
+  sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
+rescue InvalidSampleSizeError => exception
+  RBS.logger.error exception.message
+  exit 1
+rescue Exception => e
+  raise e.message
   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_RAISE: specify any value to raise an exception when type error is detected"
+  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)"
   exit 1
 end
 
-hooks = []
-
-env = RBS::Environment.new
-
 loader = RBS::EnvironmentLoader.new
 OptionParser.new do |opts|
   opts.on("-r [LIB]") do |name| loader.add(library: name) end
   opts.on("-I [DIR]") do |dir| loader.add(path: Pathname(dir)) end
 end.parse!(opts)
-loader.load(env: env)
+
+env = RBS::Environment.from_loader(loader).resolve_type_names
 
 def match(filter, name)
   if filter.end_with?("*")
-    name.start_with?(filter[0, filter.size - 1]) || name == filter[0, filter.size-3]
+    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)
+
 TracePoint.trace :end do |tp|
-  class_name = tp.self.name
+  class_name = tp.self.name&.yield_self {|name| to_absolute_typename name }
 
   if class_name
-    if filter.any? {|f| match(f, class_name) } && skips.none? {|f| match(f, class_name) }
-      type_name = RBS::Namespace.parse(class_name).absolute!.to_type_name
-      if hooks.none? {|hook| hook.klass == tp.self }
-        if env.find_class(type_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 tester.checkers.none? {|hook| hook.klass == tp.self }
+        if env.class_decls.key?(class_name)
           logger.info "Setting up hooks for #{class_name}"
-          hooks << RBS::Test::Hook.install(env, tp.self, logger: logger).verify_all.raise_on_error!(raise_on_error)
+          tester.install!(tp.self, sample_size: sample_size)
         end
       end
     end
   end
 end
+
+at_exit do
+  if $!.nil? || $!.is_a?(SystemExit) && $!.success?
+    logger.warn "No type checker was installed! " if tester.checkers.empty?
+  end
+end
+
+ 

data/lib/rbs/test/setup_helper.rb

@@ -0,0 +1,29 @@
+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
+    end
+  end
+end

data/lib/rbs/test/spy.rb

@@ -1,325 +1,4 @@
 module RBS
   module Test
-    module Spy
-      def self.singleton_method(object, method_name)
-        spy = SingletonSpy.new(object: object, method_name: method_name)
-
-        if block_given?
-          begin
-            spy.setup
-            yield spy
-          ensure
-            spy.reset
-          end
-        else
-          spy
-        end
-      end
-
-      def self.instance_method(mod, method_name)
-        spy = InstanceSpy.new(mod: mod, method_name: method_name)
-
-        if block_given?
-          begin
-            spy.setup
-            yield spy
-          ensure
-            spy.reset
-          end
-        else
-          spy
-        end
-      end
-
-      def self.wrap(object, method_name)
-        spy = WrapSpy.new(object: object, method_name: method_name)
-
-        if block_given?
-          begin
-            yield spy, spy.wrapped_object
-          end
-        else
-          spy
-        end
-      end
-
-      class SingletonSpy
-        attr_accessor :callback
-        attr_reader :method_name
-        attr_reader :object
-
-        def initialize(object:, method_name:)
-          @object = object
-          @method_name = method_name
-          @callback = -> (_) { }
-        end
-
-        def setup
-          spy = self
-
-          object.singleton_class.class_eval do
-            remove_method spy.method_name
-            define_method spy.method_name, spy.spy()
-          end
-        end
-
-        def spy()
-          spy = self
-
-          -> (*args, &block) do
-            return_value = nil
-            exception = nil
-            block_calls = []
-
-            spy_block = if block
-                          Object.new.instance_eval do |fresh|
-                            -> (*block_args) do
-                              block_exn = nil
-                              block_return = nil
-
-                              begin
-                                block_return = if self.equal?(fresh)
-                                                 # no instance eval
-                                                 block.call(*block_args)
-                                               else
-                                                 self.instance_exec(*block_args, &block)
-                                               end
-                              rescue Exception => exn
-                                block_exn = exn
-                              end
-
-                              block_calls << ArgumentsReturn.new(
-                                arguments: block_args,
-                                return_value: block_return,
-                                exception: block_exn
-                              )
-
-                              if block_exn
-                                raise block_exn
-                              else
-                                block_return
-                              end
-                            end.ruby2_keywords
-                          end
-                        end
-
-            begin
-              return_value = super(*args, &spy_block)
-            rescue Exception => exn
-              exception = exn
-            end
-
-            trace = CallTrace.new(
-              method_name: spy.method_name,
-              method_call: ArgumentsReturn.new(
-                arguments: args,
-                return_value: return_value,
-                exception: exception,
-              ),
-              block_calls: block_calls,
-              block_given: block != nil
-            )
-
-            spy.callback.call(trace)
-
-            if exception
-              raise exception
-            else
-              return_value
-            end
-          end.ruby2_keywords
-        end
-
-        def reset
-          if object.singleton_class.methods.include?(method_name)
-            object.singleton_class.remove_method method_name
-          end
-        end
-      end
-
-      class InstanceSpy
-        attr_accessor :callback
-        attr_reader :mod
-        attr_reader :method_name
-        attr_reader :original_method
-
-        def initialize(mod:, method_name:)
-          @mod = mod
-          @method_name = method_name
-          @original_method = mod.instance_method(method_name)
-          @callback = -> (_) { }
-        end
-
-        def setup
-          spy = self
-
-          mod.class_eval do
-            remove_method spy.method_name
-            define_method spy.method_name, spy.spy()
-          end
-        end
-
-        def reset
-          spy = self
-
-          mod.class_eval do
-            remove_method spy.method_name
-            define_method spy.method_name, spy.original_method
-          end
-        end
-
-        def spy
-          spy = self
-
-          -> (*args, &block) do
-            return_value = nil
-            exception = nil
-            block_calls = []
-
-            spy_block = if block
-                          Object.new.instance_eval do |fresh|
-                            -> (*block_args) do
-                              block_exn = nil
-                              block_return = nil
-
-                              begin
-                                block_return = if self.equal?(fresh)
-                                                 # no instance eval
-                                                 block.call(*block_args)
-                                               else
-                                                 self.instance_exec(*block_args, &block)
-                                               end
-                              rescue Exception => exn
-                                block_exn = exn
-                              end
-
-                              block_calls << ArgumentsReturn.new(
-                                arguments: block_args,
-                                return_value: block_return,
-                                exception: block_exn
-                              )
-
-                              if block_exn
-                                raise block_exn
-                              else
-                                block_return
-                              end
-                            end.ruby2_keywords
-                          end
-                        end
-
-            begin
-              return_value = spy.original_method.bind_call(self, *args, &spy_block)
-            rescue Exception => exn
-              exception = exn
-            end
-
-            trace = CallTrace.new(
-              method_name: spy.method_name,
-              method_call: ArgumentsReturn.new(
-                arguments: args,
-                return_value: return_value,
-                exception: exception,
-                ),
-              block_calls: block_calls,
-              block_given: block != nil
-            )
-
-            spy.callback.call(trace)
-
-            if exception
-              raise exception
-            else
-              return_value
-            end
-          end.ruby2_keywords
-        end
-      end
-
-      class WrapSpy
-        attr_accessor :callback
-        attr_reader :object
-        attr_reader :method_name
-
-        def initialize(object:, method_name:)
-          @callback = -> (_) { }
-          @object = object
-          @method_name = method_name
-        end
-
-        def wrapped_object
-          spy = self
-
-          Class.new(BasicObject) do
-            define_method(:method_missing) do |name, *args, &block|
-              spy.object.__send__(name, *args, &block)
-            end
-
-            define_method(spy.method_name, -> (*args, &block) {
-              return_value = nil
-              exception = nil
-              block_calls = []
-
-              spy_block = if block
-                            Object.new.instance_eval do |fresh|
-                              -> (*block_args) do
-                                block_exn = nil
-                                block_return = nil
-
-                                begin
-                                  block_return = if self.equal?(fresh)
-                                                   # no instance eval
-                                                   block.call(*block_args)
-                                                 else
-                                                   self.instance_exec(*block_args, &block)
-                                                 end
-                                rescue Exception => exn
-                                  block_exn = exn
-                                end
-
-                                block_calls << ArgumentsReturn.new(
-                                  arguments: block_args,
-                                  return_value: block_return,
-                                  exception: block_exn
-                                )
-
-                                if block_exn
-                                  raise block_exn
-                                else
-                                  block_return
-                                end
-                              end.ruby2_keywords
-                            end
-                          end
-
-              begin
-                return_value = spy.object.__send__(spy.method_name, *args, &spy_block)
-              rescue ::Exception => exn
-                exception = exn
-              end
-
-              trace = CallTrace.new(
-                method_name: spy.method_name,
-                method_call: ArgumentsReturn.new(
-                  arguments: args,
-                  return_value: return_value,
-                  exception: exception,
-                  ),
-                block_calls: block_calls,
-                block_given: block != nil
-              )
-
-              spy.callback.call(trace)
-
-              if exception
-                spy.object.__send__(:raise, exception)
-              else
-                return_value
-              end
-            }.ruby2_keywords)
-          end.new()
-        end
-      end
-    end
   end
 end