tapioca 0.11.7 → 0.11.9

data/lib/tapioca/commands/gem_verify.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Commands
+    class GemVerify < AbstractGem
+      private
+
+      sig { override.void }
+      def execute
+        say("Checking for out-of-date RBIs...")
+        say("")
+        perform_sync_verification
+      end
+
+      sig { void }
+      def perform_sync_verification
+        diff = {}
+
+        removed_rbis.each do |gem_name|
+          next if @exclude.include?(gem_name)
+
+          filename = existing_rbi(gem_name)
+          diff[filename] = :removed
+        end
+
+        added_rbis.each do |gem_name|
+          filename = expected_rbi(gem_name)
+          diff[filename] = gem_rbi_exists?(gem_name) ? :changed : :added
+        end
+
+        report_diff_and_exit_if_out_of_date(diff, :gem)
+      end
+    end
+  end
+end

data/lib/tapioca/commands/require.rb

@@ -17,6 +17,8 @@ module Tapioca
         super()
       end
 
+      private
+
       sig { override.void }
       def execute
         compiler = Static::RequiresCompiler.new(@sorbet_config_path)

data/lib/tapioca/commands/todo.rb

@@ -6,6 +6,17 @@ module Tapioca
     class Todo < CommandWithoutTracker
       include SorbetHelper
 
+      DEPRECATION_MESSAGE = T.let(<<~DEPRECATION, String)
+        The `todo` command is deprecated and will be removed in a future release.
+
+        If your project is still missing type definitions for constants, try the following:
+        1. Regenerate gem RBIs by running `bin/tapioca gem --all` and `bin/tapioca annotations`
+        2. Generate RBIs for DSLs by running `bin/tapioca dsl`
+        3. If the missing constants are defined in files that a gem does not load by default,
+           manually require those files in `sorbet/tapioca/require.rb` and regenerate gem RBIs
+        4. Manually create an RBI shim defining the missing constants
+      DEPRECATION
+
       sig do
         params(
           todo_file: String,
@@ -19,6 +30,16 @@ module Tapioca
         super()
       end
 
+      sig { void }
+      def run_with_deprecation
+        say(DEPRECATION_MESSAGE, :red)
+        say("")
+
+        run
+      end
+
+      private
+
       sig { override.void }
       def execute
         say("Finding all unresolved constants, this may take a few seconds... ")
@@ -43,8 +64,6 @@ module Tapioca
         say("Please review changes and commit them.", [:green, :bold])
       end
 
-      private
-
       sig { params(constants: T::Array[String], command: String).returns(RBI::File) }
       def rbi(constants, command:)
         file = RBI::File.new

data/lib/tapioca/commands.rb

@@ -7,9 +7,15 @@ module Tapioca
     autoload :CommandWithoutTracker, "tapioca/commands/command_without_tracker"
     autoload :Annotations, "tapioca/commands/annotations"
     autoload :CheckShims, "tapioca/commands/check_shims"
-    autoload :Dsl, "tapioca/commands/dsl"
+    autoload :AbstractDsl, "tapioca/commands/abstract_dsl"
+    autoload :DslCompilerList, "tapioca/commands/dsl_compiler_list"
+    autoload :DslGenerate, "tapioca/commands/dsl_generate"
+    autoload :DslVerify, "tapioca/commands/dsl_verify"
     autoload :Configure, "tapioca/commands/configure"
-    autoload :Gem, "tapioca/commands/gem"
+    autoload :AbstractGem, "tapioca/commands/abstract_gem"
+    autoload :GemGenerate, "tapioca/commands/gem_generate"
+    autoload :GemSync, "tapioca/commands/gem_sync"
+    autoload :GemVerify, "tapioca/commands/gem_verify"
     autoload :Require, "tapioca/commands/require"
     autoload :Todo, "tapioca/commands/todo"
   end

data/lib/tapioca/dsl/compiler.rb

@@ -45,14 +45,18 @@ module Tapioca
 
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
-          @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[T::Class[T.anything]]))
-          @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each
+          @all_classes ||= T.let(
+            T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each,
+            T.nilable(T::Enumerable[T::Class[T.anything]]),
+          )
         end
 
         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
