tapioca 0.5.6 → 0.6.0

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

@@ -7,6 +7,8 @@ rescue LoadError
   return
 end
 
+require "tapioca/compilers/dsl/helper/active_record_constants"
+
 module Tapioca
   module Compilers
     module Dsl
@@ -42,6 +44,7 @@ module Tapioca
       # ~~~
       class ActiveRecordScope < Base
         extend T::Sig
+        include Helper::ActiveRecordConstants
 
         sig do
           override.params(
@@ -50,19 +53,33 @@ module Tapioca
           ).void
         end
         def decorate(root, constant)
-          scope_method_names = constant.send(:generated_relation_methods).instance_methods(false)
-          return if scope_method_names.empty?
+          method_names = scope_method_names(constant)
+
+          return if method_names.empty?
 
           root.create_path(constant) do |model|
-            module_name = "GeneratedRelationMethods"
+            relations_enabled = generator_enabled?("ActiveRecordRelations")
+
+            relation_methods_module = model.create_module(RelationMethodsModuleName)
+            assoc_relation_methods_mod = model.create_module(AssociationRelationMethodsModuleName) if relations_enabled
+
+            method_names.each do |scope_method|
+              generate_scope_method(
+                relation_methods_module,
+                scope_method.to_s,
+                relations_enabled ? RelationClassName : "T.untyped"
+              )
 
-            model.create_module(module_name) do |mod|
-              scope_method_names.each do |scope_method|
-                generate_scope_method(scope_method.to_s, mod)
-              end
+              next unless relations_enabled
+
+              generate_scope_method(
+                assoc_relation_methods_mod,
+                scope_method.to_s,
+                AssociationRelationClassName
+              )
             end
 
-            model.create_extend(module_name)
+            model.create_extend(RelationMethodsModuleName)
           end
         end
 
@@ -73,16 +90,29 @@ module Tapioca
 
         private
 
+        sig { params(constant: T.class_of(::ActiveRecord::Base)).returns(T::Array[Symbol]) }
+        def scope_method_names(constant)
+          scope_methods = T.let([], T::Array[Symbol])
+
+          # Keep gathering scope methods until we hit "ActiveRecord::Base"
+          until constant == ActiveRecord::Base
+            scope_methods.concat(constant.send(:generated_relation_methods).instance_methods(false))
+
+            # we are guaranteed to have a superclass that is of type "ActiveRecord::Base"
+            constant = T.cast(constant.superclass, T.class_of(ActiveRecord::Base))
+          end
+
+          scope_methods
+        end
+
         sig do
           params(
-            scope_method: String,
             mod: RBI::Scope,
+            scope_method: String,
+            return_type: String
           ).void
         end
-        def generate_scope_method(scope_method, mod)
-          # This return type should actually be Model::ActiveRecord_Relation
-          return_type = "T.untyped"
-
+        def generate_scope_method(mod, scope_method, return_type)
           mod.create_method(
             scope_method,
             parameters: [

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

@@ -109,10 +109,8 @@ module Tapioca
                 type = type_for(field.type_sym)
                 type = "T.nilable(#{type})" if field.null && type != "T.untyped"
 
-                model.create_module("StoreAccessors") do |store_accessors_module|
-                  generate_methods(store_accessors_module, field.name.to_s, type)
-                end
-
+                store_accessors_module = model.create_module("StoreAccessors")
+                generate_methods(store_accessors_module, field.name.to_s, type)
                 model.create_include("StoreAccessors")
               end
             end

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

@@ -2,11 +2,13 @@
 # frozen_string_literal: true
 
 require "tapioca/rbi_ext/model"
+require "tapioca/compilers/dsl/param_helper"
+require "tapioca/compilers/dsl_compiler"
 
 module Tapioca
   module Compilers
     module Dsl
-      COMPILERS_PATH = T.let(File.expand_path("..", __FILE__).to_s, String)
+      DSL_COMPILERS_DIR = T.let(File.expand_path("..", __FILE__).to_s, String)
 
       class Base
         extend T::Sig
@@ -22,8 +24,22 @@ module Tapioca
         sig { returns(T::Array[String]) }
         attr_reader :errors
 
-        sig { void }
-        def initialize
+        sig { params(name: String).returns(T.nilable(T.class_of(Tapioca::Compilers::Dsl::Base))) }
+        def self.resolve(name)
+          # Try to find built-in tapioca generator first, then globally defined generator.
+          potentials = ["Tapioca::Compilers::Dsl::#{name}", name].map do |potential_name|
+            Object.const_get(potential_name)
+          rescue NameError
+            # Skip if we can't find generator by the potential name
+            nil
+          end
+
+          potentials.compact.first
+        end
+
+        sig { params(compiler: Tapioca::Compilers::DslCompiler).void }
+        def initialize(compiler)
+          @compiler = compiler
           @processable_constants = T.let(Set.new(gather_constants), T::Set[Module])
           @processable_constants.compare_by_identity
           @errors = T.let([], T::Array[String])
@@ -34,6 +50,11 @@ module Tapioca
           processable_constants.include?(constant)
         end
 
+        sig { params(generator_name: String).returns(T::Boolean) }
+        def generator_enabled?(generator_name)
+          @compiler.generator_enabled?(generator_name)
+        end
+
         sig do
           abstract
             .type_parameters(:T)
@@ -107,45 +128,7 @@ module Tapioca
           )
         end
 
-        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
-
-        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
+        include ParamHelper
 
         sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
         def compile_method_parameters_to_rbi(method_def)

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

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+begin
+  require "frozen_record"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      module Extensions
+        module FrozenRecord
+          attr_reader :__tapioca_scope_names
+
+          def scope(name, body)
+            @__tapioca_scope_names ||= []
+            @__tapioca_scope_names << name
+
+            super
+          end
+
+          ::FrozenRecord::Base.singleton_class.prepend(self)
+        end
+      end
+    end
+  end
+end

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

@@ -81,6 +81,8 @@ module Tapioca
             end
 
             record.create_include(module_name)
+
+            decorate_scopes(constant, record)
           end
         end
 
@@ -88,6 +90,41 @@ module Tapioca
         def gather_constants
           descendants_of(::FrozenRecord::Base).reject(&:abstract_class?)
         end
+
+        private
+
+        sig { params(constant: T.class_of(::FrozenRecord::Base), record: RBI::Scope).void }
+        def decorate_scopes(constant, record)
+          scopes = T.unsafe(constant).__tapioca_scope_names
+          return if scopes.nil?
+
+          module_name = "GeneratedRelationMethods"
+
+          record.create_module(module_name) do |mod|
+            scopes.each do |name|
+              generate_scope_method(name.to_s, mod)
+            end
+          end
+
+          record.create_extend(module_name)
+        end
+
+        sig do
+          params(
+            scope_method: String,
+            mod: RBI::Scope,
+          ).void
+        end
+        def generate_scope_method(scope_method, mod)
+          mod.create_method(
+            scope_method,
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_block_param("blk", type: "T.untyped"),
+            ],
+            return_type: "T.untyped",
+          )
+        end
       end
     end
   end

data/lib/tapioca/compilers/dsl/helper/active_record_constants.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Compilers
+    module Dsl
+      module Helper
+        module ActiveRecordConstants
+          extend T::Sig
+
+          AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
+          AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
+
+          RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
+          AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)
+          CommonRelationMethodsModuleName = T.let("CommonRelationMethods", String)
+
+          RelationClassName = T.let("PrivateRelation", String)
+          RelationWhereChainClassName = T.let("PrivateRelationWhereChain", String)
+          AssociationRelationClassName = T.let("PrivateAssociationRelation", String)
+          AssociationRelationWhereChainClassName = T.let("PrivateAssociationRelationWhereChain", String)
+          AssociationsCollectionProxyClassName = T.let("PrivateCollectionProxy", String)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Compilers
+    module Dsl
+      module ParamHelper
+        extend T::Sig
+
+        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
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rails/generators"
+  require "rails/generators/app_base"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::RailsGenerators` generates RBI files for Rails generators
+      #
+      # For example, with the following generator:
+      #
+      # ~~~rb
+      # # lib/generators/sample_generator.rb
+      # class ServiceGenerator < Rails::Generators::NamedBase
+      #   argument :result_type, type: :string
+      #
+      #   class_option :skip_comments, type: :boolean, default: false
+      # end
+      # ~~~
+      #
+      # this compiler will produce the RBI file `service_generator.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # service_generator.rbi
+      # # typed: strong
+      #
+      # class ServiceGenerator
+      #   sig { returns(::String)}
+      #   def result_type; end
+      #
+      #   sig { returns(T::Boolean)}
+      #   def skip_comments; end
+      # end
+      # ~~~
+      class RailsGenerators < Base
+        extend T::Sig
+
+        BUILT_IN_MATCHER = T.let(
+          /::(ActionMailbox|ActionText|ActiveRecord|Rails)::Generators/,
+          Regexp
+        )
+
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::Rails::Generators::Base)).void }
+        def decorate(root, constant)
+          base_class = base_class_for(constant)
+          arguments = constant.arguments - base_class.arguments
+          class_options = constant.class_options.reject do |name, option|
+            base_class.class_options[name] == option
+          end
+
+          return if arguments.empty? && class_options.empty?
+
+          root.create_path(constant) do |klass|
+            arguments.each { |argument| generate_methods_for_argument(klass, argument) }
+            class_options.each { |_name, option| generate_methods_for_argument(klass, option) }
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          all_modules.select do |const|
+            name = qualified_name_of(const)
+
+            name &&
+              !name.match?(BUILT_IN_MATCHER) &&
+              const < ::Rails::Generators::Base
+          end
+        end
+
+        private
+
+        sig { params(klass: RBI::Tree, argument: T.any(Thor::Argument, Thor::Option)).void }
+        def generate_methods_for_argument(klass, argument)
+          klass.create_method(
+            argument.name,
+            parameters: [],
+            return_type: type_for(argument)
+          )
+        end
+
+        sig do
+          params(constant: T.class_of(::Rails::Generators::Base))
+            .returns(T.class_of(::Rails::Generators::Base))
+        end
+        def base_class_for(constant)
+          ancestor = inherited_ancestors_of(constant).find do |klass|
+            qualified_name_of(klass)&.match?(BUILT_IN_MATCHER)
+          end
+
+          T.cast(ancestor, T.class_of(::Rails::Generators::Base))
+        end
+
+        sig { params(arg: T.any(Thor::Argument, Thor::Option)).returns(String) }
+        def type_for(arg)
+          type =
+            case arg.type
+            when :array then "T::Array[::String]"
+            when :boolean then "T::Boolean"
+            when :hash then "T::Hash[::String, ::String]"
+            when :numeric then "::Numeric"
+            when :string then "::String"
+            else "T.untyped"
+            end
+
+          if arg.required || arg.default
+            type
+          else
+            "T.nilable(#{type})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl_compiler.rb

@@ -22,19 +22,31 @@ module Tapioca
           requested_constants: T::Array[Module],
           requested_generators: T::Array[T.class_of(Dsl::Base)],
           excluded_generators: T::Array[T.class_of(Dsl::Base)],
-          error_handler: T.nilable(T.proc.params(error: String).void)
+          error_handler: T.proc.params(error: String).void,
+          number_of_workers: T.nilable(Integer),
         ).void
       end
-      def initialize(requested_constants:, requested_generators: [], excluded_generators: [], error_handler: nil)
+      def initialize(
+        requested_constants:,
+        requested_generators: [],
+        excluded_generators: [],
+        error_handler: $stderr.method(:puts).to_proc,
+        number_of_workers: nil
+      )
         @generators = T.let(
           gather_generators(requested_generators, excluded_generators),
           T::Enumerable[Dsl::Base]
         )
         @requested_constants = requested_constants
-        @error_handler = T.let(error_handler || $stderr.method(:puts), T.proc.params(error: String).void)
+        @error_handler = error_handler
+        @number_of_workers = number_of_workers
       end
 
-      sig { params(blk: T.proc.params(constant: Module, rbi: RBI::File).void).void }
+      sig do
+        type_parameters(:T).params(
+          blk: T.proc.params(constant: Module, rbi: RBI::File).returns(T.type_parameter(:T))
+        ).returns(T::Array[T.type_parameter(:T)])
+      end
       def run(&blk)
         constants_to_process = gather_constants(requested_constants)
           .select { |c| Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
@@ -47,7 +59,10 @@ module Tapioca
           ERROR
         end
 
-        constants_to_process.each do |constant|
+        result = Executor.new(
+          constants_to_process,
+          number_of_workers: @number_of_workers
+        ).run_in_parallel do |constant|
           rbi = rbi_for_constant(constant)
           next if rbi.nil?
 
@@ -57,6 +72,17 @@ module Tapioca
         generators.flat_map(&:errors).each do |msg|
           report_error(msg)
         end
+
+        result.compact
+      end
+
+      sig { params(generator_name: String).returns(T::Boolean) }
+      def generator_enabled?(generator_name)
+        generator = Dsl::Base.resolve(generator_name)
+
+        return false unless generator
+
+        @generators.any?(generator)
       end
 
       private
@@ -73,7 +99,7 @@ module Tapioca
             !excluded_generators.include?(klass)
         end.sort_by { |klass| T.must(klass.name) }
 
-        generator_klasses.map(&:new)
+        generator_klasses.map { |generator_klass| generator_klass.new(self) }
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }

data/lib/tapioca/compilers/sorbet.rb

@@ -18,6 +18,8 @@ module Tapioca
       EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
       FEATURE_REQUIREMENTS = T.let({
+        # First tag that includes https://github.com/sorbet/sorbet/pull/4706
+        to_ary_nil_support: Gem::Requirement.new(">= 0.5.9220"),
       }.freeze, T::Hash[Symbol, Gem::Requirement])
 
       class << self