tapioca 0.4.27 → 0.5.3

data/lib/tapioca/compilers/dsl/base.rb

@@ -1,23 +1,31 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
+require "tapioca/rbi_ext/model"
 
 module Tapioca
   module Compilers
     module Dsl
+      COMPILERS_PATH = T.let(File.expand_path("..", __FILE__).to_s, String)
+
       class Base
         extend T::Sig
         extend T::Helpers
 
+        include Reflection
+
         abstract!
 
         sig { returns(T::Set[Module]) }
         attr_reader :processable_constants
 
+        sig { returns(T::Array[String]) }
+        attr_reader :errors
+
         sig { void }
         def initialize
           @processable_constants = T.let(Set.new(gather_constants), T::Set[Module])
+          @errors = T.let([], T::Array[String])
         end
 
         sig { params(constant: Module).returns(T::Boolean) }
@@ -29,65 +37,117 @@ module Tapioca
           abstract
             .type_parameters(:T)
             .params(
-              root: Parlour::RbiGenerator::Namespace,
+              tree: RBI::Tree,
               constant: T.type_parameter(:T)
             )
             .void
         end
-        def decorate(root, constant); end
+        def decorate(tree, constant); end
 
         sig { abstract.returns(T::Enumerable[Module]) }
         def gather_constants; end
 
-        private
+        # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
+        sig { params(error: String).void }
+        def add_error(error)
+          @errors << error
+        end
 
-        SPECIAL_METHOD_NAMES = T.let(
-          %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `].freeze,
-          T::Array[String]
-        )
+        private
 
-        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:]]*[?!=]?$/)
+        sig { returns(T::Enumerable[Class]) }
+        def all_classes
+          @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[Class]))
+          @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class]).each
         end
 
-        sig do
-          params(
-            namespace: Parlour::RbiGenerator::Namespace,
-            name: String,
-            options: T::Hash[T.untyped, T.untyped]
-          ).void
-        end
-        def create_method(namespace, name, options = {})
-          return unless valid_method_name?(name)
-          T.unsafe(namespace).create_method(name, **options)
+        sig { returns(T::Enumerable[Module]) }
+        def all_modules
+          @all_modules = T.let(@all_modules, T.nilable(T::Enumerable[Module]))
+          @all_modules ||= T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each
         end
 
-        # Create a Parlour method inside `namespace` from its Ruby definition
+        # Get the types of each parameter from a method signature
         sig do
           params(
-            namespace: Parlour::RbiGenerator::Namespace,
             method_def: T.any(Method, UnboundMethod),
-            class_method: T::Boolean
-          ).void
+            signature: T.untyped # as `T::Private::Methods::Signature` is private
+          ).returns(T::Array[String])
         end
-        def create_method_from_def(namespace, method_def, class_method: false)
-          create_method(
-            namespace,
+        def parameters_types_from_signature(method_def, signature)
+          params = T.let([], T::Array[String])
+
+          return method_def.parameters.map { "T.untyped" } unless signature
+
+          # parameters types
+          signature.arg_types.each { |arg_type| params << arg_type[1].to_s }
+
+          # keyword parameters types
+          signature.kwarg_types.each { |_, kwarg_type| params << kwarg_type.to_s }
+
+          # rest parameter type
+          params << signature.rest_type.to_s if signature.has_rest
+
+          # special case `.void` in a proc
+          unless signature.block_name.nil?
+            params << signature.block_type.to_s.gsub("returns(<VOID>)", "void")
+          end
+
+          params
+        end
+
+        sig { params(scope: RBI::Scope, method_def: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
+        def create_method_from_def(scope, method_def, class_method: false)
+          scope.create_method(
             method_def.name.to_s,
-            parameters: compile_method_parameters_to_parlour(method_def),
-            return_type: compile_method_return_type_to_parlour(method_def),
+            parameters: compile_method_parameters_to_rbi(method_def),
+            return_type: compile_method_return_type_to_rbi(method_def),
             class_method: class_method
           )
         end
 
-        # Compile a Ruby method parameters into Parlour parameters
-        sig do
-          params(method_def: T.any(Method, UnboundMethod))
-            .returns(T::Array[Parlour::RbiGenerator::Parameter])
+        sig { params(name: String, type: String).returns(RBI::TypedParam) }
+        def create_param(name, type:)
+          create_typed_param(RBI::Param.new(name), type)
+        end
+
+        sig { params(name: String, type: String, default: String).returns(RBI::TypedParam) }
+        def create_opt_param(name, type:, default:)
+          create_typed_param(RBI::OptParam.new(name, default), type)
+        end
+
+        sig { params(name: String, type: String).returns(RBI::TypedParam) }
+        def create_rest_param(name, type:)
+          create_typed_param(RBI::RestParam.new(name), type)
+        end
+
+        sig { params(name: String, type: String).returns(RBI::TypedParam) }
+        def create_kw_param(name, type:)
+          create_typed_param(RBI::KwParam.new(name), type)
         end
-        def compile_method_parameters_to_parlour(method_def)
+
+        sig { params(name: String, type: String, default: String).returns(RBI::TypedParam) }
+        def create_kw_opt_param(name, type:, default:)
+          create_typed_param(RBI::KwOptParam.new(name, default), type)
+        end
+
+        sig { params(name: String, type: String).returns(RBI::TypedParam) }
+        def create_kw_rest_param(name, type:)
+          create_typed_param(RBI::KwRestParam.new(name), type)
+        end
+
+        sig { params(name: String, type: String).returns(RBI::TypedParam) }
+        def create_block_param(name, type:)
+          create_typed_param(RBI::BlockParam.new(name), type)
+        end
+
+        sig { params(param: RBI::Param, type: String).returns(RBI::TypedParam) }
+        def create_typed_param(param, type)
+          RBI::TypedParam.new(param: param, type: type)
+        end
+
+        sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
+        def compile_method_parameters_to_rbi(method_def)
           signature = T::Private::Methods.signature_for_method(method_def)
           method_def = signature.nil? ? method_def : signature.method
           method_types = parameters_types_from_signature(method_def, signature)
@@ -97,72 +157,38 @@ module Tapioca
 
             name ||= fallback_arg_name
             name = name.to_s.gsub(/&|\*/, fallback_arg_name) # avoid incorrect names from `delegate`
-            method_type = method_types[index]
+            method_type = T.must(method_types[index])
 
             case type
             when :req
-              ::Parlour::RbiGenerator::Parameter.new(name, type: method_type)
+              create_param(name, type: method_type)
             when :opt
-              ::Parlour::RbiGenerator::Parameter.new(name, type: method_type, default: 'T.unsafe(nil)')
+              create_opt_param(name, type: method_type, default: "T.unsafe(nil)")
             when :rest
-              ::Parlour::RbiGenerator::Parameter.new("*#{name}", type: method_type)
+              create_rest_param(name, type: method_type)
             when :keyreq
-              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_type)
+              create_kw_param(name, type: method_type)
             when :key
-              ::Parlour::RbiGenerator::Parameter.new("#{name}:", type: method_type, default: 'T.unsafe(nil)')
+              create_kw_opt_param(name, type: method_type, default: "T.unsafe(nil)")
             when :keyrest
-              ::Parlour::RbiGenerator::Parameter.new("**#{name}", type: method_type)
+              create_kw_rest_param(name, type: method_type)
             when :block
-              ::Parlour::RbiGenerator::Parameter.new("&#{name}", type: method_type)
+              create_block_param(name, type: method_type)
             else
               raise "Unknown type `#{type}`."
             end
           end
         end
 
-        # Compile a Ruby method return type into a Parlour type
-        sig do
-          params(method_def: T.any(Method, UnboundMethod))
-            .returns(T.nilable(String))
-        end
-        def compile_method_return_type_to_parlour(method_def)
+        sig { params(method_def: T.any(Method, UnboundMethod)).returns(String) }
+        def compile_method_return_type_to_rbi(method_def)
           signature = T::Private::Methods.signature_for_method(method_def)
-          return_type = signature.nil? ? 'T.untyped' : signature.return_type.to_s
-          # Map <VOID> to `nil` since `nil` means a `void` return for Parlour
-          return_type = nil if return_type == "<VOID>"
+          return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)
+          return_type = "void" if return_type == "<VOID>"
           # Map <NOT-TYPED> to `T.untyped`
           return_type = "T.untyped" if return_type == "<NOT-TYPED>"
           return_type
         end
-
-        # Get the types of each parameter from a method signature
-        sig do
-          params(
-            method_def: T.any(Method, UnboundMethod),
-            signature: T.untyped # as `T::Private::Methods::Signature` is private
-          ).returns(T::Array[String])
-        end
-        def parameters_types_from_signature(method_def, signature)
-          params = T.let([], T::Array[String])
-
-          return method_def.parameters.map { 'T.untyped' } unless signature
-
-          # parameters types
-          signature.arg_types.each { |arg_type| params << arg_type[1].to_s }
-
-          # keyword parameters types
-          signature.kwarg_types.each { |_, kwarg_type| params << kwarg_type.to_s }
-
-          # rest parameter type
-          params << signature.rest_type.to_s if signature.has_rest
-
-          # special case `.void` in a proc
-          unless signature.block_name.nil?
-            params << signature.block_type.to_s.gsub('returns(<VOID>)', 'void')
-          end
-
-          params
-        end
       end
     end
   end

data/lib/tapioca/compilers/dsl/config.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "config"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::Config` generates RBI files for classes generated by the
+      # [`config`](https://github.com/rubyconfig/config) gem.
+      #
+      # The gem creates a `Config::Options` instance based on the settings files and/or
+      # env variables. It then assigns this instance to a constant with a configurable name,
+      # by default `Settings`. Application code uses methods on this constant to read off
+      # config values.
+      #
+      # For a setting file like the following:
+      # ```yaml
+      # ---
+      # github:
+      #   token: 12345
+      #   client_id: 54321
+      #   client_secret: super_secret
+      # ```
+      # and a `Config` setup like:
+      # ```ruby
+      # Config.setup do |config|
+      #   config.const_name = "AppSettings"
+      # end
+      # ```
+      # this generator will produce the following RBI file:
+      # ```rbi
+      # AppSettings = T.let(T.unsafe(nil), AppSettingsConfigOptions)
+      #
+      # class AppSettingsConfigOptions < ::Config::Options
+      #   sig { returns(T.untyped) }
+      #   def github; end
+      #
+      #   sig { params(value: T.untyped).returns(T.untyped) }
+      #   def github=(value); end
+      # end
+      # ```
+      class Config < Base
+        extend T::Sig
+
+        CONFIG_OPTIONS_SUFFIX = "ConfigOptions"
+
+        sig { override.params(root: RBI::Tree, constant: Module).void }
+        def decorate(root, constant)
+          # The constant we are given is the specialized config options type
+          option_class_name = constant.name
+          return unless option_class_name
+
+          # Grab the config constant name and the actual config constant
+          config_constant_name = option_class_name
+            .gsub(/#{CONFIG_OPTIONS_SUFFIX}$/, "")
+          config_constant = Object.const_get(config_constant_name)
+
+          # Look up method names from the keys of the config constant
+          method_names = config_constant.keys
+
+          return if method_names.empty?
+
+          root.create_constant(config_constant_name, value: "T.let(T.unsafe(nil), #{option_class_name})")
+
+          root.create_class(option_class_name, superclass_name: "::Config::Options") do |mod|
+            # We need this to be generic only becuase `Config::Options` is an
+            # enumerable and, thus, needs to redeclare the `Elem` type member.
+            #
+            # We declare it as a fixed member of `T.untyped` so that if anyone
+            # enumerates the entries, we don't make any assumptions about their
+            # types.
+            mod.create_extend("T::Generic")
+            mod.create_type_member("Elem", value: "type_member(fixed: T.untyped)")
+
+            method_names.each do |method_name|
+              # Create getter method
+              mod.create_method(
+                method_name.to_s,
+                return_type: "T.untyped"
+              )
+
+              # Create setter method
+              mod.create_method(
+                "#{method_name}=",
+                parameters: [create_param("value", type: "T.untyped")],
+                return_type: "T.untyped"
+              )
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          name = ::Config.const_name
+          return [] unless Object.const_defined?(name)
+
+          config_object = Object.const_get(name)
+          options_class_name = "#{name}#{CONFIG_OPTIONS_SUFFIX}"
+          Object.const_set(options_class_name, config_object.singleton_class)
+
+          Array(config_object.singleton_class)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl/frozen_record.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "frozen_record"
 rescue LoadError
@@ -67,18 +65,18 @@ module Tapioca
       class FrozenRecord < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::FrozenRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::FrozenRecord::Base)).void }
         def decorate(root, constant)
           attributes = constant.attributes
           return if attributes.empty?
 
-          root.path(constant) do |record|
+          root.create_path(constant) do |record|
             module_name = "FrozenRecordAttributeMethods"
 
             record.create_module(module_name) do |mod|
               attributes.each do |attribute|
-                create_method(mod, "#{attribute}?", return_type: 'T::Boolean')
-                create_method(mod, attribute.to_s, return_type: 'T.untyped')
+                mod.create_method("#{attribute}?", return_type: "T::Boolean")
+                mod.create_method(attribute.to_s, return_type: "T.untyped")
               end
             end
 
@@ -88,7 +86,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::FrozenRecord::Base.descendants.reject(&:abstract_class?)
+          descendants_of(::FrozenRecord::Base).reject(&:abstract_class?)
         end
       end
     end

data/lib/tapioca/compilers/dsl/identity_cache.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "rails/railtie"
   require "identity_cache"
@@ -67,23 +65,16 @@ module Tapioca
 
         COLLECTION_TYPE = T.let(
           ->(type) { "T::Array[::#{type}]" },
-          T.proc.params(type: Module).returns(String)
+          T.proc.params(type: T.any(Module, String)).returns(String)
         )
 
-        sig do
-          override
-            .params(
-              root: Parlour::RbiGenerator::Namespace,
-              constant: T.class_of(::ActiveRecord::Base)
-            )
-            .void
-        end
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveRecord::Base)).void }
         def decorate(root, constant)
           caches = constant.send(:all_cached_associations)
           cache_indexes = constant.send(:cache_indexes)
           return if caches.empty? && cache_indexes.empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             cache_manys = constant.send(:cached_has_manys)
             cache_ones = constant.send(:cached_has_ones)
             cache_belongs = constant.send(:cached_belongs_tos)
@@ -108,7 +99,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveRecord::Base.descendants.select do |klass|
+          descendants_of(::ActiveRecord::Base).select do |klass|
             klass < ::IdentityCache::WithoutPrimaryIndex
           end
         end
@@ -119,8 +110,7 @@ module Tapioca
           params(
             field: T.untyped,
             returns_collection: T::Boolean
-          )
-            .returns(String)
+          ).returns(String)
         end
         def type_for_field(field, returns_collection:)
           cache_type = field.reflection.compute_class(field.reflection.class_name)
@@ -136,10 +126,9 @@ module Tapioca
         sig do
           params(
             field: T.untyped,
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             returns_collection: T::Boolean
-          )
-            .void
+          ).void
         end
         def create_fetch_field_methods(field, klass, returns_collection:)
           name = field.cached_accessor_name.to_s
@@ -156,21 +145,36 @@ module Tapioca
         sig do
           params(
             field: T.untyped,
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             constant: T.class_of(::ActiveRecord::Base),
-          )
-            .void
+          ).void
         end
         def create_fetch_by_methods(field, klass, constant)
+          is_cache_index = field.instance_variable_defined?(:@attribute_proc)
+
+          # Both `cache_index` and `cache_attribute` generate aliased methods
+          create_aliased_fetch_by_methods(field, klass, constant)
+
+          # If the method used was `cache_index` a few extra methods are created
+          create_index_fetch_by_methods(field, klass, constant) if is_cache_index
+        end
+
+        sig do
+          params(
+            field: T.untyped,
+            klass: RBI::Scope,
+            constant: T.class_of(::ActiveRecord::Base),
+          ).void
+        end
+        def create_index_fetch_by_methods(field, klass, constant)
           field_length = field.key_fields.length
           fields_name = field.key_fields.join("_and_")