+          @all_modules ||= T.let(
+            T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each,
+            T.nilable(T::Enumerable[Module]),
+          )
         end
       end
 

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

@@ -126,7 +126,9 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            descendants_of(::ActionController::Base).reject(&:abstract?).select(&:name)
+            descendants_of(::ActionController::Base).select(&:name).select do |klass|
+              klass.const_defined?(:HelperMethods, false)
+            end
           end
         end
 

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

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_model"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveModelValidationsConfirmation` decorates RBI files for all
+      # classes that use [`ActiveModel::Validates::Confirmation`](https://api.rubyonrails.org/classes/ActiveModel/Validations/HelperMethods.html#method-i-validates_confirmation_of).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class User
+      #   include ActiveModel::Validations
+      #
+      #   validates_confirmation_of :password
+      #
+      #   validates :email, confirmation: true
+      # end
+      # ~~~
+      #
+      # this compiler will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class User
+      #
+      #   sig { returns(T.untyped) }
+      #   def email_confirmation; end
+      #
+      #   sig { params(email_confirmation=: T.untyped).returns(T.untyped) }
+      #   def email_confirmation=(email_confirmation); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def password_confirmation; end
+      #
+      #   sig { params(password_confirmation=: T.untyped).returns(T.untyped) }
+      #   def password_confirmation=(password_confirmation); end
+      # end
+      # ~~~
+      class ActiveModelValidationsConfirmation < Compiler
+        extend T::Sig
+
+        ConstantType = type_member do
+          {
+            fixed: T.all(
+              T::Class[ActiveModel::Validations],
+              ActiveModel::Validations::HelperMethods,
+              ActiveModel::Validations::ClassMethods,
+            ),
+          }
+        end
+
+        class << self
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            # Collect all the classes that include ActiveModel::Validations
+            all_classes.select do |c|
+              c < ActiveModel::Validations
+            end
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          confirmation_validators = constant.validators.grep(ActiveModel::Validations::ConfirmationValidator)
+
+          return if confirmation_validators.empty?
+
+          # Create a RBI definition for each class that includes Active::Model::Validations
+          root.create_path(constant) do |klass|
+            # Create RBI definitions for all the attributes that use confirmation validation
+            confirmation_validators.each do |validator|
+              validator.attributes.each do |attr_name|
+                klass.create_method("#{attr_name}_confirmation", return_type: "T.untyped")
+                klass.create_method(
+                  "#{attr_name}_confirmation=",
+                  parameters: [create_param("#{attr_name}_confirmation", type: "T.untyped")],
+                  return_type: "T.untyped",
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -110,8 +110,8 @@ module Tapioca
 
           root.create_path(constant) do |model|
             model.create_module(AttributeMethodsModuleName) do |mod|
-              constant.attribute_names.each do |column_name|
-                add_methods_for_attribute(mod, column_name)
+              (constant.attribute_names + ["id"]).uniq.each do |attribute_name|
+                add_methods_for_attribute(mod, attribute_name)
               end
 
               constant.attribute_aliases.each do |attribute_name, column_name|
@@ -127,7 +127,7 @@ module Tapioca
                 old_method_names = patterns.map { |m| m.method_name(column_name) }
                 methods_to_add = new_method_names - old_method_names
 
-                add_methods_for_attribute(mod, column_name, attribute_name, methods_to_add)
+                add_methods_for_attribute(mod, attribute_name, column_name, methods_to_add)
               end
             end
 
@@ -152,13 +152,13 @@ module Tapioca
             name: String,
             methods_to_add: T.nilable(T::Array[String]),
             return_type: String,
-            parameters: T::Array[[String, String]],
+            parameters: T::Array[RBI::TypedParam],
           ).void
         end
         def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
           klass.create_method(
             name,
-            parameters: parameters.map { |param, type| create_param(param, type: type) },
+            parameters: parameters,
             return_type: return_type,
           ) if methods_to_add.nil? || methods_to_add.include?(name)
         end
@@ -166,13 +166,15 @@ module Tapioca
         sig do
           params(
             klass: RBI::Scope,
-            column_name: String,
             attribute_name: String,
+            column_name: String,
             methods_to_add: T.nilable(T::Array[String]),
           ).void
         end
-        def add_methods_for_attribute(klass, column_name, attribute_name = column_name, methods_to_add = nil)
-          getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(column_name)
+        def add_methods_for_attribute(klass, attribute_name, column_name = attribute_name, methods_to_add = nil)
+          getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper
+            .new(constant)
+            .type_for(attribute_name, column_name)
 
           # Added by ActiveRecord::AttributeMethods::Read
           #
@@ -189,7 +191,7 @@ module Tapioca
             klass,
             "#{attribute_name}=",
             methods_to_add,
-            parameters: [["value", setter_type]],
+            parameters: [create_param("value", type: setter_type)],
             return_type: setter_type,
           )
 
@@ -254,6 +256,10 @@ module Tapioca
             "#{attribute_name}_changed?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+            ],
           )
           add_method(
             klass,
@@ -277,6 +283,10 @@ module Tapioca
             "#{attribute_name}_previously_changed?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+            ],
           )
           add_method(
             klass,

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

@@ -98,6 +98,9 @@ module Tapioca
           return if stores.values.all? { |store| store.accessors.empty? }
 
           root.create_path(constant) do |model|
+            store_accessors_module = model.create_module("StoreAccessors")
+            model.create_include("StoreAccessors")
+
             stores.values.each do |store_data|
               store_data.accessors.each do |accessor, name|
                 field = store_data.fields.fetch(accessor)
@@ -105,9 +108,7 @@ module Tapioca
                 type = as_nilable_type(type) if field.null
                 name ||= field.name # support < 1.5.0
 
-                store_accessors_module = model.create_module("StoreAccessors")
                 generate_methods(store_accessors_module, name.to_s, type)
-                model.create_include("StoreAccessors")
               end
             end
           end

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

@@ -85,7 +85,7 @@ module Tapioca
 
           sig { params(concern: Module).returns(T::Array[Module]) }
           def dependencies_of(concern)
-            concern.instance_variable_get(:@_dependencies)
+            concern.instance_variable_get(:@_dependencies) || []
           end
         end
 

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

@@ -55,7 +55,7 @@ module Tapioca
           root.create_path(constant) do |input_object|
             arguments.each do |argument|
               name = argument.keyword.to_s
-              input_object.create_method(name, return_type: Helpers::GraphqlTypeHelper.type_for(argument.type))
+              input_object.create_method(name, return_type: Helpers::GraphqlTypeHelper.type_for(argument))
             end
           end
         end

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

@@ -42,7 +42,7 @@ module Tapioca
       class GraphqlMutation < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::InputObject) } }
+        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::Mutation) } }
 
         sig { override.void }
         def decorate
@@ -59,7 +59,7 @@ module Tapioca
           params = compile_method_parameters_to_rbi(method_def).map do |param|
             name = param.param.name
             argument = arguments_by_name.fetch(name, nil)
-            create_typed_param(param.param, argument ? Helpers::GraphqlTypeHelper.type_for(argument.type) : "T.untyped")
+            create_typed_param(param.param, argument_type(argument))
           end
 
           root.create_path(constant) do |mutation|
@@ -67,6 +67,13 @@ module Tapioca
           end
         end
 
+        sig { params(argument: T.nilable(GraphQL::Schema::Argument)).returns(String) }
+        def argument_type(argument)
+          return "T.untyped" unless argument
+
+          Helpers::GraphqlTypeHelper.type_for(argument)
+        end
+
         class << self
           extend T::Sig
 

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

@@ -0,0 +1,208 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "json_api_client"
+rescue LoadError
+  # means JsonApiClient is not installed,
+  # so let's not even define the compiler.
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::JsonApiClientResource` generates RBI files for classes that inherit
+      # [`JsonApiClient::Resource`](https://github.com/JsonApiClient/json_api_client).
+      #
+      # For example, with the following classes that inherits `JsonApiClient::Resource`:
+      #
+      # ~~~rb
+      # # user.rb
+      # class User < JsonApiClient::Resource
+      #   has_many :posts
+      #
+      #   property :name, type: :string
+      #   property :is_admin, type: :boolean, default: false
+      # end
+      #
+      # # post.rb
+      # class Post < JsonApiClient::Resource
+      #   belongs_to :user
+      #
+      #   property :title, type: :string
+      # end
+      # ~~~
+      #
+      # this compiler will produce RBI files with the following content:
+      #
+      # ~~~rbi
+      # # user.rbi
+      # # typed: strong
+      #
+      # class User
+      #   include JsonApiClientResourceGeneratedMethods
+      #
+      #   module JsonApiClientResourceGeneratedMethods
+      #     sig { returns(T::Boolean) }
+      #     def is_admin; end
+      #
+      #     sig { params(is_admin: T::Boolean).returns(T::Boolean) }
+      #     def is_admin=(is_admin); end
+      #
+      #     sig { returns(T.nilable(::String)) }
+      #     def name; end
+      #
+      #     sig { params(name: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def name=(name); end
+      #
+      #     sig { returns(T.nilable(T::Array[Post])) }
+      #     def posts; end
+      #
+      #     sig { params(posts: T.nilable(T::Array[Post])).returns(T.nilable(T::Array[Post])) }
+      #     def posts=(posts); end
+      #   end
+      # end
+      #
+      # # post.rbi
+      # # typed: strong
+      #
+      # class Post
+      #   include JsonApiClientResourceGeneratedMethods
+      #
+      #   module JsonApiClientResourceGeneratedMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def title; end
+      #
+      #     sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def title=(title); end
+      #
+      #     sig { returns(T.nilable(::String)) }
+      #     def user_id; end
+      #
+      #     sig { params(user_id: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def user_id=(user_id); end
+      #   end
+      # end
+      # ~~~
+      class JsonApiClientResource < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::JsonApiClient::Resource) } }
+
+        sig { override.void }
+        def decorate
+          schema = resource_schema
+          return if schema.nil? && constant.associations.empty?
+
+          root.create_path(constant) do |k|
+            module_name = "JsonApiClientResourceGeneratedMethods"
+            k.create_module(module_name) do |mod|
+              schema&.each_property do |property|
+                generate_methods_for_property(mod, property)
+              end
+
+              constant.associations.each do |association|
+                generate_methods_for_association(mod, association)
+              end
+            end
+
+            k.create_include(module_name)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_modules.select do |c|
+              name_of(c) && c < ::JsonApiClient::Resource
+            end
+          end
+        end
+
+        private
+
+        sig { returns(T.nilable(::JsonApiClient::Schema)) }
+        def resource_schema
+          schema = constant.schema
+
+          # empty? does not exist on JsonApiClient::Schema
+          schema if schema.size > 0 # rubocop:disable Style/ZeroLengthPredicate
+        end
+
+        sig do
+          params(
+            mod: RBI::Scope,
+            property: ::JsonApiClient::Schema::Property,
+          ).void
+        end
+        def generate_methods_for_property(mod, property)
+          type = type_for(property)
+
+          name = property.name.to_s
+
+          mod.create_method(name, return_type: type)
+          mod.create_method("#{name}=", parameters: [create_param(name, type: type)], return_type: type)
+        end
+
+        sig { params(property: ::JsonApiClient::Schema::Property).returns(String) }
+        def type_for(property)
+          type = ::JsonApiClient::Schema::TypeFactory.type_for(property.type)
+          return "T.untyped" if type.nil?
+
+          sorbet_type = if type.respond_to?(:sorbet_type)
+            type.sorbet_type
+          elsif type == ::JsonApiClient::Schema::Types::Integer
+            "::Integer"
+          elsif type == ::JsonApiClient::Schema::Types::String
+            "::String"
+          elsif type == ::JsonApiClient::Schema::Types::Float
+            "::Float"
+          elsif type == ::JsonApiClient::Schema::Types::Time
+            "::Time"
+          elsif type == ::JsonApiClient::Schema::Types::Decimal
+            "::BigDecimal"
+          elsif type == ::JsonApiClient::Schema::Types::Boolean
+            "T::Boolean"
+          else
+            "T.untyped"
+          end
+
+          if property.default.nil?
+            as_nilable_type(sorbet_type)
+          else
+            sorbet_type
+          end
+        end
+
+        sig do
+          params(
+            mod: RBI::Scope,
+            association: JsonApiClient::Associations::BaseAssociation,
+          ).void
+        end
+        def generate_methods_for_association(mod, association)
+          # If the association is broken, it will raise a NameError when trying to access the association_class
+          klass = association.association_class
+
+          name, type = case association
+          when ::JsonApiClient::Associations::BelongsTo::Association
+            # id must be a string: # https://jsonapi.org/format/#document-resource-object-identification
+            [association.param.to_s, "T.nilable(::String)"]
+          when ::JsonApiClient::Associations::HasOne::Association
+            [association.attr_name.to_s, "T.nilable(#{klass})"]
+          when ::JsonApiClient::Associations::HasMany::Association
+            [association.attr_name.to_s, "T.nilable(T::Array[#{klass}])"]
+          else
+            return # Unsupported association type
+          end
+
+          mod.create_method(name, return_type: type)
+          mod.create_method("#{name}=", parameters: [create_param(name, type: type)], return_type: type)
+        end
+      end
+    end
+  end
+end

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

@@ -250,27 +250,21 @@ module Tapioca
               value_type = type_of(value)
               type = "Google::Protobuf::Map[#{key_type}, #{value_type}]"
 
-              default_args = [key.type.inspect, value.type.inspect]
-              default_args << value_type if [:enum, :message].include?(value.type)
-
               Field.new(
                 name: descriptor.name,
                 type: type,
                 init_type: "T.nilable(T.any(#{type}, T::Hash[#{key_type}, #{value_type}]))",
-                default: "Google::Protobuf::Map.new(#{default_args.join(", ")})",
+                default: "T.unsafe(nil)",
               )
             else
               elem_type = type_of(descriptor)
               type = "Google::Protobuf::RepeatedField[#{elem_type}]"
 
-              default_args = [descriptor.type.inspect]
-              default_args << elem_type if [:enum, :message].include?(descriptor.type)
-
               Field.new(
                 name: descriptor.name,
                 type: type,
                 init_type: "T.nilable(T.any(#{type}, T::Array[#{elem_type}]))",
-                default: "Google::Protobuf::RepeatedField.new(#{default_args.join(", ")})",
+                default: "T.unsafe(nil)",
               )
             end
           else

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

@@ -13,8 +13,26 @@ module Tapioca
           @constant = constant
         end
 
+        sig { params(attribute_name: String, column_name: String).returns([String, String]) }
+        def type_for(attribute_name, column_name = attribute_name)
+          return id_type if attribute_name == "id"
+
+          column_type_for(column_name)
+        end
+
+        private
+
+        sig { returns([String, String]) }
+        def id_type
+          if @constant.respond_to?(:composite_primary_key?) && T.unsafe(@constant).composite_primary_key?
+            @constant.primary_key.map(&method(:column_type_for)).map { |tuple| "[#{tuple.join(", ")}]" }
+          else
+            column_type_for(@constant.primary_key)
+          end
+        end
+
         sig { params(column_name: String).returns([String, String]) }
-        def type_for(column_name)
+        def column_type_for(column_name)
           return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(@constant)
 
           column = @constant.columns_hash[column_name]
@@ -33,7 +51,7 @@ module Tapioca
             return [getter_type, as_nilable_type(setter_type)]
           end
 
-          if column_name == @constant.primary_key ||
+          if Array(@constant.primary_key).include?(column_name) ||
               column_name == "created_at" ||
               column_name == "updated_at"
             getter_type = as_nilable_type(getter_type)
@@ -42,8 +60,6 @@ module Tapioca
           [getter_type, setter_type]
         end
 
-        private
-
         sig { params(column_type: T.untyped).returns(String) }
         def type_for_activerecord_value(column_type)
           case column_type