tapioca 0.4.23 → 0.5.0

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

@@ -0,0 +1,108 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/compilers/sorbet"
+
+begin
+  require "active_support"
+rescue LoadError
+  return
+end
+
+return unless Tapioca::Compilers::Sorbet.supports?(:mixes_in_class_methods_multiple_args)
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveSupportConcern` generates RBI files for classes that both `extend`
+      # `ActiveSupport::Concern` and `include` another class that extends `ActiveSupport::Concern`
+      #
+      # For example for the following hierarchy:
+      #
+      # ~~~rb
+      # # concern.rb
+      # module Foo
+      #  extend ActiveSupport::Concern
+      #  module ClassMethods; end
+      # end
+      #
+      # module Bar
+      #  extend ActiveSupport::Concern
+      #  module ClassMethods; end
+      #  include Foo
+      # end
+      #
+      # class Baz
+      #  include Bar
+      # end
+      # ~~~
+      #
+      # this generator will produce the RBI file `concern.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # typed: true
+      # module Bar
+      #   mixes_in_class_methods(::Foo::ClassMethods)
+      # end
+      # ~~~
+      class ActiveSupportConcern < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: Module).void }
+        def decorate(root, constant)
+          dependencies = linearized_dependencies_of(constant)
+
+          mixed_in_class_methods = dependencies
+            .uniq # Deduplicate
+            .map do |concern| # Map to class methods module name, if exists
+              "#{qualified_name_of(concern)}::ClassMethods" if concern.const_defined?(:ClassMethods)
+            end
+            .compact # Remove non-existent records
+
+          return if mixed_in_class_methods.empty?
+
+          root.create_path(constant) do |mod|
+            mixed_in_class_methods.each do |mix|
+              mod.create_mixes_in_class_methods(mix)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          # Find all Modules that are:
+          all_modules.select do |mod|
+            # named (i.e. not anonymous)
+            name_of(mod) &&
+              # not singleton classes
+              !mod.singleton_class? &&
+              # extend ActiveSupport::Concern, and
+              mod.singleton_class < ActiveSupport::Concern &&
+              # have dependencies (i.e. include another concern)
+              !dependencies_of(mod).empty?
+          end
+        end
+
+        private
+
+        sig { params(concern: Module).returns(T::Array[Module]) }
+        def dependencies_of(concern)
+          concern.instance_variable_get(:@_dependencies)
+        end
+
+        sig { params(concern: Module).returns(T::Array[Module]) }
+        def linearized_dependencies_of(concern)
+          # Grab all the dependencies of the concern
+          dependencies = dependencies_of(concern)
+
+          # Flatten this concern's dependencies and all of their dependencies
+          dependencies.flat_map do |dependency|
+            # Linearize dependencies of the current dependency,
+            # which, itself, is a concern
+            linearized_dependencies_of(dependency) << dependency
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,10 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_support"
+  # The following is needed due to https://github.com/rails/rails/pull/41610
+  require "active_support/core_ext/module/delegation"
 rescue LoadError
   return
 end
@@ -65,7 +65,7 @@ module Tapioca
         sig do
           override
             .params(
-              root: Parlour::RbiGenerator::Namespace,
+              root: RBI::Tree,
               constant: T.class_of(::ActiveSupport::CurrentAttributes)
             )
             .void
@@ -75,7 +75,7 @@ module Tapioca
           instance_methods = instance_methods_for(constant) - dynamic_methods
           return if dynamic_methods.empty? && instance_methods.empty?
 
-          root.path(constant) do |current_attributes|
+          root.create_path(constant) do |current_attributes|
             dynamic_methods.each do |method|
               method = method.to_s
               # We want to generate each method both on the class
@@ -95,7 +95,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveSupport::CurrentAttributes.descendants
+          descendants_of(::ActiveSupport::CurrentAttributes)
         end
 
         private
@@ -110,11 +110,16 @@ module Tapioca
           constant.instance_methods(false)
         end
 
-        sig { params(klass: Parlour::RbiGenerator::Namespace, method: String, class_method: T::Boolean).void }
+        sig { params(klass: RBI::Scope, method: String, class_method: T::Boolean).void }
         def generate_method(klass, method, class_method:)
           if method.end_with?("=")
-            parameter = Parlour::RbiGenerator::Parameter.new("value", type: "T.untyped")
-            klass.create_method(method, class_method: class_method, parameters: [parameter], return_type: "T.untyped")
+            parameter = create_param("value", type: "T.untyped")
+            klass.create_method(
+              method,
+              class_method: class_method,
+              parameters: [parameter],
+              return_type: "T.untyped"
+            )
           else
             klass.create_method(method, class_method: class_method, return_type: "T.untyped")
           end

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

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
+require "tapioca/rbi_ext/model"
 
 module Tapioca
   module Compilers
@@ -10,6 +10,8 @@ module Tapioca
         extend T::Sig
         extend T::Helpers
 
+        include Reflection
+
         abstract!
 
         sig { returns(T::Set[Module]) }
@@ -29,65 +31,111 @@ 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
 
-        SPECIAL_METHOD_NAMES = T.let(
-          %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `].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:]]*[?!=]?$/)
+        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
+
+        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
-        def compile_method_parameters_to_parlour(method_def)
+
+        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 +145,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