tapioca 0.6.1 → 0.7.0

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Helpers
+      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 [as_nilable_type(getter_type), as_nilable_type(setter_type)]
+          end
+
+          if column_name == @constant.primary_key ||
+              column_name == "created_at" ||
+              column_name == "updated_at"
+            getter_type = as_nilable_type(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(type: String).returns(String) }
+        def as_nilable_type(type)
+          if type.start_with?("T.nilable(") || type == "T.untyped"
+            type
+          else
+            "T.nilable(#{type})"
+          end
+        end
+
+        sig { params(column_type: Object).returns(String) }
+        def handle_unknown_type(column_type)
+          return "T.untyped" unless ActiveModel::Type::Value === column_type
+          return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(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 = Runtime::Reflection.signature_of(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 = Runtime::Reflection.signature_of(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
+    end
+  end
+end

data/lib/tapioca/dsl/helpers/active_record_constants_helper.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Helpers
+      module ActiveRecordConstantsHelper
+        extend T::Sig
+
+        ReflectionType = T.type_alias do
+          T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
+        end
+
+        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

data/lib/tapioca/{compilers/dsl → dsl/helpers}/param_helper.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 module Tapioca
-  module Compilers
-    module Dsl
+  module Dsl
+    module Helpers
       module ParamHelper
         extend T::Sig
 

data/lib/tapioca/{compilers/dsl_compiler.rb → dsl/pipeline.rb}

@@ -1,15 +1,15 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "tapioca/compilers/dsl/base"
+require "tapioca/dsl/compilers"
 
 module Tapioca
-  module Compilers
-    class DslCompiler
+  module Dsl
+    class Pipeline
       extend T::Sig
 
-      sig { returns(T::Enumerable[Dsl::Base]) }
-      attr_reader :generators
+      sig { returns(T::Enumerable[T.class_of(Compiler)]) }
+      attr_reader :compilers
 
       sig { returns(T::Array[Module]) }
       attr_reader :requested_constants
@@ -17,29 +17,33 @@ module Tapioca
       sig { returns(T.proc.params(error: String).void) }
       attr_reader :error_handler
 
+      sig { returns(T::Array[String]) }
+      attr_reader :errors
+
       sig do
         params(
           requested_constants: T::Array[Module],
-          requested_generators: T::Array[T.class_of(Dsl::Base)],
-          excluded_generators: T::Array[T.class_of(Dsl::Base)],
+          requested_compilers: T::Array[T.class_of(Compiler)],
+          excluded_compilers: T::Array[T.class_of(Compiler)],
           error_handler: T.proc.params(error: String).void,
           number_of_workers: T.nilable(Integer),
         ).void
       end
       def initialize(
         requested_constants:,
-        requested_generators: [],
-        excluded_generators: [],
+        requested_compilers: [],
+        excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
         number_of_workers: nil
       )
-        @generators = T.let(
-          gather_generators(requested_generators, excluded_generators),
-          T::Enumerable[Dsl::Base]
+        @compilers = T.let(
+          gather_compilers(requested_compilers, excluded_compilers),
+          T::Enumerable[T.class_of(Compiler)]
         )
         @requested_constants = requested_constants
         @error_handler = error_handler
         @number_of_workers = number_of_workers
+        @errors = T.let([], T::Array[String])
       end
 
       sig do
@@ -49,8 +53,8 @@ module Tapioca
       end
       def run(&blk)
         constants_to_process = gather_constants(requested_constants)
-          .select { |c| Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
-          .sort_by! { |c| T.must(Reflection.name_of(c)) }
+          .select { |c| Runtime::Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
+          .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
         if constants_to_process.empty?
           report_error(<<~ERROR)
@@ -69,42 +73,45 @@ module Tapioca
           blk.call(constant, rbi)
         end
 
-        generators.flat_map(&:errors).each do |msg|
+        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)
+      sig { params(error: String).void }
+      def add_error(error)
+        @errors << error
+      end
 
-        return false unless generator
+      sig { params(compiler_name: String).returns(T::Boolean) }
+      def compiler_enabled?(compiler_name)
+        potential_names = Compilers::NAMESPACES.map { |namespace| namespace + compiler_name }
 
-        @generators.any?(generator)
+        @compilers.any? do |compiler|
+          potential_names.any?(compiler.name)
+        end
       end
 
       private
 
       sig do
         params(
-          requested_generators: T::Array[T.class_of(Dsl::Base)],
-          excluded_generators: T::Array[T.class_of(Dsl::Base)]
-        ).returns(T::Enumerable[Dsl::Base])
+          requested_compilers: T::Array[T.class_of(Compiler)],
+          excluded_compilers: T::Array[T.class_of(Compiler)]
+        ).returns(T::Enumerable[T.class_of(Compiler)])
       end
-      def gather_generators(requested_generators, excluded_generators)
-        generator_klasses = ::Tapioca::Reflection.descendants_of(Dsl::Base).select do |klass|
-          (requested_generators.empty? || requested_generators.include?(klass)) &&
-            !excluded_generators.include?(klass)
+      def gather_compilers(requested_compilers, excluded_compilers)
+        Runtime::Reflection.descendants_of(Compiler).select do |klass|
+          (requested_compilers.empty? || requested_compilers.include?(klass)) &&
+            !excluded_compilers.include?(klass)
         end.sort_by { |klass| T.must(klass.name) }
-
-        generator_klasses.map { |generator_klass| generator_klass.new(self) }
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
       def gather_constants(requested_constants)
-        constants = generators.map(&:processable_constants).reduce(Set.new, :union)
+        constants = compilers.map(&:processable_constants).reduce(Set.new, :union)
         constants &= requested_constants unless requested_constants.empty?
         constants
       end
@@ -113,9 +120,10 @@ module Tapioca
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
-        generators.each do |generator|
-          next unless generator.handles?(constant)
-          generator.decorate(file.root, constant)
+        compilers.each do |compiler_class|
+          next unless compiler_class.handles?(constant)
+          compiler = compiler_class.new(self, file.root, constant)
+          compiler.decorate
         end
 
         return if file.root.empty?

data/lib/tapioca/gem/events.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+
+module Tapioca
+  module Gem
+    class Event
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+    end
+
+    class SymbolFound < Event
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :symbol
+
+      sig { params(symbol: String).void }
+      def initialize(symbol)
+        super()
+        @symbol = symbol
+      end
+    end
+
+    class ConstantFound < Event
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :symbol
+
+      sig { returns(BasicObject).checked(:never) }
+      attr_reader :constant
+
+      sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
+      def initialize(symbol, constant)
+        super()
+        @symbol = symbol
+        @constant = constant
+      end
+    end
+
+    class NodeAdded < Event
+      extend T::Helpers
+      extend T::Sig
+
+      abstract!
+
+      sig { returns(String) }
+      attr_reader :symbol
+
+      sig { returns(Module).checked(:never) }
+      attr_reader :constant
+
+      sig { params(symbol: String, constant: Module).void.checked(:never) }
+      def initialize(symbol, constant)
+        super()
+        @symbol = symbol
+        @constant = constant
+      end
+    end
+
+    class ConstNodeAdded < NodeAdded
+      extend T::Sig
+
+      sig { returns(RBI::Const) }
+      attr_reader :node
+
+      sig { params(symbol: String, constant: Module, node: RBI::Const).void.checked(:never) }
+      def initialize(symbol, constant, node)
+        super(symbol, constant)
+        @node = node
+      end
+    end
+
+    class ScopeNodeAdded < NodeAdded
+      extend T::Sig
+
+      sig { returns(RBI::Scope) }
+      attr_reader :node
+
+      sig { params(symbol: String, constant: Module, node: RBI::Scope).void.checked(:never) }
+      def initialize(symbol, constant, node)
+        super(symbol, constant)
+        @node = node
+      end
+    end
+
+    class MethodNodeAdded < NodeAdded
+      extend T::Sig
+
+      sig { returns(RBI::Method) }
+      attr_reader :node
+
+      sig { returns(T.untyped) }
+      attr_reader :signature
+
+      sig { returns(T::Array[[Symbol, String]]) }
+      attr_reader :parameters
+
+      sig do
+        params(
+          symbol: String,
+          constant: Module,
+          node: RBI::Method,
+          signature: T.untyped,
+          parameters: T::Array[[Symbol, String]]
+        ).void.checked(:never)
+      end
+      def initialize(symbol, constant, node, signature, parameters)
+        super(symbol, constant)
+        @node = node
+        @signature = signature
+        @parameters = parameters
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/base.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Base
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig { params(pipeline: Pipeline).void }
+        def initialize(pipeline)
+          @pipeline = pipeline
+        end
+
+        sig { params(event: NodeAdded).void }
+        def dispatch(event)
+          case event
+          when ConstNodeAdded
+            on_const(event)
+          when ScopeNodeAdded
+            on_scope(event)
+          when MethodNodeAdded
+            on_method(event)
+          else
+            raise "Unsupported event #{event.class}"
+          end
+        end
+
+        private
+
+        sig { params(event: ConstNodeAdded).void }
+        def on_const(event)
+        end
+
+        sig { params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+        end
+
+        sig { params(event: MethodNodeAdded).void }
+        def on_method(event)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/dynamic_mixins.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class DynamicMixins < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          constant = event.constant
+          return if constant.is_a?(Class)
+
+          node = event.node
+          mixin_compiler = Runtime::DynamicMixinCompiler.new(constant)
+          mixin_compiler.compile_class_attributes(node)
+          dynamic_extends, dynamic_includes = mixin_compiler.compile_mixes_in_class_methods(node)
+
+          (dynamic_includes + dynamic_extends).each do |mod|
+            name = @pipeline.name_of(mod)
+            @pipeline.push_symbol(name) if name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/gem/listeners/methods.rb

@@ -0,0 +1,183 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class Methods < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        SPECIAL_METHOD_NAMES = T.let([
+          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
+          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",
+        ], T::Array[String])
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          symbol = event.symbol
+          constant = event.constant
+          node = event.node
+
+          compile_method(node, symbol, constant, initialize_method_for(constant))
+          compile_directly_owned_methods(node, symbol, constant)
+          compile_directly_owned_methods(node, symbol, singleton_class_of(constant))
+        end
+
+        sig do
+          params(
+            tree: RBI::Tree,
+            module_name: String,
+            mod: Module,
+            for_visibility: T::Array[Symbol]
+          ).void
+        end
+        def compile_directly_owned_methods(tree, module_name, mod, for_visibility = [:public, :protected, :private])
+          method_names_by_visibility(mod)
+            .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
+            .each do |visibility, method_list|
+              method_list.sort!.map do |name|
+                next if name == :initialize
+                vis = case visibility
+                when :protected
+                  RBI::Protected.new
+                when :private
+                  RBI::Private.new
+                else
+                  RBI::Public.new
+                end
+                compile_method(tree, module_name, mod, mod.instance_method(name), vis)
+              end
+            end
+        end
+
+        sig do
+          params(
+            tree: RBI::Tree,
+            symbol_name: String,
+            constant: Module,
+            method: T.nilable(UnboundMethod),
+            visibility: RBI::Visibility
+          ).void
+        end
+        def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
+          return unless method
+          return unless method.owner == constant
+          return if @pipeline.symbol_in_payload?(symbol_name) && !@pipeline.method_in_gem?(method)
+
+          signature = signature_of(method)
+          method = T.let(signature.method, UnboundMethod) if signature
+
+          method_name = method.name.to_s
+          return unless valid_method_name?(method_name)
+          return if struct_method?(constant, method_name)
+          return if method_name.start_with?("__t_props_generated_")
+
+          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+          sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
+            fallback_arg_name = "_arg#{index}"
+
+            name = if name
+              name.to_s
+            else
+              # For attr_writer methods, Sorbet signatures have the name
+              # of the method (without the trailing = sign) as the name of
+              # the only parameter. So, if the parameter does not have a name
+              # then the replacement name should be the name of the method
+              # (minus trailing =) if and only if there is a signature for the
+              # method and the parameter is required and there is a single
+              # parameter and the signature also defines a single parameter and
+              # the name of the method ends with a = character.
+              writer_method_with_sig = (
+                signature && type == :req &&
+                parameters.size == 1 &&
+                signature.arg_types.size == 1 &&
+                method_name[-1] == "="
+              )
+
+              if writer_method_with_sig
+                method_name.delete_suffix("=")
+              else
+                fallback_arg_name
+              end
+            end
+
+            # Sanitize param names
+            name = fallback_arg_name unless valid_parameter_name?(name)
+
+            [type, name]
+          end
+
+          rbi_method = RBI::Method.new(
+            method_name,
+            is_singleton: constant.singleton_class?,
+            visibility: visibility
+          )
+
+          sanitized_parameters.each do |type, name|
+            case type
+            when :req
+              rbi_method << RBI::Param.new(name)
+            when :opt
+              rbi_method << RBI::OptParam.new(name, "T.unsafe(nil)")
+            when :rest
+              rbi_method << RBI::RestParam.new(name)
+            when :keyreq
+              rbi_method << RBI::KwParam.new(name)
+            when :key
+              rbi_method << RBI::KwOptParam.new(name, "T.unsafe(nil)")
+            when :keyrest
+              rbi_method << RBI::KwRestParam.new(name)
+            when :block
+              rbi_method << RBI::BlockParam.new(name)
+            end
+          end
+
+          @pipeline.push_method(symbol_name, constant, rbi_method, signature, sanitized_parameters)
+          tree << rbi_method
+        end
+
+        sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+        def method_names_by_visibility(mod)
+          {
+            public: public_instance_methods_of(mod),
+            protected: protected_instance_methods_of(mod),
+            private: private_instance_methods_of(mod),
+          }
+        end
+
+        sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+        def struct_method?(constant, method_name)
+          return false unless T::Props::ClassMethods === constant
+
+          constant
+            .props
+            .keys
+            .include?(method_name.gsub(/=$/, "").to_sym)
+        end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_method_name?(name)
+          return true if SPECIAL_METHOD_NAMES.include?(name)
+          !!name.match(/^[[:word:]]+[?!=]?$/)
+        end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def valid_parameter_name?(name)
+          name.match?(/^[[[:alnum:]]_]+$/)
+        end
+
+        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
+        def initialize_method_for(constant)
+          constant.instance_method(:initialize)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end