boba 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c88ef5656da55d5a864ad1bf3b5231907260c62f2239964f47921368dbffea8
-  data.tar.gz: c32f3fe6f3063407146db5559cee2d6714474e9f69eb769ce39278c961908537
+  metadata.gz: cb49413d3cfe01c4ea9d7cf283c50f03183f521e198b0af96e30fd0ec95fb7d4
+  data.tar.gz: 7f2dd02645cce05f8204a710b6a787e0aa7271fc902bea0f4c0e0174ffe7cf99
 SHA512:
-  metadata.gz: ba9b4ccc7ffb27011848c62428a8cbed4cf9556bc3b63c04a4db867ed08ca12c2f16f48bc9f4c1f0ade04bd769d5033a977bc1e34f85115995c31dcdd65d21e0
-  data.tar.gz: dfe9d28722a6191722271c44b64ba2aec62eca438534b9617b2806d460c35c171635a662d6a6033d96220de6f3ff40cf0d4dc5e4122643ecad4fe3b6b6ac9b52
+  metadata.gz: 87d9819bf315f321c8aaf3e33f6681606cc980384b2a7f61ceda298097cc955a291e91a1b7ef7e0c1e2e3763570cf79d244e1eebfb07766404bb60283732c8bd
+  data.tar.gz: 5cd15d8a5d1a16eba4258240ce240c17063dc5b538dfb9346bf1209e5ab0ae18af667ca710b2e2c0e086261c9b110abc7f6dfac78122fbaacc567b53125afe82

data/README.md

@@ -81,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/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Boba
-  VERSION = "0.0.13"
+  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

@@ -11,10 +11,10 @@ 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:
+      # `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

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.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Angellist
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-01 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,12 +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
@@ -64,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.13/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.13
+  source_code_uri: https://github.com/angellist/boba/tree/0.0.14
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []