tapioca 0.4.27 → 0.5.3

data/lib/tapioca/generic_type_registry.rb

@@ -20,14 +20,15 @@ module Tapioca
   # variable to type variable serializers. This allows us to associate type variables
   # to the constant names that represent them, easily.
   module GenericTypeRegistry
+    TypeVariable = T.type_alias { T.any(TypeMember, TypeTemplate) }
     @generic_instances = T.let(
       {},
       T::Hash[String, Module]
     )
 
     @type_variables = T.let(
-      {},
-      T::Hash[Integer, T::Hash[Integer, String]]
+      {}.compare_by_identity,
+      T::Hash[Module, T::Hash[TypeVariable, String]]
     )
 
     class << self
@@ -49,7 +50,7 @@ module Tapioca
         # Build the name of the instantiated generic type,
         # something like `"Foo[X, Y, Z]"`
         type_list = types.map { |type| T::Utils.coerce(type).name }.join(", ")
-        name = "#{name_of(constant)}[#{type_list}]"
+        name = "#{Reflection.name_of(constant)}[#{type_list}]"
 
         # Create a generic type with an overridden `name`
         # method that returns the name we constructed above.
@@ -59,35 +60,30 @@ module Tapioca
         @generic_instances[name] ||= create_generic_type(constant, name)
       end
 
-      sig do
-        params(
-          constant: T.untyped,
-          type_member: T::Types::TypeVariable,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
-        ).void
-      end
-      def register_type_member(constant, type_member, fixed, lower, upper)
-        register_type_variable(constant, :type_member, type_member, fixed, lower, upper)
+      sig { params(constant: Module).returns(T.nilable(T::Hash[TypeVariable, String])) }
+      def lookup_type_variables(constant)
+        @type_variables[constant]
       end
 
+      # This method is called from intercepted calls to `type_member` and `type_template`.
+      # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+      # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+      #
+      # This method creates a `String` with that data and stores it in the
+      # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+      #
+      # Finally, the original `type_variable` is returned from this method, so that the caller
+      # can return it from the original methods as well.
       sig do
         params(
           constant: T.untyped,
-          type_template: T::Types::TypeVariable,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
+          type_variable: TypeVariable,
         ).void
       end
-      def register_type_template(constant, type_template, fixed, lower, upper)
-        register_type_variable(constant, :type_template, type_template, fixed, lower, upper)
-      end
+      def register_type_variable(constant, type_variable)
+        type_variables = lookup_or_initialize_type_variables(constant)
 
-      sig { params(constant: Module).returns(T.nilable(T::Hash[Integer, String])) }
-      def lookup_type_variables(constant)
-        @type_variables[object_id_of(constant)]
+        type_variables[type_variable] = type_variable.serialize
       end
 
       private
@@ -117,39 +113,6 @@ module Tapioca
         generic_type
       end
 
-      # This method is called from intercepted calls to `type_member` and `type_template`.
-      # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
-      # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
-      #
-      # This method creates a `String` with that data and stores it in the
-      # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
-      #
-      # Finally, the original `type_variable` is returned from this method, so that the caller
-      # can return it from the original methods as well.
-      sig do
-        params(
-          constant: T.untyped,
-          type_variable_type: T.enum([:type_member, :type_template]),
-          type_variable: T::Types::TypeVariable,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
-        ).void
-      end
-      # rubocop:disable Metrics/ParameterLists
-      def register_type_variable(constant, type_variable_type, type_variable, fixed, lower, upper)
-        # rubocop:enable Metrics/ParameterLists
-        type_variables = lookup_or_initialize_type_variables(constant)
-
-        type_variables[object_id_of(type_variable)] = serialize_type_variable(
-          type_variable_type,
-          type_variable.variance,
-          fixed,
-          lower,
-          upper
-        )
-      end
-
       sig { params(constant: Class).returns(Class) }
       def create_safe_subclass(constant)
         # Lookup the "inherited" class method
@@ -164,11 +127,9 @@ module Tapioca
           # Otherwise, some inherited method could be preventing us
           # from creating subclasses, so let's override it and rescue
           owner.send(:define_method, :inherited) do |s|
-            begin
-              inherited_method.call(s)
-            rescue
-              # Ignoring errors
-            end
+            inherited_method.call(s)
+          rescue
+            # Ignoring errors
           end
 
           # return a subclass
@@ -179,43 +140,9 @@ module Tapioca
         end
       end
 
-      sig { params(constant: Module).returns(T::Hash[Integer, String]) }
+      sig { params(constant: Module).returns(T::Hash[TypeVariable, String]) }
       def lookup_or_initialize_type_variables(constant)
-        @type_variables[object_id_of(constant)] ||= {}
-      end
-
-      sig do
-        params(
-          type_variable_type: Symbol,
-          variance: Symbol,
-          fixed: T.untyped,
-          lower: T.untyped,
-          upper: T.untyped
-        ).returns(String)
-      end
-      def serialize_type_variable(type_variable_type, variance, fixed, lower, upper)
-        parts = []
-        parts << ":#{variance}" unless variance == :invariant
-        parts << "fixed: #{fixed}" if fixed
-        parts << "lower: #{lower}" unless lower == T.untyped
-        parts << "upper: #{upper}" unless upper == BasicObject
-
-        parameters = parts.join(", ")
-
-        serialized = T.let(type_variable_type.to_s, String)
-        serialized += "(#{parameters})" unless parameters.empty?
-
-        serialized
-      end
-
-      sig { params(constant: Module).returns(T.nilable(String)) }
-      def name_of(constant)
-        Module.instance_method(:name).bind(constant).call
-      end
-
-      sig { params(object: BasicObject).returns(Integer) }
-      def object_id_of(object)
-        Object.instance_method(:object_id).bind(object).call
+        @type_variables[constant] ||= {}.compare_by_identity
       end
     end
   end

data/lib/tapioca/helpers/active_record_column_type_helper.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+class ActiveRecordColumnTypeHelper
+  extend T::Sig
+
+  sig { params(constant: T.class_of(ActiveRecord::Base)).void }
+  def initialize(constant)
+    @constant = constant
+  end
+
+  sig { params(column_name: String).returns([String, String]) }
+  def type_for(column_name)
+    return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(@constant)
+
+    column_type = @constant.attribute_types[column_name]
+
+    getter_type =
+      case column_type
+      when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
+        "::Money"
+      when ActiveRecord::Type::Integer
+        "::Integer"
+      when ActiveRecord::Type::String
+        "::String"
+      when ActiveRecord::Type::Date
+        "::Date"
+      when ActiveRecord::Type::Decimal
+        "::BigDecimal"
+      when ActiveRecord::Type::Float
+        "::Float"
+      when ActiveRecord::Type::Boolean
+        "T::Boolean"
+      when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
+        "::DateTime"
+      when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
+        "::ActiveSupport::TimeWithZone"
+      else
+        handle_unknown_type(column_type)
+      end
+
+    column = @constant.columns_hash[column_name]
+    setter_type = getter_type
+
+    if column&.null
+      return ["T.nilable(#{getter_type})", "T.nilable(#{setter_type})"]
+    end
+
+    if column_name == @constant.primary_key ||
+        column_name == "created_at" ||
+        column_name == "updated_at"
+      getter_type = "T.nilable(#{getter_type})"
+    end
+
+    [getter_type, setter_type]
+  end
+
+  private
+
+  sig { params(constant: Module).returns(T::Boolean) }
+  def do_not_generate_strong_types?(constant)
+    Object.const_defined?(:StrongTypeGeneration) &&
+        !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
+  end
+
+  sig { params(column_type: Object).returns(String) }
+  def handle_unknown_type(column_type)
+    return "T.untyped" unless ActiveModel::Type::Value === column_type
+
+    lookup_return_type_of_method(column_type, :deserialize) ||
+      lookup_return_type_of_method(column_type, :cast) ||
+      lookup_arg_type_of_method(column_type, :serialize) ||
+      "T.untyped"
+  end
+
+  sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
+  def lookup_return_type_of_method(column_type, method)
+    signature = T::Private::Methods.signature_for_method(column_type.method(method))
+    return unless signature
+
+    return_type = signature.return_type
+    return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
+
+    return_type.to_s
+  end
+
+  sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
+  def lookup_arg_type_of_method(column_type, method)
+    signature = T::Private::Methods.signature_for_method(column_type.method(method))
+    return unless signature
+
+    # Arg types is an array [name, type] entries, so we desctructure the type of
+    # first argument to get the first argument type
+    _, first_argument_type = signature.arg_types.first
+
+    first_argument_type.to_s
+  end
+end

data/lib/tapioca/internal.rb

@@ -3,22 +3,14 @@
 
 require "tapioca"
 require "tapioca/loader"
-require "tapioca/generic_type_registry"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/fixed_hash_patch"
+require "tapioca/generic_type_registry"
 require "tapioca/config"
 require "tapioca/config_builder"
-require "tapioca/generator"
+require "tapioca/generators"
 require "tapioca/cli"
-require "tapioca/cli/main"
 require "tapioca/gemfile"
-require "tapioca/rbi/model"
-require "tapioca/rbi/visitor"
-require "tapioca/rbi/rewriters/nest_singleton_methods"
-require "tapioca/rbi/rewriters/nest_non_public_methods"
-require "tapioca/rbi/rewriters/group_nodes"
-require "tapioca/rbi/rewriters/sort_nodes"
-require "tapioca/rbi/printer"
 require "tapioca/compilers/sorbet"
 require "tapioca/compilers/requires_compiler"
 require "tapioca/compilers/symbol_table_compiler"

data/lib/tapioca/loader.rb

@@ -5,13 +5,8 @@ module Tapioca
   class Loader
     extend(T::Sig)
 
-    sig { params(gemfile: Tapioca::Gemfile).void }
-    def initialize(gemfile)
-      @gemfile = T.let(gemfile, Tapioca::Gemfile)
-    end
-
-    sig { params(initialize_file: T.nilable(String), require_file: T.nilable(String)).void }
-    def load_bundle(initialize_file, require_file)
+    sig { params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void }
+    def load_bundle(gemfile, initialize_file, require_file)
       require_helper(initialize_file)
 
       load_rails_application
@@ -40,9 +35,6 @@ module Tapioca
 
     private
 
-    sig { returns(Tapioca::Gemfile) }
-    attr_reader :gemfile
-
     sig { params(file: T.nilable(String)).void }
     def require_helper(file)
       return unless file
@@ -54,18 +46,10 @@ module Tapioca
 
     sig { returns(T::Array[T.untyped]) }
     def rails_engines
-      engines = []
-
-      return engines unless Object.const_defined?("Rails::Engine")
-
-      base = Object.const_get("Rails::Engine")
-      ObjectSpace.each_object(base.singleton_class) do |k|
-        k = T.cast(k, Class)
-        next if k.singleton_class?
-        engines.unshift(k) unless k == base
-      end
+      return [] unless Object.const_defined?("Rails::Engine")
 
-      engines.reject(&:abstract_railtie?)
+      # We can use `Class#descendants` here, since we know Rails is loaded
+      Object.const_get("Rails::Engine").descendants.reject(&:abstract_railtie?)
     end
 
     sig { params(path: String).void }
@@ -116,22 +100,18 @@ module Tapioca
 
         engine.config.eager_load_paths.each do |load_path|
           Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
-            begin
-              require(file)
-            rescue LoadError, StandardError
-              errored_files << file
-            end
+            require(file)
+          rescue LoadError, StandardError
+            errored_files << file
           end
         end
 
         # Try files that have errored one more time
         # It might have been a load order problem
         errored_files.each do |file|
-          begin
-            require(file)
-          rescue LoadError, StandardError
-            nil
-          end
+          require(file)
+        rescue LoadError, StandardError
+          nil
         end
       end
     end

data/lib/tapioca/rbi_ext/model.rb

@@ -0,0 +1,166 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rbi"
+
+module RBI
+  class File
+    extend T::Sig
+
+    sig { returns(String) }
+    def transformed_string
+      transform_rbi!
+      string
+    end
+
+    sig { void }
+    def transform_rbi!
+      root.nest_singleton_methods!
+      root.nest_non_public_methods!
+      root.group_nodes!
+      root.sort_nodes!
+    end
+
+    sig do
+      params(
+        command: String,
+        reason: T.nilable(String),
+        display_heading: T::Boolean
+      ).void
+    end
+    def set_file_header(command, reason: nil, display_heading: true)
+      return unless display_heading
+      comments << RBI::Comment.new("DO NOT EDIT MANUALLY")
+      comments << RBI::Comment.new("This is an autogenerated file for #{reason}.") unless reason.nil?
+      comments << RBI::Comment.new("Please instead update this file by running `#{command}`.")
+    end
+
+    sig { void }
+    def set_empty_body_content
+      comments << RBI::EmptyComment.new unless comments.empty?
+      comments << RBI::Comment.new("THIS IS AN EMPTY RBI FILE.")
+      comments << RBI::Comment.new("see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires")
+    end
+
+    sig { returns(T::Boolean) }
+    def empty?
+      root.empty?
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: Scope).void)).void }
+    def create_path(constant, &block)
+      constant_name = Tapioca::Reflection.name_of(constant)
+      raise "given constant does not have a name" unless constant_name
+
+      instance = ::Module.const_get(constant_name)
+      case instance
+      when ::Class
+        create_class(constant.to_s, &block)
+      when ::Module
+        create_module(constant.to_s, &block)
+      else
+        raise "unexpected type: #{constant_name} is a #{instance.class}"
+      end
+    end
+
+    sig { params(name: String, block: T.nilable(T.proc.params(scope: Scope).void)).void }
+    def create_module(name, &block)
+      node = create_node(RBI::Module.new(name))
+      block&.call(T.cast(node, RBI::Scope))
+    end
+
+    sig do
+      params(
+        name: String,
+        superclass_name: T.nilable(String),
+        block: T.nilable(T.proc.params(scope: RBI::Scope).void)
+      ).void
+    end
+    def create_class(name, superclass_name: nil, &block)
+      node = create_node(RBI::Class.new(name, superclass_name: superclass_name))
+      block&.call(T.cast(node, RBI::Scope))
+    end
+
+    sig { params(name: String, value: String).void }
+    def create_constant(name, value:)
+      create_node(RBI::Const.new(name, value))
+    end
+
+    sig { params(name: String).void }
+    def create_include(name)
+      create_node(RBI::Include.new(name))
+    end
+
+    sig { params(name: String).void }
+    def create_extend(name)
+      create_node(RBI::Extend.new(name))
+    end
+
+    sig { params(name: String).void }
+    def create_mixes_in_class_methods(name)
+      create_node(RBI::MixesInClassMethods.new(name))
+    end
+
+    sig { params(name: String, value: String).void }
+    def create_type_member(name, value: "type_member")
+      create_node(RBI::TypeMember.new(name, value))
+    end
+
+    sig do
+      params(
+        name: String,
+        parameters: T::Array[TypedParam],
+        return_type: String,
+        class_method: T::Boolean
+      ).void
+    end
+    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false)
+      return unless valid_method_name?(name)
+
+      sig = RBI::Sig.new(return_type: return_type)
+      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method)
+      parameters.each do |param|
+        method << param.param
+        sig << RBI::SigParam.new(param.param.name, param.type)
+      end
+      self << method
+    end
+
+    private
+
+    SPECIAL_METHOD_NAMES = T.let(
+      ["!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^", "<", "<=", "=>", ">", ">=",
+       "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"].freeze,
+      T::Array[String]
+    )
+
+    sig { params(name: String).returns(T::Boolean) }
+    def valid_method_name?(name)
+      return true if SPECIAL_METHOD_NAMES.include?(name)
+      !!name.match(/^[a-zA-Z_][[:word:]]*[?!=]?$/)
+    end
+
+    sig { returns(T::Hash[String, RBI::Node]) }
+    def nodes_cache
+      T.must(@nodes_cache ||= T.let({}, T.nilable(T::Hash[String, Node])))
+    end
+
+    sig { params(node: RBI::Node).returns(RBI::Node) }
+    def create_node(node)
+      cached = nodes_cache[node.to_s]
+      return cached if cached
+      nodes_cache[node.to_s] = node
+      self << node
+      node
+    end
+  end
+
+  class TypedParam < T::Struct
+    const :param, RBI::Param
+    const :type, String
+  end
+end

data/lib/tapioca/reflection.rb

@@ -0,0 +1,138 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Reflection
+    extend T::Sig
+    extend self
+
+    CLASS_METHOD = T.let(Kernel.instance_method(:class), UnboundMethod)
+    CONSTANTS_METHOD = T.let(Module.instance_method(:constants), UnboundMethod)
+    NAME_METHOD = T.let(Module.instance_method(:name), UnboundMethod)
+    SINGLETON_CLASS_METHOD = T.let(Object.instance_method(:singleton_class), UnboundMethod)
+    ANCESTORS_METHOD = T.let(Module.instance_method(:ancestors), UnboundMethod)
+    SUPERCLASS_METHOD = T.let(Class.instance_method(:superclass), UnboundMethod)
+    OBJECT_ID_METHOD = T.let(BasicObject.instance_method(:__id__), UnboundMethod)
+    EQUAL_METHOD = T.let(BasicObject.instance_method(:equal?), UnboundMethod)
+    PUBLIC_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:public_instance_methods), UnboundMethod)
+    PROTECTED_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:protected_instance_methods), UnboundMethod)
+    PRIVATE_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:private_instance_methods), UnboundMethod)
+    METHOD_METHOD = T.let(Kernel.instance_method(:method), UnboundMethod)
+
+    sig { params(object: BasicObject).returns(Class).checked(:never) }
+    def class_of(object)
+      CLASS_METHOD.bind(object).call
+    end
+
+    sig { params(constant: Module).returns(T::Array[Symbol]) }
+    def constants_of(constant)
+      CONSTANTS_METHOD.bind(constant).call(false)
+    end
+
+    sig { params(constant: Module).returns(T.nilable(String)) }
+    def name_of(constant)
+      name = NAME_METHOD.bind(constant).call
+      name&.start_with?("#<") ? nil : name
+    end
+
+    sig { params(constant: Module).returns(Class) }
+    def singleton_class_of(constant)
+      SINGLETON_CLASS_METHOD.bind(constant).call
+    end
+
+    sig { params(constant: Module).returns(T::Array[Module]) }
+    def ancestors_of(constant)
+      ANCESTORS_METHOD.bind(constant).call
+    end
+
+    sig { params(constant: Class).returns(T.nilable(Class)) }
+    def superclass_of(constant)
+      SUPERCLASS_METHOD.bind(constant).call
+    end
+
+    sig { params(object: BasicObject).returns(Integer).checked(:never) }
+    def object_id_of(object)
+      OBJECT_ID_METHOD.bind(object).call
+    end
+
+    sig { params(object: BasicObject, other: BasicObject).returns(T::Boolean).checked(:never) }
+    def are_equal?(object, other)
+      EQUAL_METHOD.bind(object).call(other)
+    end
+
+    sig { params(constant: Module).returns(T::Array[Symbol]) }
+    def public_instance_methods_of(constant)
+      PUBLIC_INSTANCE_METHODS_METHOD.bind(constant).call
+    end
+
+    sig { params(constant: Module).returns(T::Array[Symbol]) }
+    def protected_instance_methods_of(constant)
+      PROTECTED_INSTANCE_METHODS_METHOD.bind(constant).call
+    end
+
+    sig { params(constant: Module).returns(T::Array[Symbol]) }
+    def private_instance_methods_of(constant)
+      PRIVATE_INSTANCE_METHODS_METHOD.bind(constant).call
+    end
+
+    sig { params(constant: Module).returns(T::Array[Module]) }
+    def inherited_ancestors_of(constant)
+      if Class === constant
+        ancestors_of(superclass_of(constant) || Object)
+      else
+        Module.ancestors
+      end
+    end
+
+    sig { params(constant: Module).returns(T.nilable(String)) }
+    def qualified_name_of(constant)
+      name = name_of(constant)
+      return if name.nil?
+
+      if name.start_with?("::")
+        name
+      else
+        "::#{name}"
+      end
+    end
+
+    sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
+    def signature_of(method)
+      T::Private::Methods.signature_for_method(method)
+    rescue LoadError, StandardError
+      nil
+    end
+
+    sig { params(type: T::Types::Base).returns(String) }
+    def name_of_type(type)
+      type.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
+    end
+
+    sig { params(constant: Module, method: Symbol).returns(Method) }
+    def method_of(constant, method)
+      METHOD_METHOD.bind(constant).call(method)
+    end
+
+    # Returns an array with all classes that are < than the supplied class.
+    #
+    #   class C; end
+    #   descendants_of(C) # => []
+    #
+    #   class B < C; end
+    #   descendants_of(C) # => [B]
+    #
+    #   class A < B; end
+    #   descendants_of(C) # => [B, A]
+    #
+    #   class D < C; end
+    #   descendants_of(C) # => [B, A, D]
+    sig { type_parameters(:U).params(klass: T.type_parameter(:U)).returns(T::Array[T.type_parameter(:U)]) }
+    def descendants_of(klass)
+      result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
+        T.cast(k, Module).singleton_class? || T.unsafe(k) == klass
+      end
+
+      T.unsafe(result)
+    end
+  end
+end

data/lib/tapioca/sorbet_ext/fixed_hash_patch.rb

@@ -13,7 +13,7 @@ module T
           end
         end
 
-        "{#{entries.join(', ')}}"
+        "{#{entries.join(", ")}}"
       end
     end
   end