boba 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ff9566546cf590673a7cadc4eec67aa44e91a3ad2d0c04610d8a8d928464a57
-  data.tar.gz: 4e505d2aa2274290fa2beadf0d00988acf96948451c20d5a84ffa2097e3ef819
+  metadata.gz: 76f99ba4fafb5f1a55c1abb60b0c099569f3f4153c4f0f0b43ced158e02fb59b
+  data.tar.gz: 1de40e562d0dbeb3c0b2a987cd4e2898321a62550a239941cb129f5690da042d
 SHA512:
-  metadata.gz: 15db509c3ae4d466b7b2a1e6e3cc863a62bc1326446be905b7945705a22aff99c09024edceb1fd82e7a6fdd6fbdca111b331b32830d236c8dadbc6f487d43692
-  data.tar.gz: 66df338170b5d2ecb3054c05fd0b707d163b3262f7e0f6a82dcd4014abfdea6124f69b23be53b8335609b273da467b936f3cc77ae8604f32e2e9ca508318a15d
+  metadata.gz: fbc7d9e5ee8248a1175e499f891716d0397136cc20e1e6db65c22c6d61d777ea756c2c992e48694375358a748986bca2bd2c70393601c8185faf49e1ea7f9e39
+  data.tar.gz: 23d4d817f6b1a14345599d027c5fbed2203a32709d1cd955568ee69b7475b4551e31308936c02d4e2c26c403af292070f301c9258eed40fdba0b17414ad346f4

data/README.md

@@ -6,15 +6,18 @@ 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.
+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
 
 Add Boba to your development dependencies in your gemfile:
 ```ruby
 group :development do
-  gem 'boba'
+  gem 'boba', require: false
 end
 ```
 
@@ -26,10 +29,24 @@ dsl:
     Compiler1
     Compiler2
 ```
+This makes it easy to selectively enable only the compilers you want to use in your project.
+
+## 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/version.rb

@@ -1,3 +1,6 @@
+# typed: true
+# frozen_string_literal: true
+
 module Boba
-  VERSION = '0.0.1'
+  VERSION = "0.0.3"
 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.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Angellist
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-09-21 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
@@ -48,11 +48,18 @@ files:
 - LICENSE
 - README.md
 - 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: {}
+metadata:
+  bug_tracker_uri: https://github.com/angellist/boba/issues
+  changelog_uri: https://github.com/angellist/boba/blob/0.0.3/History.md
+  homepage_uri: https://github.com/angellist/boba
+  source_code_uri: https://github.com/angellist/boba/tree/0.0.3
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: