mock-suey 0.0.1 → 0.1.0

data/lib/mock_suey/type_checks/ruby.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+gem "rbs", "~> 2.0"
+require "rbs"
+require "rbs/test"
+
+require "set"
+require "pathname"
+
+require "mock_suey/ext/instance_class"
+
+module MockSuey
+  module TypeChecks
+    using Ext::InstanceClass
+
+    class Ruby
+      class SignatureGenerator
+        attr_reader :klass, :method_calls, :constants, :singleton
+        alias_method :singleton?, :singleton
+
+        def initialize(klass, method_calls)
+          @klass = klass
+          @singleton = klass.singleton_class?
+          @method_calls = method_calls
+          @constants = Set.new
+        end
+
+        def to_rbs
+          [
+            header,
+            *method_calls.map { |name, calls| method_sig(name, calls) },
+            footer
+          ].join("\n")
+        end
+
+        private
+
+        def header
+          nesting_parts = klass.instance_class_name.split("::")
+
+          base = Kernel
+          nesting = 0
+
+          lines = []
+
+          nesting_parts.map do |const|
+            base = base.const_get(const)
+            lines << "#{"  " * nesting}#{base.is_a?(Class) ? "class" : "module"} #{const}"
+            nesting += 1
+          end
+
+          @nesting = nesting_parts.size
+
+          lines.join("\n")
+        end
+
+        def footer
+          @nesting.times.map do |n|
+            "#{"  " * (@nesting - n - 1)}end"
+          end.join("\n")
+        end
+
+        def method_sig(name, calls)
+          "#{"  " * @nesting}def #{singleton? ? "self." : ""}#{name}: (#{[args_sig(calls.map(&:pos_args)), kwargs_sig(calls.map(&:kwargs))].compact.join(", ")}) -> (#{return_sig(name, calls.map(&:return_value))})"
+        end
+
+        def args_sig(args)
+          return if args.all?(&:empty?)
+
+          args.transpose.map do |arg_values|
+            arg_values.map(&:class).uniq.map do
+              constants << _1
+              "::#{_1.name}"
+            end
+          end.join(", ")
+        end
+
+        def kwargs_sig(kwargs)
+          return if kwargs.all?(&:empty?)
+
+          key_values = kwargs.each_with_object(Hash.new { |h, k| h[k] = [] }) { |pairs, acc|
+            pairs.each { acc[_1] << _2 }
+          }
+
+          key_values.map do |key, values|
+            values_sig = values.map(&:class).uniq.map do
+              constants << _1
+              "::#{_1.name}"
+            end.join(" | ")
+
+            "?#{key}: (#{values_sig})"
+          end.join(", ")
+        end
+
+        def return_sig(name, values)
+          # Special case
+          return "self" if name == :initialize
+
+          values.map(&:class).uniq.map do
+            constants << _1
+            "::#{_1.name}"
+          end.join(" | ")
+        end
+      end
+
+      def initialize(load_dirs: [])
+        @load_dirs = Array(load_dirs)
+      end
+
+      def typecheck!(call_obj, raise_on_missing: false)
+        method_name = call_obj.method_name
+
+        method_call = RBS::Test::ArgumentsReturn.return(
+          arguments: call_obj.arguments,
+          value: call_obj.return_value
+        )
+
+        call_trace = RBS::Test::CallTrace.new(
+          method_name:,
+          method_call:,
+          # TODO: blocks support
+          block_calls: [],
+          block_given: false
+        )
+
+        method_type = type_for(call_obj.receiver_class, method_name)
+
+        unless method_type
+          raise MissingSignature, "No signature found for #{call_obj.method_desc}" if raise_on_missing
+          return
+        end
+
+        self_class = call_obj.receiver_class
+        instance_class = call_obj.receiver_class
+        class_class = call_obj.receiver_class.singleton_class? ? call_obj.receiver_class : call_obj.receiver_class.singleton_class
+
+        typecheck = RBS::Test::TypeCheck.new(
+          self_class:,
+          builder:,
+          sample_size: 100, # What should be the value here?
+          unchecked_classes: [],
+          instance_class:,
+          class_class:
+        )
+
+        errors = []
+        typecheck.overloaded_call(
+          method_type,
+          "#{self_class.singleton_class? ? "." : "#"}#{method_name}",
+          call_trace,
+          errors:
+        )
+
+        reject_returned_doubles!(errors)
+
+        # TODO: Use custom error class
+        raise RBS::Test::Tester::TypeError.new(errors) unless errors.empty?
+      end
+
+      def load_signatures_from_calls(calls)
+        constants = Set.new
+
+        calls.group_by(&:receiver_class).each do |klass, klass_calls|
+          calls_per_method = klass_calls.group_by(&:method_name)
+          generator = SignatureGenerator.new(klass, calls_per_method)
+
+          generator.to_rbs.then do |rbs|
+            MockSuey.logger.debug "Generated RBS for #{klass.instance_class_name}:\n#{rbs}\n"
+            load_rbs(rbs)
+          end
+
+          constants |= generator.constants
+        end
+
+        constants.each do |const|
+          next if type_defined?(const)
+
+          SignatureGenerator.new(const, {}).to_rbs.then do |rbs|
+            MockSuey.logger.debug "Generated RBS for constant #{const.instance_class_name}:\n#{rbs}\n"
+            load_rbs(rbs)
+          end
+        end
+      end
+
+      private
+
+      def load_rbs(rbs)
+        ::RBS::Parser.parse_signature(rbs).then do |declarations|
+          declarations.each do |decl|
+            env << decl
+          end
+        end
+      end
+
+      def env
+        return @env if instance_variable_defined?(:@env)
+
+        loader = RBS::EnvironmentLoader.new
+        @load_dirs&.each { loader.add(path: Pathname(_1)) }
+        @env = RBS::Environment.from_loader(loader).resolve_type_names
+      end
+
+      def builder = @builder ||= RBS::DefinitionBuilder.new(env:)
+
+      def type_for(klass, method_name)
+        type = type_for_class(klass.instance_class)
+        return unless env.class_decls[type]
+
+        decl = klass.singleton_class? ? builder.build_singleton(type) : builder.build_instance(type)
+
+        decl.methods[method_name]
+      end
+
+      def type_for_class(klass)
+        *path, name = *klass.instance_class_name.split("::").map(&:to_sym)
+
+        namespace = path.empty? ? RBS::Namespace.root : RBS::Namespace.new(absolute: true, path:)
+
+        RBS::TypeName.new(name:, namespace:)
+      end
+
+      def type_defined?(klass)
+        !env.class_decls[type_for_class(klass.instance_class)].nil?
+      end
+
+      def reject_returned_doubles!(errors)
+        return unless defined?(::RSpec::Core)
+
+        errors.reject! do |error|
+          case error
+          in RBS::Test::Errors::ReturnTypeError[
+            type:,
+            value: ::RSpec::Mocks::InstanceVerifyingDouble => double
+          ]
+            return_class = type.instance_of?(RBS::Types::Bases::Self) ? error.klass : type.name
+            return_type = return_class.to_s.gsub(/^::/, "")
+            double_type = double.instance_variable_get(:@doubled_module).target.to_s
+
+            double_type == return_type
+          in RBS::Test::Errors::ReturnTypeError[
+            value: ::RSpec::Mocks::Double
+          ]
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mock_suey/type_checks.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MockSuey
+  module TypeChecks
+    class MissingSignature < StandardError
+    end
+  end
+end

data/lib/mock_suey/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MockSuey # :nodoc:
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/mock_suey.rb

@@ -1,3 +1,18 @@
 # frozen_string_literal: true
 
+require "logger"
+
+require "ruby-next"
+
+require "ruby-next/language/setup"
+RubyNext::Language.setup_gem_load_path(transpile: true)
+
 require "mock_suey/version"
+require "mock_suey/logging"
+require "mock_suey/core"
+require "mock_suey/method_call"
+require "mock_suey/type_checks"
+require "mock_suey/tracer"
+require "mock_suey/mock_contract"
+
+require "mock_suey/rspec" if defined?(RSpec::Core)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mock-suey
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-15 00:00:00.000000000 Z
+date: 2022-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.9'
 - !ruby/object:Gem::Dependency
-  name: ruby-next
+  name: ruby-next-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -76,8 +76,32 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/.rbnext/3.0/mock_suey/core.rb
+- lib/.rbnext/3.0/mock_suey/ext/instance_class.rb
+- lib/.rbnext/3.0/mock_suey/ext/rspec.rb
+- lib/.rbnext/3.0/mock_suey/mock_contract.rb
+- lib/.rbnext/3.0/mock_suey/rspec/mock_context.rb
+- lib/.rbnext/3.0/mock_suey/type_checks/ruby.rb
+- lib/.rbnext/3.1/mock_suey/core.rb
+- lib/.rbnext/3.1/mock_suey/mock_contract.rb
+- lib/.rbnext/3.1/mock_suey/rspec/mock_context.rb
+- lib/.rbnext/3.1/mock_suey/rspec/proxy_method_invoked.rb
+- lib/.rbnext/3.1/mock_suey/tracer.rb
+- lib/.rbnext/3.1/mock_suey/type_checks/ruby.rb
 - lib/mock-suey.rb
 - lib/mock_suey.rb
+- lib/mock_suey/core.rb
+- lib/mock_suey/ext/instance_class.rb
+- lib/mock_suey/ext/rspec.rb
+- lib/mock_suey/logging.rb
+- lib/mock_suey/method_call.rb
+- lib/mock_suey/mock_contract.rb
+- lib/mock_suey/rspec.rb
+- lib/mock_suey/rspec/mock_context.rb
+- lib/mock_suey/rspec/proxy_method_invoked.rb
+- lib/mock_suey/tracer.rb
+- lib/mock_suey/type_checks.rb
+- lib/mock_suey/type_checks/ruby.rb
 - lib/mock_suey/version.rb
 homepage: http://github.com/test-prof/mock-suey
 licenses: