tapioca 0.4.23 → 0.5.0

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

@@ -4,22 +4,14 @@
 require "tapioca"
 require "tapioca/loader"
 require "tapioca/constant_locator"
-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/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,19 +5,13 @@ 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
-      load_rake
+      gemfile.require_bundle
 
-      require_bundle
+      load_rails_application
 
       require_helper(require_file)
 
@@ -25,14 +19,11 @@ module Tapioca
     end
 
     sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
-    def load_rails(environment_load: false, eager_load: false)
+    def load_rails_application(environment_load: false, eager_load: false)
       return unless File.exist?("config/application.rb")
 
-      safe_require("rails")
-
       silence_deprecations
 
-      safe_require("rails/generators/test_case")
       if environment_load
         safe_require("./config/environment")
       else
@@ -44,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
@@ -56,25 +44,12 @@ module Tapioca
       require(file)
     end
 
-    sig { void }
-    def require_bundle
-      gemfile.require
-    end
-
     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 }
@@ -84,11 +59,6 @@ module Tapioca
       nil
     end
 
-    sig { void }
-    def load_rake
-      safe_require("rake")
-    end
-
     sig { void }
     def silence_deprecations
       # Stop any ActiveSupport Deprecations from being reported
@@ -130,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,122 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rbi"
+
+module RBI
+  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