boba 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cbef69a3715be625d4af0b5bf408b3822cc09fef287e8bcd1acd1a6c6377280
-  data.tar.gz: f47e14bbf2f23c02f45190053fdcbbfd29aee7de39e3d698919bbb97db96dd8a
+  metadata.gz: cb49413d3cfe01c4ea9d7cf283c50f03183f521e198b0af96e30fd0ec95fb7d4
+  data.tar.gz: 7f2dd02645cce05f8204a710b6a787e0aa7271fc902bea0f4c0e0174ffe7cf99
 SHA512:
-  metadata.gz: feb7409b2a58e5d48e8e2b5fb6efa47adf622f4a74b5d8a0dd52c976118b03142c983949e0996d1535fe3d0da565f2785978c0de5d5524ded192394be15148aa
-  data.tar.gz: 1f8edb8084ab4115c01c522b0ed0e82d0dd1f3e6720554995df3abbe0842f22865bd08cec7315850482dda117e382cb6954adc976925ec3a1c83de3d03b3c003
+  metadata.gz: 87d9819bf315f321c8aaf3e33f6681606cc980384b2a7f61ceda298097cc955a291e91a1b7ef7e0c1e2e3763570cf79d244e1eebfb07766404bb60283732c8bd
+  data.tar.gz: 5cd15d8a5d1a16eba4258240ce240c17063dc5b538dfb9346bf1209e5ab0ae18af667ca710b2e2c0e086261c9b110abc7f6dfac78122fbaacc567b53125afe82

data/README.md

@@ -36,7 +36,8 @@ If you'd like to use relation types in your sigs that are less broad than `Activ
   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:
+The railtie will automatically define the `PrivateRelation`, `PrivateAssociationRelation`, and `PrivateCollectionProxy` constants on each model that inherits from `ActiveRecord::Base`. These are defined as their corresponding private `ActiveRecord` classes, so runtime type checking works as expected. They can then be used in typing, like so:
+
 ```ruby
 class Post < ::ActiveRecord::Base
   scope :recent -> { where('created_at > ?', Date.current) }
@@ -49,7 +50,7 @@ sig { params(author: Author).returns(Post::PrivateRelation) }
 def posts_from_author(author); end
 ```
 
-and the following should not raise an error:
+and the following should not raise a Sorbet error:
 
 ```ruby
 sig { params(author: Author).returns(Post::PrivateRelation) }
@@ -58,6 +59,15 @@ def recent_posts_from_author(author)
 end
 ```
 
+Boba also defines a type alias `RelationType` on each such class, which is defined as the union of the three relation types. This is useful because the relation types are often used interchangeably and so you may expect to return or pass any of the three classes as an argument. To use this, you will also need to use the `ActiveRecordRelationTypes` compiler to generate the type alias in the signatures as well (or define them manually in shims).
+
+```ruby
+sig { params(author: Author).returns(Post::RelationType) }
+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).
@@ -71,7 +81,3 @@ Since Boba is intended to be used alongside Tapioca and the compilers provided b
 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. Specs & spec harness

data/lib/boba/active_record/attribute_service.rb

@@ -7,15 +7,22 @@ module Boba
       class << self
         extend T::Sig
 
-        sig { params(constant: T.class_of(::ActiveRecord::Base), attribute: String).returns(T::Boolean) }
-        def has_unconditional_presence_validator?(constant, attribute)
-          return false unless constant.respond_to?(:validators_on)
+        sig do
+          params(
+            constant: T.class_of(::ActiveRecord::Base),
+            attribute: String,
+            column_name: String,
+          ).returns(T::Boolean)
+        end
+        def nilable_attribute?(constant, attribute, column_name: attribute)
+          return false if has_non_null_database_constraint?(constant, column_name)
 
-          constant.validators_on(attribute).any? do |validator|
-            next false unless validator.is_a?(::ActiveRecord::Validations::PresenceValidator)
+          !has_unconditional_presence_validator?(constant, attribute)
+        end
 
-            !validator.options.key?(:if) && !validator.options.key?(:unless) && !validator.options.key?(:on)
-          end
+        sig { params(constant: T.class_of(::ActiveRecord::Base), column_name: String).returns(T::Boolean) }
+        def virtual_attribute?(constant, column_name)
+          constant.columns_hash[column_name].nil?
         end
 
         sig { params(constant: T.class_of(::ActiveRecord::Base), column_name: String).returns(T::Boolean) }
@@ -28,9 +35,27 @@ module Boba
           false
         end
 
-        sig { params(constant: T.class_of(::ActiveRecord::Base), column_name: String).returns(T::Boolean) }
-        def virtual_attribute?(constant, column_name)
-          constant.columns_hash[column_name].nil?
+        sig { params(constant: T.class_of(::ActiveRecord::Base), attribute: String).returns(T::Boolean) }
+        def has_unconditional_presence_validator?(constant, attribute)
+          return false unless constant.respond_to?(:validators_on)
+
+          constant.validators_on(attribute).any? do |validator|
+            unconditional_presence_validator?(validator)
+          end
+        end
+
+        private
+
+        sig { params(validator: ActiveModel::Validator).returns(T::Boolean) }
+        def unconditional_presence_validator?(validator)
+          return false unless validator.is_a?(::ActiveRecord::Validations::PresenceValidator)
+
+          unconditional_validator?(validator)
+        end
+
+        sig { params(validator: ActiveModel::Validator).returns(T::Boolean) }
+        def unconditional_validator?(validator)
+          !validator.options.key?(:if) && !validator.options.key?(:unless) && !validator.options.key?(:on)
         end
       end
     end

data/lib/boba/active_record/reflection_service.rb

@@ -13,13 +13,24 @@ module Boba
           T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
         end
 
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def required_reflection?(reflection)
+          return true if has_one_and_required_reflection?(reflection)
+
+          belongs_to_and_non_optional_reflection?(reflection)
+        end
+
+        private
+
         sig { params(reflection: ReflectionType).returns(T::Boolean) }
         def has_one_and_required_reflection?(reflection)
           return false unless reflection.has_one?
           return true if !!reflection.options[:required]
-          return true if reflection_required_by_database_constraint?(reflection)
 
-          reflection_required_by_validation?(reflection)
+          Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+            reflection.active_record,
+            reflection.name.to_s,
+          )
         end
 
         sig { params(reflection: ReflectionType).returns(T::Boolean) }
@@ -32,36 +43,21 @@ module Boba
             reflection.options[:optional]
           end
           return !optional unless optional.nil?
-          return true if reflection_required_by_database_constraint?(reflection)
-          return true if reflection_required_by_validation?(reflection)
-
-          # nothing defined, so fall back to the default active record config
-          !!reflection.active_record.belongs_to_required_by_default
-        end
-
-        private
-
-        # check for non-nullable database constraint on the foreign key
-        sig { params(reflection: ReflectionType).returns(T::Boolean) }
-        def reflection_required_by_database_constraint?(reflection)
-          Boba::ActiveRecord::AttributeService.has_non_null_database_constraint?(
+          return true if Boba::ActiveRecord::AttributeService.has_non_null_database_constraint?(
             reflection.active_record,
-            reflection.foreign_key,
+            reflection.foreign_key.to_s,
           )
-        end
-
-        # check for presence validator on the foreign key or on the association
-        sig { params(reflection: ReflectionType).returns(T::Boolean) }
-        def reflection_required_by_validation?(reflection)
           return true if Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
             reflection.active_record,
-            reflection.foreign_key,
+            reflection.foreign_key.to_s,
           )
-
-          Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+          return true if Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
             reflection.active_record,
-            reflection.name,
+            reflection.name.to_s,
           )
+
+          # nothing defined, so fall back to the default active record config
+          !!reflection.active_record.belongs_to_required_by_default
         end
       end
     end

data/lib/boba/options/association_type_option.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Boba
+  module Options
+    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
+  end
+end

data/lib/boba/relations_railtie.rb

@@ -6,15 +6,30 @@ require "rails/railtie"
 class Boba::RelationsRailtie < Rails::Railtie
   railtie_name(:boba)
 
-  initializer("boba.add_private_relation_constant") do
+  initializer("boba.add_private_relation_constants") do
     ActiveSupport.on_load(:active_record) do
       module AciveRecordInheritDefineRelationTypes
         def inherited(child)
           super(child)
 
-          child.const_set("PrivateRelation", Object)
-          child.const_set("PrivateAssociationRelation", Object)
-          child.const_set("PrivateCollectionProxy", Object)
+          # Tapioca defines these three classes for each active record model as proxies for the actual AR internal
+          # classes. In order to be able to use these as types in signatures, we need to expose them as actual constants
+          # at runtime. Tapioca intentionally obfuscates these classes because they're private, so exposing them is
+          # _slightly_ dangerous in that someone could do something naughty. But we're not super worried about it.
+          child.const_set("PrivateRelation", child.const_get(:ActiveRecord_Relation))
+          child.const_set("PrivateAssociationRelation", child.const_get(:ActiveRecord_AssociationRelation))
+          child.const_set("PrivateCollectionProxy", child.const_get(:ActiveRecord_Associations_CollectionProxy))
+
+          # Expose a common type so that signatures can be typed to the broader `RelationType` since the three are often
+          # used interchangeably.
+          relation_type = T.type_alias do
+            T.any(
+              child.const_get(:PrivateRelation),
+              child.const_get(:PrivateAssociationRelation),
+              child.const_get(:PrivateCollectionProxy),
+            )
+          end
+          child.const_set(:RelationType, relation_type)
         end
       end
 

data/lib/boba/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Boba
-  VERSION = "0.0.12"
+  VERSION = "0.0.14"
 end

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

@@ -6,6 +6,7 @@ require "tapioca/dsl/compilers/active_record_associations"
 return unless defined?(Tapioca::Dsl::Compilers::ActiveRecordAssociations)
 
 require "boba/active_record/reflection_service"
+require "boba/options/association_type_option"
 
 module Tapioca
   module Dsl
@@ -53,62 +54,18 @@ module Tapioca
       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) }
+        sig { returns(Boba::Options::AssociationTypeOption) }
         def association_type_option
           @association_type_option ||= T.let(
-            AssociationTypeOption.from_options(options) do |value, default_association_type_option|
+            Boba::Options::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),
+            T.nilable(Boba::Options::AssociationTypeOption),
           )
         end
 
@@ -190,9 +147,7 @@ module Tapioca
           association_class = type_for(reflection)
           return as_nilable_type(association_class) unless association_type_option.persisted?
 
-          if Boba::ActiveRecord::ReflectionService.has_one_and_required_reflection?(reflection)
-            association_class
-          elsif Boba::ActiveRecord::ReflectionService.belongs_to_and_non_optional_reflection?(reflection)
+          if Boba::ActiveRecord::ReflectionService.required_reflection?(reflection)
             association_class
           else
             as_nilable_type(association_class)

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

@@ -153,14 +153,7 @@ module Tapioca
         def column_type_for(column_name)
           return ["T.untyped", "T.untyped"] if column_type_option.untyped?
 
-          nilable_column = !Boba::ActiveRecord::AttributeService.has_non_null_database_constraint?(
-            @constant,
-            column_name,
-          )
-          nilable_column &&= !Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
-            @constant,
-            column_name,
-          )
+          nilable_column = Boba::ActiveRecord::AttributeService.nilable_attribute?(@constant, column_name)
 
           column_type = @constant.attribute_types[column_name]
           getter_type = column_type_helper.send(

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

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(ActiveRecord::Base)
+
+require "tapioca/dsl/helpers/active_record_constants_helper"
+require "tapioca/dsl/compilers/active_record_relations"
+
+return unless defined?(Tapioca::Dsl::Compilers::ActiveRecordRelations)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordRelationTypes` extends
+      # `Tapioca::Dsl::Compilers::ActiveRecordRelationTypes` to generate a `RelationType` type alias for each class.
+      # This type alias is defined a runtime through the Boba railtie, and is useful for typing signatures to accept or
+      # return relations. For instance, with the following `ActiveRecord::Base` subclass:
+      # ~~~rb
+      # class Post < ApplicationRecord
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `post.rbi` with the following content:
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      #
+      # class Post
+      #   RelationType = T.any(PrivateRelation, PrivateAssociationRelation, PrivateCollectionProxy)
+      # end
+      # ~~~
+      # So that the following method will accept any of the private relation types as an argument:
+      # ~~~rb
+      # sig { params(posts: Post::RelationType).void }
+      # def process_posts(posts)
+      #   # ...
+      # end
+      # ~~~
+      class ActiveRecordRelationTypes < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |rbi_class|
+            relation_type_alias = "T.any(" \
+              "#{Tapioca::Dsl::Helpers::ActiveRecordConstantsHelper::RelationClassName}, " \
+              "#{Tapioca::Dsl::Helpers::ActiveRecordConstantsHelper::AssociationRelationClassName}, " \
+              "#{Tapioca::Dsl::Helpers::ActiveRecordConstantsHelper::AssociationsCollectionProxyClassName}" \
+              ")"
+            rbi_class.create_type_variable("RelationType", type: "T.type_alias { #{relation_type_alias} }")
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            Tapioca::Dsl::Compilers::ActiveRecordRelations.gather_constants
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
-return if !defined?(AttrJson::Record)
+return unless defined?(AttrJson::Record)
 
 module Tapioca
   module Dsl
@@ -39,7 +39,7 @@ module Tapioca
         # Class methods module is already defined in the gem rbi, so just reference it here.
         ClassMethodsModuleName = "AttrJson::Record::ClassMethods"
         InstanceMethodModuleName = "AttrJsonGeneratedMethods"
-        ConstantType = type_member {{ fixed: T.any(T.class_of(::AttrJson::Record), T.class_of(::AttrJson::Model)) }}
+        ConstantType = type_member { { fixed: T.any(T.class_of(::AttrJson::Record), T.class_of(::AttrJson::Model)) } }
 
         class << self
           extend T::Sig
@@ -65,7 +65,7 @@ module Tapioca
         private
 
         def decorate_attributes(rbi_scope)
-          T.unsafe(constant).attr_json_registry
+          constant.attr_json_registry
             .definitions
             .sort_by(&:name) # this is annoying, but we need to sort to force consistent ordering or the rbi checks fail
             .each do |definition|
@@ -122,7 +122,7 @@ module Tapioca
 
           sorbet_type = "::#{sorbet_type}"
           sorbet_type = "T::Array[#{sorbet_type}]" if array
-          sorbet_type = "T.nilable(#{sorbet_type})" if nilable # todo: improve this
+          sorbet_type = "T.nilable(#{sorbet_type})" if nilable # TODO: improve this
 
           sorbet_type
         end

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

@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Kaminari)
+
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Kaminari` decorates RBI files for models
+      # using Kaminari.
+      #
+      # For example, with Kaminari installed and the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ApplicationRecord
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   extend GeneratedRelationMethods
+      #
+      #   module GeneratedRelationMethods
+      #     sig do
+      #       params(
+      #         num: T.any(Integer, String)
+      #       ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
+      #     end
+      #     def page(num = nil); end
+      #   end
+      # end
+      # ~~~
+      class Kaminari < Tapioca::Dsl::Compiler
+        extend T::Sig
+        include Helpers::ActiveRecordConstantsHelper
+
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |model|
+            target_modules.each do |module_name, return_type|
+              model.create_module(module_name).create_method(
+                ::Kaminari.config.page_method_name.to_s,
+                parameters: [create_opt_param("num", type: "T.any(Integer, String)", default: "nil")],
+                return_type: "T.all(#{return_type}, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)",
+              )
+            end
+
+            model.create_extend(RelationMethodsModuleName)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          end
+        end
+
+        private
+
+        sig { returns(T::Array[[String, String]]) }
+        def target_modules
+          if compiler_enabled?("ActiveRecordRelations")
+            [
+              [RelationMethodsModuleName, RelationClassName],
+              [AssociationRelationMethodsModuleName, AssociationRelationClassName],
+            ]
+          else
+            [[RelationMethodsModuleName, "T.untyped"]]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,8 @@
 return unless defined?(MoneyRails)
 
 require "tapioca/helpers/rbi_helper"
+require "tapioca/dsl/helpers/active_record_column_type_helper"
+require "boba/active_record/attribute_service"
 
 module Tapioca
   module Dsl
@@ -37,7 +39,14 @@ module Tapioca
         extend T::Sig
         include RBIHelper
 
-        ConstantType = type_member { { fixed: T.class_of(::MoneyRails::ActiveRecord::Monetizable) } }
+        ConstantType = type_member do
+          {
+            fixed: T.all(
+              T.class_of(::MoneyRails::ActiveRecord::Monetizable),
+              ::MoneyRails::ActiveRecord::Monetizable::ClassMethods,
+            ),
+          }
+        end
 
         class << self
           extend T::Sig
@@ -48,6 +57,21 @@ module Tapioca
           end
         end
 
+        ColumnTypeOption = Tapioca::Dsl::Helpers::ActiveRecordColumnTypeHelper::ColumnTypeOption
+
+        sig { returns(ColumnTypeOption) }
+        def column_type_option
+          @column_type_option ||= T.let(
+            ColumnTypeOption.from_options(options) do |value, default_column_type_option|
+              add_error(<<~MSG.strip)
+                Unknown value for compiler option `ActiveRecordColumnTypes` given: `#{value}`.
+                Proceeding with the default value: `#{default_column_type_option.serialize}`.
+              MSG
+            end,
+            T.nilable(ColumnTypeOption),
+          )
+        end
+
         sig { override.void }
         def decorate
           return if constant.monetized_attributes.empty?
@@ -57,10 +81,23 @@ module Tapioca
             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]
+              if column_type_option.untyped?
+                type_name = "T.untyped"
+              else
+                type_name = "::Money"
+
+                nilable_attribute = if constant < ::ActiveRecord::Base && column_type_option.persisted?
+                  Boba::ActiveRecord::AttributeService.nilable_attribute?(
+                    T.cast(constant, T.class_of(::ActiveRecord::Base)),
+                    attribute_name,
+                    column_name: column_name,
+                  )
+                else
+                  true
+                end
 
-              type_name = "::Money"
-              type_name = as_nilable_type(type_name) if column.nil? || !!column.null
+                type_name = as_nilable_type(type_name) if nilable_attribute
+              end
 
               # Model: monetize :amount_cents
               # => amount

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Angellist
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-30 00:00:00.000000000 Z
+date: 2024-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-static-and-runtime
@@ -50,11 +50,14 @@ files:
 - lib/boba.rb
 - lib/boba/active_record/attribute_service.rb
 - lib/boba/active_record/reflection_service.rb
+- lib/boba/options/association_type_option.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/active_record_relation_types.rb
 - lib/tapioca/dsl/compilers/attr_json.rb
+- lib/tapioca/dsl/compilers/kaminari.rb
 - lib/tapioca/dsl/compilers/money_rails.rb
 - lib/tapioca/dsl/compilers/paperclip.rb
 - lib/tapioca/dsl/compilers/state_machines_extended.rb
@@ -63,9 +66,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/angellist/boba/issues
-  changelog_uri: https://github.com/angellist/boba/blob/0.0.12/History.md
+  changelog_uri: https://github.com/angellist/boba/blob/0.0.14/History.md
   homepage_uri: https://github.com/angellist/boba
-  source_code_uri: https://github.com/angellist/boba/tree/0.0.12
+  source_code_uri: https://github.com/angellist/boba/tree/0.0.14
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []