boba 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8819547e35a1566b8b772069f87ae189a4d1faa0bc7b3426e69c01b286fb372b
-  data.tar.gz: 23e40a45b04a32ee32322d2123eabb3dc9e06829df556af916b1a2885cb04168
+  metadata.gz: c574e47f38c05d56093ec30f3f1328e28440c4ad2511567e0015106798569e44
+  data.tar.gz: cdeb013e429306a83dd5a41023fb73c311180d88e89923cccba55eff5a613dda
 SHA512:
-  metadata.gz: a71b576ebd62ccfb4cde1a8383ad3dfccabb7a1f6812f35ad54ca8f3def3d1c014c493d86d7a973939c6f425a3a2eeebd62ec77df5c94b91840c1ada25b283d1
-  data.tar.gz: '0417790d2c32e3faa556a22b6a9deab60581f3b6534f04451c87b89e74b4aa67ef0e3608eaf782a2343d83b1319e7461e3ca841a842dd557dda7ba83c78db4d2'
+  metadata.gz: 93de6c75462a9824d8cacd0fc0fec7ae246694eb0c63acf216cc0f04f3eb4fee94e9b98a77b6e65879eb8c11d41bf47fc06dae535b4767ecbab15150cc0c43ec
+  data.tar.gz: 2de09551f27c892aa5317aa133f30e67b70dfa9bfbc16e7c4474e089909ba7d3bf7d1178109f94f48b09a17d774425b3d51e1eb778629b2834135d1a66daad61

data/lib/boba/active_record/attribute_service.rb

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Boba
+  module ActiveRecord
+    module AttributeService
+      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)
+
+          constant.validators_on(attribute).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 { params(constant: T.class_of(::ActiveRecord::Base), column_name: String).returns(T::Boolean) }
+        def has_non_null_database_constraint?(constant, column_name)
+          column = constant.columns_hash[column_name]
+          return false if column.nil?
+
+          !column.null
+        rescue StandardError
+          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?
+        end
+      end
+    end
+  end
+end

data/lib/boba/active_record/reflection_service.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative("attribute_service")
+
+module Boba
+  module ActiveRecord
+    module ReflectionService
+      class << self
+        extend T::Sig
+
+        ReflectionType = T.type_alias do
+          T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
+        end
+
+        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)
+        end
+
+        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
+          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?(
+            reflection.active_record,
+            reflection.foreign_key,
+          )
+        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,
+          )
+
+          Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+            reflection.active_record,
+            reflection.name,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/boba/version.rb

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

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

@@ -5,6 +5,8 @@ require "tapioca/dsl/compilers/active_record_associations"
 
 return unless defined?(Tapioca::Dsl::Compilers::ActiveRecordAssociations)
 
+require "boba/active_record/reflection_service"
+
 module Tapioca
   module Dsl
     module Compilers
@@ -188,39 +190,14 @@ module Tapioca
           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)
+          if Boba::ActiveRecord::ReflectionService.has_one_and_required_reflection?(reflection)
+            association_class
+          elsif Boba::ActiveRecord::ReflectionService.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

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

@@ -5,6 +5,7 @@ require "tapioca/dsl/compilers/active_record_columns"
 
 return unless defined?(Tapioca::Dsl::Compilers::ActiveRecordColumns)
 
+require "boba/active_record/attribute_service"
 require "tapioca/dsl/helpers/active_record_column_type_helper"
 
 module Tapioca
@@ -150,10 +151,16 @@ module Tapioca
 
         sig { params(column_name: String).returns([String, String]) }
         def column_type_for(column_name)
-          return ["T.untyped", "T.untyped"] if @column_type_option.untyped?
+          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)
+          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,
+          )
 
           column_type = @constant.attribute_types[column_name]
           getter_type = column_type_helper.send(
@@ -169,7 +176,8 @@ module Tapioca
               getter_type
             end
 
-          if @column_type_option.persisted? && (virtual_attribute?(column_name) || !nilable_column)
+          virtual_attribute = Boba::ActiveRecord::AttributeService.virtual_attribute?(@constant, column_name)
+          if column_type_option.persisted? && (virtual_attribute || !nilable_column)
             [getter_type, setter_type]
           else
             getter_type = as_nilable_type(getter_type) unless column_type_helper.send(
@@ -180,30 +188,6 @@ module Tapioca
           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,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Angellist
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-12 00:00:00.000000000 Z
+date: 2024-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-static-and-runtime
@@ -48,6 +48,8 @@ files:
 - LICENSE
 - README.md
 - lib/boba.rb
+- lib/boba/active_record/attribute_service.rb
+- lib/boba/active_record/reflection_service.rb
 - lib/boba/relations_railtie.rb
 - lib/boba/version.rb
 - lib/tapioca/dsl/compilers/active_record_associations_persisted.rb
@@ -59,9 +61,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/angellist/boba/issues
-  changelog_uri: https://github.com/angellist/boba/blob/0.0.6/History.md
+  changelog_uri: https://github.com/angellist/boba/blob/0.0.8/History.md
   homepage_uri: https://github.com/angellist/boba
-  source_code_uri: https://github.com/angellist/boba/tree/0.0.6
+  source_code_uri: https://github.com/angellist/boba/tree/0.0.8
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []