boba 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6617f4443fb1796f5d0a55766e42dec078ab79b0090e6df248fbb02224ebc9fc
-  data.tar.gz: 0c3f0c9e08b090e076a3d0a446541fb46341f2a630cd2e4718a9a4873eab218a
+  metadata.gz: f7db0fba3021c2e619b8ba2a5e8d7a19173a4b66fc63f16f72ca6e3bc140ed5b
+  data.tar.gz: c655306579accf7b2d76bdd5e4643a16926dddb2d1bf9cf48a1a065134f11c6b
 SHA512:
-  metadata.gz: 971bd8bada42707d12ca53ffb760cf765c2b203c118a6259de66089014e61bb47cce73ab9b0fd8175052e4c15ece1c800870b39802aca9ed093e8b838147628b
-  data.tar.gz: e1fc1a2051aa58506c10ffabc2d3419ddfdb977445b28ad734e4b7b17dceceba3066ace8c635782255070f45a97652a5b87d591464ddff54757f7d266197411c
+  metadata.gz: 6f24939c06e8e727a21c0c30d9d881493ef7de1acb88fe292384c457c73df059ae68a24c3a3a615873da40ea4d646e0fd9cb62379dc6c026ca553b47a6655ff3
+  data.tar.gz: 3c0f1b1931937e93a274513e47954d67605203edc9fceee6552a1aac8121af7a71bc7469e11be1a63c222fe81ba1e6b3759d415d1cc0a49bf881fb009518c24c

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.7"
+  VERSION = "0.0.9"
 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
@@ -152,8 +153,14 @@ module Tapioca
         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)
+          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,

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+# typed: true
+
+return if !defined?(AttrJson::Record)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::AttrJson` decorates RBI files for classes that use the `AttrJson` gem.
+      # https://github.com/jrochkind/attr_json
+      #
+      # For example, with the following ActiveRecord model:
+      # ~~~rb
+      # class Product < ActiveRecord::Base
+      #   include AttrJson::Record
+      #
+      #   attr_json :price_cents, :integer
+      # end
+      # ~~~
+      #
+      # This compiler will generate the following RBI:
+      # ~~~rbi
+      # class Product
+      #   include AttrJsonGeneratedMethods
+      #   extend AttrJson::Record::ClassMethods
+      #
+      #   module AttrJsonGeneratedMethods
+      #     sig { returns(::Integer) }
+      #     def price_cents; end
+      #
+      #     sig { params(value: Integer).returns(::Integer) }
+      #     def price_cents=(value); end
+      #   end
+      # end
+      # ~~~
+      class AttrJson < Tapioca::Dsl::Compiler
+        extend T::Sig
+
+        # 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)) }}
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select { |constant| constant < ::AttrJson::Record || constant < ::AttrJson::Model }
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          rbi_class = root.create_path(constant)
+          instance_module = RBI::Module.new(InstanceMethodModuleName)
+
+          decorate_attributes(instance_module)
+
+          rbi_class << instance_module
+          rbi_class.create_include(InstanceMethodModuleName)
+          rbi_class.create_extend(ClassMethodsModuleName) if constant < ::AttrJson::Record
+        end
+
+        private
+
+        def decorate_attributes(rbi_scope)
+          T.unsafe(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|
+              _, type, options = definition.original_args
+              attribute_name = definition.name
+              type_name = sorbet_type(type, array: !!options[:array], nilable: !!options[:nil])
+
+              # Model: attr_json(:other_model_id, :string)
+              # => other_model_id
+              # => other_model_id=
+              rbi_scope.create_method(attribute_name, return_type: type_name)
+              rbi_scope.create_method(
+                "#{attribute_name}=",
+                parameters: [create_param("value", type: type_name)],
+                return_type: type_name,
+              )
+            end
+        end
+
+        def symbol_type(type_name)
+          return type_name if type_name.is_a?(Symbol)
+          return type_name.to_sym if type_name.is_a?(String)
+
+          type_name.type
+        end
+
+        def sorbet_type(type_name, array: false, nilable: false)
+          sorbet_type = if type_name.respond_to?(:model)
+            type_name.model
+          else
+            case symbol_type(type_name)
+            when :string, :immutable_string, :text, :uuid, :binary
+              "String"
+            when :boolean
+              "T::Boolean"
+            when :integer, :big_integer
+              "Integer"
+            when :float
+              "Float"
+            when :decimal
+              "BigDecimal"
+            when :time, :datetime
+              "Time"
+            when :date
+              "Date"
+            when :money
+              "Money"
+            when :json
+              "T.untyped"
+            else
+              "T.untyped"
+            end
+          end
+
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Paperclip)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Paperclip` decorates RBI files for classes that use the `has_attached_file` method
+      # provided by the `paperclip` gem.
+      # https://github.com/thoughtbot/paperclip
+      #
+      # For example, with the following ActiveRecord model:
+      # ~~~rb
+      # class Product < ActiveRecord::Base
+      #   has_attached_file(:marketing_image)
+      # end
+      # ~~~
+      #
+      # This compiler will generate the following RBI:
+      # ~~~rbi
+      # class Product
+      #  include PaperclipGeneratedMethods
+      #
+      #  module PaperclipGeneratedMethods
+      #    sig { returns(::Paperclip::Attachment) }
+      #    def marketing_image; end
+      #
+      #    sig { params(value: T.untyped).void }
+      #    def marketing_image=(value); end
+      #  end
+      # end
+      # ~~~
+      class Paperclip < Tapioca::Dsl::Compiler
+        extend T::Sig
+        include RBIHelper
+
+        InstanceModuleName = "PaperclipGeneratedMethods"
+        ConstantType = type_member { { fixed: T.class_of(::Paperclip::Glue) } }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select { |c| c < ::Paperclip::Glue }
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          attachments = ::Paperclip::AttachmentRegistry.names_for(constant)
+          return if attachments.empty?
+
+          root.create_path(constant) do |klass|
+            instance_module = RBI::Module.new(InstanceModuleName)
+
+            attachments.each do |attachment_name|
+              # Model: has_attached_file(:marketing_image)
+              # => marketing_image
+              # => marketing_image=
+              instance_module.create_method(attachment_name, return_type: "::Paperclip::Attachment")
+              instance_module.create_method(
+                "#{attachment_name}=",
+                parameters: [create_param("value", type: "T.untyped")],
+                return_type: nil,
+              )
+            end
+
+            klass << instance_module
+            klass.create_include(InstanceModuleName)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,11 @@ module Tapioca
         def decorate
           return if constant.state_machines.empty?
 
+          # This is a hack to make sure the instance methods are defined on the constant. Somehow the constant is being
+          # loaded but the actual `state_machine` call is not being executed, so the instance methods don't exist yet.
+          # Instantiating an empty class fixes it.
+          constant.try(:new)
+
           super()
 
           root.create_path(T.unsafe(constant)) do |klass|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.9
 platform: ruby
 authors:
 - Angellist
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-12 00:00:00.000000000 Z
+date: 2024-11-26 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.2
+        version: 0.16.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.16.2
+        version: 0.16.4
 description:
 email:
 - alex.stathis@angellist.com
@@ -48,20 +48,24 @@ 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
 - lib/tapioca/dsl/compilers/active_record_columns_persisted.rb
+- lib/tapioca/dsl/compilers/attr_json.rb
 - lib/tapioca/dsl/compilers/money_rails.rb
+- lib/tapioca/dsl/compilers/paperclip.rb
 - lib/tapioca/dsl/compilers/state_machines_extended.rb
 homepage: https://github.com/angellist/boba
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/angellist/boba/issues
-  changelog_uri: https://github.com/angellist/boba/blob/0.0.7/History.md
+  changelog_uri: https://github.com/angellist/boba/blob/0.0.9/History.md
   homepage_uri: https://github.com/angellist/boba
-  source_code_uri: https://github.com/angellist/boba/tree/0.0.7
+  source_code_uri: https://github.com/angellist/boba/tree/0.0.9
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -78,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Custom Tapioca compilers