tapioca 0.4.26 → 0.5.0

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,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)
 
       gemfile.require_bundle
@@ -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,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

data/lib/tapioca/reflection.rb

@@ -0,0 +1,131 @@
+# 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)
+
+    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_METHOD.bind(constant).call
+    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
+
+    # 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