type_toolkit 0.0.5 → 0.0.7

data/lib/type_toolkit/has_abstract_methods.rb

@@ -0,0 +1,108 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypeToolkit
+  # Given a class Foo, abstract methods can be defined at two levels:
+  # 1. Instance methods available on the instance of Foo
+  # 2. "Class methods" available on the Foo class itself
+  #
+  # In case 1, the storage belongs one level up, in the class Foo.
+  # In case 2, the storage belongs two levels up, in the singleton class of Foo (`Foo::<Foo>`)
+  module HasAbstractMethods
+    # Private API, do not use directly. Only meant to be called from the `abstract` macro.
+    #: (Symbol) -> void
+    def __register_abstract_method(method_name) # :nodoc:
+      (
+        @__abstract_methods ||= Set.new #: Set[Symbol]?
+      ) << method_name
+    end
+
+    # Returns all methods that were marked abstract (even those which are implemented).
+    #: (?bool) -> Array[Symbol]
+    def declared_abstract_instance_methods(include_super = true)
+      #: self as HasAbstractMethods & Module[top]
+
+      result = @__abstract_methods
+
+      return result.to_a unless include_super
+
+      if defined?(super) && (super_abstract_methods = super)
+        if result
+          result.merge(super_abstract_methods)
+        else
+          result = super_abstract_methods
+        end
+      end
+
+      abstract_methods_in_interfaces = included_modules.flat_map do |m|
+        m.is_a?(HasAbstractMethods) ? m.declared_abstract_instance_methods : []
+      end
+
+      if abstract_methods_in_interfaces.any?
+        if result&.any?
+          result.merge(abstract_methods_in_interfaces)
+        else
+          result = abstract_methods_in_interfaces
+        end
+      end
+
+      result.to_a
+    end
+
+    # Returns all methods that are abstract and have not been implemented.
+    #: (?bool) -> Array[Symbol]
+    def abstract_instance_methods(include_super = true)
+      #: self as HasAbstractMethods & Module[top]
+
+      declared_abstract_instance_methods(include_super).reject do |m|
+        method_defined?(m) || private_method_defined?(m)
+      end
+    end
+
+    # Returns true if the given method name was ever marked abstract, even if it has a concrete implementation.
+    #
+    # Similar to `public_method_defined?` and friends, this method is called on a class to check if the method
+    # is defined for _instances_ of that class. For example:
+    #
+    #     if Foo.abstract_method_declared?(:instance_method)
+    #       Foo.new.instance_method # Might raise AbstractMethodNotImplementedError
+    #     end
+    #
+    #     if Foo.singleton_class.abstract_method_declared?(:class_method)
+    #       Foo.class_method # Might raise AbstractMethodNotImplementedError
+    #     end
+    #
+    #: (Symbol) -> bool
+    def abstract_method_declared?(method_name)
+      #: self as Module[top]
+
+      @__abstract_methods&.include?(method_name) ||
+        included_modules.any? { |m| m.is_a?(HasAbstractMethods) && m.abstract_method_declared?(method_name) } ||
+        (defined?(super) && super)
+    end
+
+    # Returns true if the given method is abstract, and has not been implemented.
+    # Calling it *will* raise an `AbstractMethodNotImplementedError`.
+    #
+    # Similar to `public_method_defined?` and friends, this method is called on a class to check if the method
+    # is defined for _instances_ of that class. For example:
+    #
+    #     if Foo.abstract_method?(:instance_method)
+    #       Foo.new.instance_method # Will raise AbstractMethodNotImplementedError
+    #     end
+    #
+    #     if Foo.singleton_class.abstract_method?(:class_method)
+    #       Foo.class_method # Will raise AbstractMethodNotImplementedError
+    #     end
+    #
+    #: (Symbol) -> bool
+    def abstract_method?(method_name)
+      #: self as (HasAbstractMethods & Module[top])
+
+      # If the method is defined, it has a concrete implementation, so it's not abstract.
+      return false if method_defined?(method_name) || private_method_defined?(method_name)
+
+      abstract_method_declared?(method_name)
+    end
+  end
+end

data/lib/type_toolkit/interface.rb

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "dsl"
+require_relative "method_def_recorder"
+require_relative "has_abstract_methods"
+require_relative "abstract_method_receiver"
+
+module TypeToolkit
+  class << self
+    #: (Module[top]) -> void
+    def make_interface!(mod)
+      if Class === mod
+        raise TypeError, "Classes can't be interfaces. Did you mean to make it `abstract` instead?"
+      end
+
+      mod.extend(TypeToolkit::Interface)
+      mod.extend(TypeToolkit::DSL)
+      mod.extend(TypeToolkit::MethodDefRecorder)
+      mod.extend(TypeToolkit::HasAbstractMethods)
+    end
+  end
+
+  # This module is extended onto any module that represents an interface.
+  # All of its members should be public and abstract.
+  module Interface
+    #: (Module[top]) -> void
+    def included(target_module)
+      # Including/extending a module is idempotent, so we don't have to worry these were already included/extended.
+
+      # Potentially abstract methods will be called on instances of `self`, so we need the `method_missing` hooks.
+      target_module.include(TypeToolkit::AbstractInstanceMethodReceiver)
+
+      # The `method_missing` hooks need to be able to look up the abstract methods (from the interface).
+      target_module.extend(TypeToolkit::HasAbstractMethods)
+    end
+  end
+end

data/lib/type_toolkit/method_def_recorder.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypeToolkit
+  # This module tracks new methods being defined, and whether they were
+  # instance methods (`def foo; end`) or singleton methods (`def self.foo; end`).
+  module MethodDefRecorder
+    #: [Symbol, bool]?
+    attr_reader :__last_method_def
+
+    class << self
+      #: (Module[top]) -> void
+      def extended(target_module)
+        # Also extend the singleton class so methods are available there
+        target_module.singleton_class.extend(ClassMethods)
+      end
+    end
+
+    # These actually go on the YourClass.singleton_class.singleton_class
+    # @requires_ancestor: MethodDefRecorder
+    module ClassMethods
+      #: () -> [Symbol, bool]?
+      def __last_method_def
+        #: self as Class[MethodDefRecorder]
+        cls = attached_object #: as MethodDefRecorder
+        cls.__last_method_def
+      end
+    end
+
+    # Need `@without_runtime` because of https://github.com/Shopify/tapioca/issues/2513
+    # @without_runtime
+    #: (Symbol) -> void
+    def method_added(m)
+      is_singleton_method = false
+      @__last_method_def = [m, is_singleton_method] #: [Symbol, bool]?
+
+      super
+    end
+
+    # Need `@without_runtime` because of https://github.com/Shopify/tapioca/issues/2513
+    # @without_runtime
+    # @override
+    #: (Symbol) -> void
+    def singleton_method_added(m)
+      return super if m == :singleton_method_added
+
+      is_singleton_method = true
+      @__last_method_def = [m, is_singleton_method] #: [Symbol, bool]?
+
+      super
+    end
+  end
+end

data/lib/type_toolkit/method_patch.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypeToolkit
+  # @requires_ancestor: MethodOrUnboundMethod
+  module MethodPatch
+    # Returns true if this method is an abstract method that hasn't been implemented.
+    # Calling it will raise an `AbstractMethodNotImplementedError`.
+    #: -> bool
+    def abstract?
+      return false unless TypeToolkit::HasAbstractMethods === (owner = self.owner)
+
+      owner.abstract_method?(name)
+    end
+  end
+end

data/lib/type_toolkit/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module TypeToolkit
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/lib/type_toolkit.rb

@@ -2,6 +2,9 @@
 # frozen_string_literal: true
 
 require_relative "type_toolkit/version"
+require_relative "type_toolkit/interface"
+require_relative "type_toolkit/ext/method"
+require_relative "type_toolkit/ext/module"
 require_relative "type_toolkit/ext/nil_assertions"
 
 module TypeToolkit

data/sorbet/config

@@ -3,5 +3,7 @@
 --ignore=tmp/
 --ignore=vendor/
 --enable-experimental-rbs-comments
+--enable-experimental-requires-ancestor
 --suppress-payload-superclass-redefinition-for=RDoc::Markup::Heading
---disable-watchman
+--suppress-error-code=5022
+--parser=prism