-
+          name = "fetch_by_#{fields_name}"
           parameters = field.key_fields.map do |arg|
-            Parlour::RbiGenerator::Parameter.new(arg.to_s, type: "T.untyped")
+            create_param(arg.to_s, type: "T.untyped")
           end
-          parameters << Parlour::RbiGenerator::Parameter.new("includes:", default: "nil", type: "T.untyped")
+          parameters << create_kw_opt_param("includes", default: "nil", type: "T.untyped")
 
-          name = "fetch_by_#{fields_name}"
           if field.unique
             klass.create_method(
               "#{name}!",
@@ -195,18 +199,51 @@ module Tapioca
           end
 
           if field_length == 1
-            name = "fetch_multi_by_#{fields_name}"
             klass.create_method(
-              name,
+              "fetch_multi_by_#{fields_name}",
               class_method: true,
               parameters: [
-                Parlour::RbiGenerator::Parameter.new("index_values", type: "T.untyped"),
-                Parlour::RbiGenerator::Parameter.new("includes:", default: "nil", type: "T.untyped"),
+                create_param("index_values", type: "T::Enumerable[T.untyped]"),
+                create_kw_opt_param("includes", default: "nil", type: "T.untyped"),
               ],
               return_type: COLLECTION_TYPE.call(constant)
             )
           end
         end
+
+        sig do
+          params(
+            field: T.untyped,
+            klass: RBI::Scope,
+            constant: T.class_of(::ActiveRecord::Base),
+          ).void
+        end
+        def create_aliased_fetch_by_methods(field, klass, constant)
+          type, _ = ActiveRecordColumnTypeHelper.new(constant).type_for(field.alias_name.to_s)
+          multi_type = type.delete_prefix("T.nilable(").delete_suffix(")").delete_prefix("::")
+          length = field.key_fields.length
+          suffix = field.send(:fetch_method_suffix)
+
+          parameters = field.key_fields.map do |arg|
+            create_param(arg.to_s, type: "T.untyped")
+          end
+
+          klass.create_method(
+            "fetch_#{suffix}",
+            class_method: true,
+            parameters: parameters,
+            return_type: type
+          )
+
+          if length == 1
+            klass.create_method(
+              "fetch_multi_#{suffix}",
+              class_method: true,
+              parameters: [create_param("keys", type: "T::Enumerable[T.untyped]")],
+              return_type: COLLECTION_TYPE.call(multi_type)
+            )
+          end
+        end
       end
     end
   end

data/lib/tapioca/compilers/dsl/mixed_in_class_attributes.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_support/core_ext/class/attribute"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::MixedInClassAttributes` generates RBI files for modules that dynamically use
+      # `class_attribute` on classes.
+      #
+      # For example, given the following concern
+      #
+      # ~~~rb
+      # module Taggeable
+      #   extend ActiveSupport::Concern
+      #
+      #   included do
+      #     class_attribute :tag
+      #   end
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `taggeable.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # typed: strong
+      #
+      # module Taggeable
+      #   include GeneratedInstanceMethods
+      #
+      #   mixes_in_class_methods GeneratedClassMethods
+      #
+      #   module GeneratedClassMethods
+      #     def tag; end
+      #     def tag=(value); end
+      #     def tag?; end
+      #   end
+      #
+      #   module GeneratedInstanceMethods
+      #     def tag; end
+      #     def tag=(value); end
+      #     def tag?; end
+      #   end
+      # end
+      # ~~~
+      class MixedInClassAttributes < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: Module).void }
+        def decorate(root, constant)
+          mixin_compiler = DynamicMixinCompiler.new(constant)
+          return if mixin_compiler.empty_attributes?
+
+          root.create_path(constant) do |mod|
+            mixin_compiler.compile_class_attributes(mod)
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          # Select all non-anonymous modules that have overridden Module.included
+          all_modules.select do |mod|
+            !mod.is_a?(Class) && name_of(mod) && Tapioca::Reflection.method_of(mod, :included).owner != Module
+          end
+        end
+      end
+    end
+  end
+end