boba 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27ee83d22576856c1cc2c546cd1c49bb69ccbe5dc168858be21ffa0bce985e62
-  data.tar.gz: 146fd90b3e40b8db91b1a71ca8b850594922a0178ef4e8cb4a18d46ba94eaca1
+  metadata.gz: e6b2eb9c09c7bcd8a5050115892945fc23749ddc3b9f0376387c914c089c390b
+  data.tar.gz: b17a134072db6a900007bc4a74cba405ca69383039e710e86862de09c6daa93f
 SHA512:
-  metadata.gz: c8bbdbedbc56f12ac239dd8ad75c04bc6782d2b8448dc7f289c430d9ea592458f44b3461c304daaff218689bad83c4779a701d449d14f2d6babf7c2bb06c367a
-  data.tar.gz: '068e9cf37630c8fd608a04280b35a46f769a432ecb6605cedbc7c03991d1cec5d6f67306a38803069e0eaa8be5f27889c362b5fb9aa622714653775540e7c88d'
+  metadata.gz: 6d1bd6b43cc6ad2104ad6bcb96f78a53eb7c70068ef948ba0ab172fb8821537963e3a4bf5fe2b810613f9a2e4e9c0a30364bca266e243af1b8cf2800f0d8772a
+  data.tar.gz: 38e5e55631671d0bf64c7c8f64b3d21d8d7c8dbd393b4ffc960f2e958766302bb67dea0c8aeef65ec606f2f395d1194ac1367551a795ae66c7f455ce412f287e

data/README.md

@@ -4,10 +4,11 @@
 
 Boba is a collection of compilers for Sorbet & Tapioca.
 
-Tapioca is very opinionated about what types of compilers or changes are accepted into the repository. See
-[here](https://github.com/Shopify/tapioca?tab=readme-ov-file#dsl-compilers). Boba come in all
-different shapes, sizes, consistencies, etc, and is much less opinionated about what is or is not accepted. Think of
-Boba like a collection of compilers that you can pick and choose from.
+Tapioca is very opinionated about what types of compilers or changes are accepted into the repository. See [here](https://github.com/Shopify/tapioca?tab=readme-ov-file#dsl-compilers). Boba come in all different shapes, sizes, consistencies, etc, and is much less opinionated about what is or is not accepted. Boba is a collection of optional compilers that you can pick and choose from.
+
+### Available Compilers
+
+See [the compilers manual](https://github.com/angellist/boba/blob/main/manual/compilers.md) for a list of available compilers.
 
 ## Usage
 
@@ -18,18 +19,59 @@ group :development do
 end
 ```
 
-We recommend you also use the `only` configuration option in your Tapioca config (typically `sorbet/tapioca/config.yml`)
-to specify only the Tapioca compilers you wish to use.
+We recommend you also use the `only` configuration option in your Tapioca config (typically `sorbet/tapioca/config.yml`) to specify only the Tapioca compilers you wish to use.
 ```yml
 dsl:
   only:
     Compiler1
     Compiler2
 ```
+This makes it easy to selectively enable only the compilers you want to use in your project.
+
+### Typing Relations
+
+If you'd like to use relation types in your sigs that are less broad than `ActiveRecord::Relation`, such as those specific to a model, Boba provides a railtie to initialize these constants for each class. Move Boba in your gemfile out of the development group:
+
+```ruby
+  gem 'boba'
+```
+
+The railtie will automatically define the `PrivateRelation` constant on each model that inherits from `ActiveRecord::Base`. It can then be used in typing, like thus:
+```ruby
+class Post < ::ActiveRecord::Base
+  scope :recent -> { where('created_at > ?', Date.current) }
+
+  belongs_to :author
+  has_many :comments
+end
+
+sig { params(author: Author).returns(Post::PrivateRelation) }
+def posts_from_author(author); end
+```
+
+and the following should not raise an error:
+
+```ruby
+sig { params(author: Author).returns(Post::PrivateRelation) }
+def recent_posts_from_author(author)
+  posts_from_author(author).recent
+end
+```
+
+## Contributing
+
+Bugs and feature requests are welcome and should be [filed as issues on github](https://github.com/angellist/boba/issues).
+
+### New Compilers
+
+Compilers for any commonly used Ruby or Rails gems are welcome to be contributed. See the [Writing New Compilers section of the Tapioca docs](https://github.com/Shopify/tapioca?tab=readme-ov-file#writing-custom-dsl-compilers) for an introduction to writing compilers.
+
+Since Boba is intended to be used alongside Tapioca and the compilers provided by Boba are intended to be fully optional, we will not accept compilers which overwrite the Tapioca default compilers. See the [Tapioca Manual](https://github.com/Shopify/tapioca/blob/main/manual/compilers.md) for a list of these compilers. Instead, compilers which extend or overwrite the default Tapioca compilers should be given unique names.
+
+Contributed compilers should be well documented, and named after and include a link or reference to the Gem, DSL, or other module they implement RBIs for.
+
+Compilers for Gems, DSLs, or modules that are not publicly available will not be accepted.
 
 ## Todo
 
-1. Contributing Section
-2. Specs & spec harness
-3. Docs & doc harness
-4. Rubocop
+1. Specs & spec harness

data/lib/boba/relations_railtie.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+class Boba::RelationsRailtie < Rails::Railtie
+  railtie_name(:boba)
+
+  initializer("boba.add_private_relation_constant") do
+    ActiveSupport.on_load(:active_record) do
+      module AciveRecordInheritDefineRelationTypes
+        def inherited(child)
+          super(child)
+
+          child.const_set("PrivateRelation", Object)
+        end
+      end
+
+      class ::ActiveRecord::Base
+        class << self
+          prepend AciveRecordInheritDefineRelationTypes
+        end
+      end
+    end
+  end
+end

data/lib/boba/version.rb

@@ -1,3 +1,6 @@
+# typed: true
+# frozen_string_literal: true
+
 module Boba
-  VERSION = '0.0.2'
+  VERSION = "0.0.4"
 end

data/lib/boba.rb

@@ -0,0 +1,7 @@
+# typed: true
+# frozen_string_literal: true
+
+module Boba
+  require "boba/version"
+  require "boba/relations_railtie" if defined?(Rails)
+end

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

@@ -0,0 +1,225 @@
+# typed: ignore
+# frozen_string_literal: true
+
+return unless defined?(ActiveRecord::Base)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordAssociationsPersisted` extends the default Tapioca compiler `Tapioca::Dsl::Compilers::ActiveRecordAssociations`
+      # to provide an option to generate RBI files for associations on models assuming that the model is persisted. These sigs therefore respect
+      # validations and DB constraints, and generate non-nilable types for associations that are required or non-optional.
+      #
+      # This compiler accepts a `ActiveRecordAssociationTypes` option that can be used to specify
+      # how the types of `belongs_to` and `has_one` associations should be generated. The option can be one of the
+      # following:
+      #  - `nilable (_default_)`: All association methods will be generated with `T.nilable` return types. This is
+      #  strictly the most correct way to type the methods, but it can make working with the models more cumbersome, as
+      #  you will have to handle the `nil` cases explicitly using `T.must` or the safe navigation operator `&.`, even
+      #  for valid persisted models.
+      #  - `persisted`: The methods will be generated with the type that matches validations on the association. If
+      #  there is a `required: true` or `optional: false`, then the types will be generated as non-nilable. This mode
+      #  basically treats each model as if it was a valid and persisted model. Note that this makes typing Active Record
+      #  models easier, but does not match the behaviour of non-persisted or invalid models, which can have `nil`
+      #  associations.
+      #
+      # For example, with the following model class:
+      #
+      # ~~~rb
+      # class Post < ActiveRecord::Base
+      #   belongs_to :category
+      #   has_many :comments
+      #   has_one :author, class_name: "User", optional: false
+      #
+      #   accepts_nested_attributes_for :category, :comments, :author
+      # end
+      # ~~~
+      #
+      # By default, the compiler will generate types consistent with `Tapioca::Dsl::Compilers::ActiveRecordAssociationsPersisted`.
+      # If `ActiveRecordAssociationTypes` is `persisted`, the `author` method will be generated as:
+      # ~~~rbi
+      #     sig { returns(::User) }
+      #     def author; end
+      # ~~~
+      # and if the option is set to `untyped`, the `author` method will be generated as:
+      # ~~~rbi
+      #     sig { returns(T.untyped) }
+      #     def author; end
+      # ~~~
+      class ActiveRecordAssociationsPersisted < ::Tapioca::Dsl::Compilers::ActiveRecordAssociations
+        extend T::Sig
+
+        class AssociationTypeOption < T::Enum
+          extend T::Sig
+
+          enums do
+            Nilable = new("nilable")
+            Persisted = new("persisted")
+          end
+
+          class << self
+            extend T::Sig
+
+            sig do
+              params(
+                options: T::Hash[String, T.untyped],
+                block: T.proc.params(value: String, default_association_type_option: AssociationTypeOption).void,
+              ).returns(AssociationTypeOption)
+            end
+            def from_options(options, &block)
+              association_type_option = Nilable
+              value = options["ActiveRecordAssociationTypes"]
+
+              if value
+                if has_serialized?(value)
+                  association_type_option = from_serialized(value)
+                else
+                  block.call(value, association_type_option)
+                end
+              end
+
+              association_type_option
+            end
+          end
+
+          sig { returns(T::Boolean) }
+          def persisted?
+            self == AssociationTypeOption::Persisted
+          end
+
+          sig { returns(T::Boolean) }
+          def nilable?
+            self == AssociationTypeOption::Nilable
+          end
+        end
+
+        private
+
+        sig { returns(AssociationTypeOption) }
+        def association_type_option
+          @association_type_option ||= T.let(
+            AssociationTypeOption.from_options(options) do |value, default_association_type_option|
+              add_error(<<~MSG.strip)
+                Unknown value for compiler option `ActiveRecordAssociationTypes` given: `#{value}`.
+                Proceeding with the default value: `#{default_association_type_option.serialize}`.
+              MSG
+            end,
+            T.nilable(AssociationTypeOption),
+          )
+        end
+
+        sig do
+          params(
+            klass: RBI::Scope,
+            association_name: T.any(String, Symbol),
+            reflection: ReflectionType,
+          ).void
+        end
+        def populate_single_assoc_getter_setter(klass, association_name, reflection)
+          association_class = type_for(reflection)
+          association_type = single_association_type_for(reflection)
+          association_methods_module = constant.generated_association_methods
+
+          klass.create_method(
+            association_name.to_s,
+            return_type: association_type,
+          )
+          klass.create_method(
+            "#{association_name}=",
+            parameters: [create_param("value", type: association_type)],
+            return_type: "void",
+          )
+          klass.create_method(
+            "reload_#{association_name}",
+            return_type: association_type,
+          )
+          klass.create_method(
+            "reset_#{association_name}",
+            return_type: "void",
+          )
+          if association_methods_module.method_defined?("#{association_name}_changed?")
+            klass.create_method(
+              "#{association_name}_changed?",
+              return_type: "T::Boolean",
+            )
+          end
+          if association_methods_module.method_defined?("#{association_name}_previously_changed?")
+            klass.create_method(
+              "#{association_name}_previously_changed?",
+              return_type: "T::Boolean",
+            )
+          end
+          unless reflection.polymorphic?
+            klass.create_method(
+              "build_#{association_name}",
+              parameters: [
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("blk", type: "T.untyped"),
+              ],
+              return_type: association_class,
+            )
+            klass.create_method(
+              "create_#{association_name}",
+              parameters: [
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("blk", type: "T.untyped"),
+              ],
+              return_type: association_class,
+            )
+            klass.create_method(
+              "create_#{association_name}!",
+              parameters: [
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("blk", type: "T.untyped"),
+              ],
+              return_type: association_class,
+            )
+          end
+        end
+
+        sig do
+          params(
+            reflection: ReflectionType,
+          ).returns(String)
+        end
+        def single_association_type_for(reflection)
+          association_class = type_for(reflection)
+          return as_nilable_type(association_class) unless association_type_option.persisted?
+
+          if has_one_and_required_reflection?(reflection) || belongs_to_and_non_optional_reflection?(reflection)
+            association_class
+          else
+            as_nilable_type(association_class)
+          end
+        end
+
+        # Note - one can do more here. If the association's attribute has an unconditional presence validation, it
+        # should also be considered required.
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def has_one_and_required_reflection?(reflection)
+          reflection.has_one? && !!reflection.options[:required]
+        end
+
+        # Note - one can do more here. If the FK defining the belongs_to association is non-nullable at the DB level, or
+        # if the association's attribute has an unconditional presence validation, it should also be considered
+        # non-optional.
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def belongs_to_and_non_optional_reflection?(reflection)
+          return false unless reflection.belongs_to?
+
+          optional = if reflection.options.key?(:required)
+            !reflection.options[:required]
+          else
+            reflection.options[:optional]
+          end
+
+          if optional.nil?
+            !!reflection.active_record.belongs_to_required_by_default
+          else
+            !optional
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,358 @@
+# typed: ignore
+# frozen_string_literal: true
+
+return unless defined?(ActiveRecord::Base)
+
+require "tapioca/dsl/helpers/active_record_column_type_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordColumnsPersisted` is an extension of the default Tapioca compiler `Tapioca::Dsl::Compilers::ActiveRecordColumns`.
+      # It extends the `persisted` option of the `ActiveRecordColumnTypes` to respect not only database constraints, but
+      # also validations on the attributes in the model.
+      #
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This compiler is only responsible for defining the attribute methods that would be
+      # created for columns and virtual attributes that are defined in the Active Record
+      # model.
+      #
+      # This compiler accepts a `ActiveRecordColumnTypes` option that can be used to specify
+      # how the types of the column related methods should be generated. The option can be one of the following:
+      #  - `persisted` (_default_): The methods will be generated with the type that matches the actual database
+      #  column type as the return type. This means that if the column is a string, the method return type
+      #  will be `String`, but if the column is also nullable, then the return type will be `T.nilable(String)`. This
+      #  mode basically treats each model as if it was a valid and persisted model. Note that this makes typing
+      #  Active Record models easier, but does not match the behaviour of non-persisted or invalid models, which can
+      #  have all kinds of non-sensical values in their column attributes.
+      #  - `nilable`: All column methods will be generated with `T.nilable` return types. This is strictly the most
+      #  correct way to type the methods, but it can make working with the models more cumbersome, as you will have to
+      #  handle the `nil` cases explicitly using `T.must` or the safe navigation operator `&.`, even for valid
+      #  persisted models.
+      #  - `untyped`: The methods will be generated with `T.untyped` return types. This mode is practical if you are not
+      #  ready to start typing your models strictly yet, but still want to generate RBI files for them.
+      #
+      # For example, with the following model class:
+      # ~~~rb
+      # class Post < ActiveRecord::Base
+      # end
+      # ~~~
+      #
+      # and the following database schema:
+      #
+      # ~~~rb
+      # # db/schema.rb
+      # create_table :posts do |t|
+      #   t.string :title, null: false
+      #   t.string :body
+      #   t.boolean :published
+      #   t.timestamps
+      # end
+      # ~~~
+      #
+      # this compiler will, by default, produce the following methods in the RBI file
+      # `post.rbi`:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   include GeneratedAttributeMethods
+      #
+      #   module GeneratedAttributeMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def body; end
+      #
+      #     sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def body=; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def body?; end
+      #
+      #     sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+      #     def created_at; end
+      #
+      #     sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
+      #     def created_at=; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def created_at?; end
+      #
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def published; end
+      #
+      #     sig { params(value: T::Boolean).returns(T::Boolean) }
+      #     def published=; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def published?; end
+      #
+      #     sig { returns(::String) }
+      #     def title; end
+      #
+      #     sig { params(value: ::String).returns(::String) }
+      #     def title=(value); end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def title?; end
+      #
+      #     sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+      #     def updated_at; end
+      #
+      #     sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
+      #     def updated_at=; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def updated_at?; end
+      #
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveModel/Dirty.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html
+      #   end
+      # end
+      # ~~~
+      #
+      # However, if `ActiveRecordColumnTypes` is set to `nilable`, the `title` method will be generated as:
+      # ~~~rbi
+      #     sig { returns(T.nilable(::String)) }
+      #     def title; end
+      # ~~~
+      # and if the option is set to `untyped`, the `title` method will be generated as:
+      # ~~~rbi
+      #     sig { returns(T.untyped) }
+      #     def title; end
+      # ~~~
+      class ActiveRecordColumnsPersisted < ::Tapioca::Dsl::Compilers::ActiveRecordColumns
+        extend T::Sig
+
+        private
+
+        def column_type_helper
+          ::Tapioca::Dsl::Helpers::ActiveRecordColumnTypeHelper.new(
+            constant,
+            column_type_option: column_type_option,
+          )
+        end
+
+        sig do
+          params(
+            attribute_name: String,
+            column_name: String,
+          ).returns([String, String])
+        end
+        def type_for(attribute_name, column_name = attribute_name)
+          return column_type_helper.send(:id_type) if attribute_name == "id"
+
+          column_type_for(column_name)
+        end
+
+        sig { params(column_name: String).returns([String, String]) }
+        def column_type_for(column_name)
+          return ["T.untyped", "T.untyped"] if @column_type_option.untyped?
+
+          nilable_column = !has_non_null_database_constraint?(column_name) &&
+            !has_unconditional_presence_validator?(column_name)
+
+          column_type = @constant.attribute_types[column_name]
+          getter_type = column_type_helper.send(
+            :type_for_activerecord_value,
+            column_type,
+            column_nullability: nilable_column,
+          )
+          setter_type =
+            case column_type
+            when ActiveRecord::Enum::EnumType
+              column_type_helper.send(:enum_setter_type, column_type)
+            else
+              getter_type
+            end
+
+          if @column_type_option.persisted? && (virtual_attribute?(column_name) || !nilable_column)
+            [getter_type, setter_type]
+          else
+            getter_type = as_nilable_type(getter_type) unless column_type_helper.send(
+              :not_nilable_serialized_column?,
+              column_type,
+            )
+            [getter_type, as_nilable_type(setter_type)]
+          end
+        end
+
+        sig { params(column_name: String).returns(T::Boolean) }
+        def virtual_attribute?(column_name)
+          @constant.columns_hash[column_name].nil?
+        end
+
+        sig { params(column_name: String).returns(T::Boolean) }
+        def has_non_null_database_constraint?(column_name)
+          column = @constant.columns_hash[column_name]
+          return false if column.nil?
+
+          !column.null
+        end
+
+        sig { params(column_name: String).returns(T::Boolean) }
+        def has_unconditional_presence_validator?(column_name)
+          return false unless @constant.respond_to?(:validators_on)
+
+          @constant.validators_on(column_name).any? do |validator|
+            next false unless validator.is_a?(ActiveRecord::Validations::PresenceValidator)
+
+            !validator.options.key?(:if) && !validator.options.key?(:unless) && !validator.options.key?(:on)
+          end
+        end
+
+        sig do
+          params(
+            klass: RBI::Scope,
+            attribute_name: String,
+            column_name: String,
+            methods_to_add: T.nilable(T::Array[String]),
+          ).void
+        end
+        def add_methods_for_attribute(klass, attribute_name, column_name = attribute_name, methods_to_add = nil)
+          getter_type, setter_type = type_for(attribute_name, column_name)
+
+          # Added by ActiveRecord::AttributeMethods::Read
+          #
+          add_method(
+            klass,
+            attribute_name.to_s,
+            methods_to_add,
+            return_type: getter_type,
+          )
+
+          # Added by ActiveRecord::AttributeMethods::Write
+          #
+          add_method(
+            klass,
+            "#{attribute_name}=",
+            methods_to_add,
+            parameters: [create_param("value", type: setter_type)],
+            return_type: setter_type,
+          )
+
+          # Added by ActiveRecord::AttributeMethods::Query
+          #
+          add_method(
+            klass,
+            "#{attribute_name}?",
+            methods_to_add,
+            return_type: "T::Boolean",
+          )
+
+          # Added by ActiveRecord::AttributeMethods::Dirty
+          #
+          add_method(
+            klass,
+            "#{attribute_name}_before_last_save",
+            methods_to_add,
+            return_type: as_nilable_type(getter_type),
+          )
+          add_method(
+            klass,
+            "#{attribute_name}_change_to_be_saved",
+            methods_to_add,
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+          )
+          add_method(
+            klass,
+            "#{attribute_name}_in_database",
+            methods_to_add,
+            return_type: as_nilable_type(getter_type),
+          )
+          add_method(
+            klass,
+            "saved_change_to_#{attribute_name}",
+            methods_to_add,
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+          )
+          add_method(
+            klass,
+            "saved_change_to_#{attribute_name}?",
+            methods_to_add,
+            return_type: "T::Boolean",
+          )
+          add_method(
+            klass,
+            "will_save_change_to_#{attribute_name}?",
+            methods_to_add,
+            return_type: "T::Boolean",
+          )
+
+          # Added by ActiveModel::Dirty
+          #
+          add_method(
+            klass,
+            "#{attribute_name}_change",
+            methods_to_add,
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+          )
+          add_method(
+            klass,
+            "#{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,
+            "#{attribute_name}_will_change!",
+            methods_to_add,
+          )
+          add_method(
+            klass,
+            "#{attribute_name}_was",
+            methods_to_add,
+            return_type: as_nilable_type(getter_type),
+          )
+          add_method(
+            klass,
+            "#{attribute_name}_previous_change",
+            methods_to_add,
+            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+          )
+          add_method(
+            klass,
+            "#{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,
+            "#{attribute_name}_previously_was",
+            methods_to_add,
+            return_type: as_nilable_type(getter_type),
+          )
+          add_method(
+            klass,
+            "restore_#{attribute_name}!",
+            methods_to_add,
+          )
+
+          # Added by ActiveRecord::AttributeMethods::BeforeTypeCast
+          #
+          add_method(
+            klass,
+            "#{attribute_name}_before_type_cast",
+            methods_to_add,
+            return_type: "T.untyped",
+          )
+          add_method(
+            klass,
+            "#{attribute_name}_came_from_user?",
+            methods_to_add,
+            return_type: "T::Boolean",
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,18 +1,43 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
-return unless defined?(::MoneyRails)
+return unless defined?(MoneyRails)
 
-require 'tapioca/helpers/rbi_helper'
+require "tapioca/helpers/rbi_helper"
 
 module Tapioca
   module Dsl
     module Compilers
+      # `Tapioca::Dsl::Compilers::MoneyRails` decorates RBI files for classes that use the `monetize` method provided
+      # by the `money-rails` gem.
+      # https://github.com/RubyMoney/money-rails
+      #
+      # For example, with the following ActiveRecord model:
+      # ~~~rb
+      # class Product < ActiveRecord::Base
+      #   monetize :price_cents
+      # end
+      # ~~~
+      #
+      # This compiler will generate the following RBI:
+      # ~~~rbi
+      # class Product
+      #  include MoneyRailsGeneratedMethods
+      #
+      #  module MoneyRailsGeneratedMethods
+      #    sig { returns(::Money) }
+      #    def price; end
+      #
+      #    sig { params(value: ::Money).returns(::Money) }
+      #    def price=(value); end
+      #  end
+      # end
+      # ~~~
       class MoneyRails < Tapioca::Dsl::Compiler
         extend T::Sig
         include RBIHelper
 
-        ConstantType = type_member {{ fixed: T.class_of(::MoneyRails::ActiveRecord::Monetizable) }}
+        ConstantType = type_member { { fixed: T.class_of(::MoneyRails::ActiveRecord::Monetizable) } }
 
         class << self
           extend T::Sig
@@ -28,13 +53,13 @@ module Tapioca
           return if constant.monetized_attributes.empty?
 
           root.create_path(constant) do |klass|
-            instance_module_name = 'MoneyRailsGeneratedMethods'
+            instance_module_name = "MoneyRailsGeneratedMethods"
             instance_module = RBI::Module.new(instance_module_name)
 
             constant.monetized_attributes.each do |attribute_name, column_name|
               column = T.unsafe(constant).columns_hash[column_name]
 
-              type_name = '::Money'
+              type_name = "::Money"
               type_name = as_nilable_type(type_name) if column.nil? || !!column.null
 
               # Model: monetize :amount_cents
@@ -43,7 +68,7 @@ module Tapioca
               instance_module.create_method(attribute_name, return_type: type_name)
               instance_module.create_method(
                 "#{attribute_name}=",
-                parameters: [create_param('value', type: type_name)],
+                parameters: [create_param("value", type: type_name)],
                 return_type: type_name,
               )
             end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Angellist
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-static-and-runtime
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: 0.16.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: 0.16.2
 description:
 email:
 - alex.stathis@angellist.com
@@ -47,13 +47,20 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/boba.rb
+- lib/boba/relations_railtie.rb
 - lib/boba/version.rb
+- lib/tapioca/dsl/compilers/active_record_associations_persisted.rb
+- lib/tapioca/dsl/compilers/active_record_columns_persisted.rb
 - lib/tapioca/dsl/compilers/money_rails.rb
 homepage: https://github.com/angellist/boba
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/angellist/boba/tree/v0.0.2
+  bug_tracker_uri: https://github.com/angellist/boba/issues
+  changelog_uri: https://github.com/angellist/boba/blob/0.0.4/History.md
+  homepage_uri: https://github.com/angellist/boba
+  source_code_uri: https://github.com/angellist/boba/tree/0.0.4
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []