type_toolkit 0.0.5 → 0.0.7

data/sorbet/rbi/shims/core.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+# A shim module representing (a subset of) the common interface between Method and UnboundMethod.
+module MethodOrUnboundMethod
+  sig { returns(T::Module[T.untyped]) }
+  def owner; end
+
+  sig { returns(Symbol) }
+  def name; end
+end
+
+class Method
+  include MethodOrUnboundMethod
+end
+
+class UnboundMethod
+  include MethodOrUnboundMethod
+end

data/sorbet/rbi/shims/minitest.rbi

@@ -35,9 +35,12 @@ module Minitest
       def it(desc = T.unsafe(nil), &block); end
 
       sig do
-        params(block: T.proc.bind(T.attached_class).void).void
+        params(
+          type: T.anything,
+          block: T.proc.bind(T.attached_class).void,
+        ).void
       end
-      def before(&block); end
+      def before(type = T.unsafe(nil), &block); end
     end
   end
 end

data/sorbet/rbi/shims/rubocop_minitest.rbi

@@ -4,14 +4,17 @@
 module RuboCop
   module Minitest
     module AssertOffense
-      sig { params(source: String).void }
-      def assert_offense(source); end
+      sig { params(source: String, file: T.nilable(String), replacements: String).void }
+      def assert_offense(source, file = nil, **replacements); end
 
       sig { params(source: String).void }
       def assert_no_offenses(source); end
 
       sig { params(source: String).void }
       def assert_correction(source); end
+
+      sig { void }
+      def assert_no_corrections; end
     end
   end
 end

data/spec/interface_spec.rb

@@ -0,0 +1,419 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module TypeToolkit
+  class InterfaceSpec < Minitest::Spec
+    module SimpleInterface
+      interface!
+
+      abstract def m1 = assert_never_called!
+      abstract def m2 = assert_never_called!
+    end
+
+    # A normal class that's completely unrelated `SimpleInterface`.
+    class NonImpl
+      def m1 = "NonImpl#m1"
+      # Does not implement `m2`
+    end
+
+    # A class that implements some but not all of the SimpleInterface's abstract methods.
+    class PartialImpl
+      include SimpleInterface
+
+      def m1 = "PartialImpl#m1"
+      # Does not provide an implementation for `m2`
+    end
+
+    # A class that implements all of the SimpleInterface's abstract methods.
+    class FullImpl
+      include SimpleInterface
+
+      def initialize
+        @a = 1
+        @b = 2
+      end
+
+      def m1 = "FullImpl#m1"
+      def m2 = "FullImpl#m2"
+    end
+
+    # A class that provides a partial implementation of `SimpleInterface` for `PartiallyInheritsItsImpl`.
+    class PartialParent
+      def m1 = "PartialParent#m1"
+      # Does not implement `m2`
+    end
+
+    # A class that implements all of the SimpleInterface's abstract methods, some via inheritance, and some via direct implementation.
+    class PartiallyInheritsItsImpl < PartialParent
+      include SimpleInterface
+
+      def m2 = "PartiallyInheritsItsImpl#m2"
+    end
+
+    describe "An interface" do
+      describe ".abstract macro" do
+        it "returns the method name" do
+          test_context = self
+
+          Module.new do
+            interface!
+
+            test_context.assert_equal(:the_method_name, abstract(def the_method_name; end))
+          end
+        end
+
+        it "raises when it sees a different method name than what MethodDefRecorder recorded" do
+          error = assert_raises(RuntimeError) do
+            Module.new do
+              interface!
+
+              # Simulate a conflicting `method_added` call by sneaking in a method definition
+              # between the `def` and the `abstract` call.
+              def m1; end
+
+              def something_else; end
+
+              abstract(:m1)
+            end
+          end
+
+          # Do not rely on this message content! Its content is subject to change!
+          assert_equal <<~EXPECTED.chomp, error.message
+            `abstract` expected to see `#m1`, but the last recorded method was called `something_else`.
+            This can happen when `abstract` is combined with other metaprogramming.
+            If you think this is a bug, please open an issue: https://github.com/Shopify/type_toolkit/issues
+          EXPECTED
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "contains all declared abstract methods" do
+          assert_equal [:m1, :m2], SimpleInterface.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], SimpleInterface.declared_abstract_instance_methods(true)
+          assert_equal [:m1, :m2], SimpleInterface.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "only contains unimplemented abstract methods" do
+          assert_equal [:m1, :m2], SimpleInterface.abstract_instance_methods
+          assert_equal [:m1, :m2], SimpleInterface.abstract_instance_methods(true)
+          assert_equal [:m1, :m2], SimpleInterface.abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns true for abstract methods" do
+          assert SimpleInterface.abstract_method?(:m1)
+          assert SimpleInterface.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute SimpleInterface.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "returns true for abstract methods" do
+          assert SimpleInterface.abstract_method_declared?(:m1)
+          assert SimpleInterface.abstract_method_declared?(:m2)
+        end
+      end
+    end
+
+    describe "A class that does not implement the interface" do
+      describe "a method with the same name as another interface's members" do
+        # These tests sanity-check that our runtime trickery didn't accidentally change the
+        # normal behaviour of method calling and `method_missing` for unrelated classes.
+
+        before do
+          @class = NonImpl
+          @x = NonImpl.new
+        end
+
+        it "#respond_to? returns true" do
+          assert_respond_to @x, :m1
+        end
+
+        it "can be called like normal" do
+          assert_equal "NonImpl#m1", @x.m1
+        end
+
+        describe "a Method object for it" do
+          it "can be called like normal" do
+            assert_equal "NonImpl#m1", @x.method(:m1).call
+          end
+
+          it "is not abstract" do
+            refute_predicate @x.method(:m1), :abstract?
+          end
+        end
+
+        describe "an UnboundMethod object for it" do
+          before { @um = @x.method(:m1).unbind }
+          it "can be called like normal" do
+            assert_equal "NonImpl#m1", @um.bind_call(@x)
+          end
+
+          it "is not abstract" do
+            refute_predicate @um, :abstract?
+          end
+        end
+
+        it "calls a defined method like normal" do
+          assert_respond_to @x, :m1
+          assert_equal "NonImpl#m1", @x.m1
+          assert_equal "NonImpl#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+        end
+
+        it "raises NoMethodError for an undefined method like normal" do
+          refute_respond_to @x, :m2
+          assert_raises(NoMethodError) { @x.m2 }
+        end
+      end
+
+      it "does not respond to .abstract_method?" do
+        refute_respond_to @class, :abstract_method?
+        assert_raises(NoMethodError) { @class.abstract_method?(:m1) }
+      end
+
+      it "does not respond to .abstract_method_declared?" do
+        refute_respond_to @class, :abstract_method_declared?
+        assert_raises(NoMethodError) { @class.abstract_method_declared?(:m1) }
+      end
+
+      it "does not respond to .declared_abstract_instance_methods" do
+        refute_respond_to @class, :declared_abstract_instance_methods
+        assert_raises(NoMethodError) { @class.declared_abstract_instance_methods }
+      end
+
+      it "does not respond to .abstract_instance_methods" do
+        refute_respond_to @class, :abstract_instance_methods
+        assert_raises(NoMethodError) { @class.abstract_instance_methods }
+      end
+    end
+
+    describe "A class that partially implements the interface" do
+      before do
+        @class = PartialImpl
+        @x = PartialImpl.new
+      end
+
+      describe "calling an implemented abstract method" do
+        it "calls the concrete implementation" do
+          assert_respond_to @x, :m1
+          assert_equal "PartialImpl#m1", @x.m1
+          assert_equal "PartialImpl#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+        end
+      end
+
+      describe "calling an unimplemented abstract method" do
+        it "raises AbstractMethodNotImplementedError" do
+          assert_respond_to @x, :m2
+
+          # Notice it's not `NoMethodError`, so we can give a better error message.
+          e = assert_abstract { @x.m2 }
+
+          # Do not rely on this message content! Its content is subject to change!
+          # We only test it to ensure it's formatted correctly.
+          assert_equal "Abstract method `#m2` was never implemented.", e.message
+
+          m2 = @x.method(:m2)
+          assert_kind_of Method, m2
+          assert_predicate m2, :abstract?
+          assert_predicate m2.unbind, :abstract?
+        end
+      end
+
+      describe "calling a non-abstract method" do
+        it "calls the concrete implementation" do
+          assert_respond_to @x, :inspect
+          assert_kind_of String, @x.inspect
+          assert_kind_of String, @x.method(:inspect).call
+          refute_predicate @x.method(:inspect), :abstract?
+          refute_predicate @x.method(:inspect).unbind, :abstract?
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns false for abstract methods that have been implemented" do
+          refute @class.abstract_method?(:m1)
+        end
+
+        it "returns true for abstract methods that have not been implemented" do
+          assert @class.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute @class.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "is true for all abstract methods" do
+          assert @class.abstract_method_declared?(:m1) # Even the one that's been implemented
+          assert @class.abstract_method_declared?(:m2)
+        end
+
+        it "is false for non-abstract methods" do
+          assert @class.public_method_defined?(:inspect) # precondition
+          refute @class.abstract_method_declared?(:inspect)
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "returns all declared abstract methods, even those that have been implemented" do
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods(true)
+          assert_equal [], @class.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "returns only unimplemented abstract methods" do
+          assert_equal [:m2], @class.abstract_instance_methods
+          assert_equal [:m2], @class.abstract_instance_methods(true)
+          assert_equal [], @class.abstract_instance_methods(false)
+        end
+      end
+    end
+
+    describe "A class that fully implements the interface" do
+      before do
+        @class = FullImpl
+        @x = FullImpl.new
+      end
+
+      describe "calling an implemented abstract method" do
+        it "calls the concrete implementation" do
+          assert_respond_to @x, :m1
+          assert_equal "FullImpl#m1", @x.m1
+          assert_equal "FullImpl#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+
+          assert_respond_to @x, :m2
+          assert_equal "FullImpl#m2", @x.m2
+          assert_equal "FullImpl#m2", @x.method(:m2).call
+          refute_predicate @x.method(:m2), :abstract?
+          refute_predicate @x.method(:m2).unbind, :abstract?
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns false for abstract methods that have been implemented" do
+          refute @class.abstract_method?(:m1)
+          refute @class.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute @class.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "returns true for all abstract methods" do
+          assert @class.abstract_method_declared?(:m1)
+          assert @class.abstract_method_declared?(:m2)
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "returns all declared abstract methods, even those that have been implemented" do
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods(true)
+          assert_equal [], @class.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "returns only unimplemented abstract methods" do
+          assert_equal [], @class.abstract_instance_methods
+          assert_equal [], @class.abstract_instance_methods(true)
+          assert_equal [], @class.abstract_instance_methods(false)
+        end
+      end
+    end
+
+    describe "A class that fully implements the interface, partially via inheritance" do
+      before do
+        @class = PartiallyInheritsItsImpl
+        @x = PartiallyInheritsItsImpl.new
+      end
+
+      describe "calling an abstract method with an inherited implementation" do
+        it "calls the inherited implementation" do
+          assert_respond_to @x, :m1
+          assert_equal "PartialParent#m1", @x.m1
+          assert_equal "PartialParent#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+        end
+      end
+
+      describe "calling an abstract method with defined in the child implementation" do
+        it "calls the child implementation" do
+          assert_respond_to @x, :m2
+          assert_equal "PartiallyInheritsItsImpl#m2", @x.m2
+          assert_equal "PartiallyInheritsItsImpl#m2", @x.method(:m2).call
+          refute_predicate @x.method(:m2), :abstract?
+          refute_predicate @x.method(:m2).unbind, :abstract?
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns false for abstract methods that have been implemented" do
+          refute @class.abstract_method?(:m1)
+          refute @class.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute @class.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "returns true for all abstract methods" do
+          assert @class.abstract_method_declared?(:m1)
+          assert @class.abstract_method_declared?(:m2)
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "returns all declared abstract methods, even those that have been implemented" do
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods(true)
+          assert_equal [], @class.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "returns only unimplemented abstract methods" do
+          assert_equal [], @class.abstract_instance_methods
+          assert_equal [], @class.abstract_instance_methods(true)
+          assert_equal [], @class.abstract_instance_methods(false)
+        end
+      end
+    end
+
+    describe "Abstract class methods" do
+      it "are not yet supported" do
+        test_context = self
+
+        Module.new do
+          interface!
+
+          test_context.assert_raises(NotImplementedError) do
+            abstract def self.abstract_class_method; end # rubocop:disable Style/ClassMethodsDefinitions
+          end
+        end
+      end
+    end
+  end
+end

data/spec/misc/how_method_added_hooks_work_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module TypeToolkit
+  module Misc
+    # This test just characterizes how `method_added` hooks work. It doesn't have anything to do with TypeToolkit itself,
+    # but it's useful for devs to confirm how this works across instance and class methods.
+    class HowMethodAddedHooksWorkSpec < Minitest::Spec
+      it "characterizes how method_added hooks work" do
+        test_context = self
+
+        Class.new do
+          class << self
+            attr_reader :__last_method_def
+
+            class << self
+              def __last_method_def
+                attached_object.__last_method_def
+              end
+            end
+
+            def method_added(m)
+              is_singleton_method = false
+              @__last_method_def = [m, is_singleton_method]
+
+              super
+            end
+
+            def singleton_method_added(m)
+              return super if m == :singleton_method_added
+
+              is_singleton_method = true
+              @__last_method_def = [m, is_singleton_method]
+
+              super
+            end
+          end
+
+          test_context.assert_nil __last_method_def
+
+          def instance_method; end
+
+          test_context.assert_equal [:instance_method, false], __last_method_def
+
+          def self.singleton_method_via_self_dot; end # rubocop:disable Style/ClassMethodsDefinitions
+
+          test_context.assert_equal [:singleton_method_via_self_dot, true], __last_method_def
+
+          r = class << self
+                def singleton_method_via_sclass; end
+
+                __last_method_def
+          end
+
+          test_context.assert_equal [:singleton_method_via_sclass, true], r
+
+          test_context.assert_equal [:singleton_method_via_sclass, true], __last_method_def
+        end
+      end
+    end
+  end
+end