boba 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc8f00fb09f7dc829a0f4c174ef8a3916068328de2868496e5430c83475c9e02
-  data.tar.gz: fa0393e8df72dfa4fe170dfe2c6ede7d07f308e257b3a5a347f875a6eba9915a
+  metadata.gz: 0a005078d3a776680cbc55c160a934a0460ba4cb7b5dd51de9c446eded2c9cdd
+  data.tar.gz: fbed64ed0a040d65e84ffa0836ab74500a3f421d0e20e13b4e00f091037cd917
 SHA512:
-  metadata.gz: 948d54418c7e911be046e53504ebf66ebb2c1190d8633643b01aadc5dbd12d137a9b7fc3d1da33ddab2298cdad40d9edcfe03ce4d9b0fe04dc59d83b17d67618
-  data.tar.gz: 83921a7f8c4285fb0fe36d65dcb565ca3cc01c421df4e123cec5abb97afa17f3393a08dcf10977f4653190511669c1f5211bbda4a324f030804d3ff19d684953
+  metadata.gz: 58cbdd3b0b5933e5052dc888dd4c596e3ee854890e6bf4c6dca431b16e71dd098828663c266d0239768c5c2493ac0430fde363cf1020e2f17ea902657d61b2b2
+  data.tar.gz: 9b8e2cc9d3c511bbc420152b2f53b73c16c3fbe0653e4adc4e1ca9f67664f90066957e7cf8cf8317b4bbb4553548171e6ebe264bc3e4910e7a9031e27c8ec6c8

data/lib/boba/active_record/attribute_service.rb

@@ -27,10 +27,8 @@ module Boba
           false
         end
 
-        #: (singleton(::ActiveRecord::Base) constant, String attribute) -> bool
+        #: (::ActiveModel::Validations::ClassMethods constant, String attribute) -> bool
         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
@@ -40,7 +38,7 @@ module Boba
 
         #: (ActiveModel::Validator validator) -> bool
         def unconditional_presence_validator?(validator)
-          return false unless validator.is_a?(::ActiveRecord::Validations::PresenceValidator)
+          return false unless validator.is_a?(::ActiveModel::Validations::PresenceValidator)
 
           unconditional_validator?(validator)
         end

data/lib/boba/version.rb

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

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

@@ -3,6 +3,8 @@
 
 return unless defined?(ActsAsTaggableOn)
 
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
 module Tapioca
   module Dsl
     module Compilers
@@ -68,13 +70,37 @@ module Tapioca
       #     sig { params(limit: Integer).returns(T.untyped) }
       #     def top_tags(limit = 10); end
       #   end
+      #
+      #   module GeneratedAssociationRelationMethods
+      #     sig { params(context: T.untyped, options: T.untyped).returns(::ActsAsTaggableOn::Tag::PrivateRelation) }
+      #     def tag_counts_on(context, options = {}); end
+      #
+      #     sig { params(tags: T.untyped, options: T.untyped).returns(PrivateAssociationRelation) }
+      #     def tagged_with(tags, options = {}); end
+      #   end
+      #
+      #   module GeneratedRelationMethods
+      #     sig { params(context: T.untyped, options: T.untyped).returns(::ActsAsTaggableOn::Tag::PrivateRelation) }
+      #     def tag_counts_on(context, options = {}); end
+      #
+      #     sig { params(tags: T.untyped, options: T.untyped).returns(PrivateRelation) }
+      #     def tagged_with(tags, options = {}); end
+      #   end
       # end
       # ~~~
       #
       # The mixins are declared rather than re-implemented, so `tagged_with`, `tag_list_on` and the rest keep
       # the signatures they have in the gem RBI. Only the per-context methods, which exist for the contexts of
       # this model alone, are generated.
+      #
+      # The relation side is the exception. `ActiveRecord::Relation` reaches the class methods by delegating to
+      # the model class, which Sorbet cannot follow, so `Post.published.tagged_with(...)` does not type-check at
+      # all. The two finders that answer a relation are re-stated on the relation modules: `tagged_with`
+      # narrows the receiver, and `tag_counts_on` answers a relation of `ActsAsTaggableOn::Tag` rather than
+      # of the model. Without the relations compiler both stay untyped.
       class ActsAsTaggableOn < Tapioca::Dsl::Compiler
+        include Helpers::ActiveRecordConstantsHelper
+
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
         # Every `acts_as_taggable_on` call installs this set; the names are fixed, so there is nothing to
@@ -96,6 +122,8 @@ module Tapioca
             tag_types.each do |tag_type|
               create_context_methods(model, tag_type)
             end
+
+            create_relation_methods(model)
           end
         end
 
@@ -111,6 +139,36 @@ module Tapioca
 
         private
 
+        #: (RBI::Scope model) -> void
+        def create_relation_methods(model)
+          relations_typed = compiler_enabled?("ActiveRecordRelations")
+          tag_relation = relations_typed ? "::ActsAsTaggableOn::Tag::PrivateRelation" : "T.untyped"
+
+          [
+            [RelationMethodsModuleName, RelationClassName],
+            [AssociationRelationMethodsModuleName, AssociationRelationClassName],
+          ].each do |module_name, relation_class|
+            relation_methods_module = model.create_module(module_name)
+
+            relation_methods_module.create_method(
+              "tagged_with",
+              parameters: [
+                create_param("tags", type: "T.untyped"),
+                create_opt_param("options", type: "T.untyped", default: "{}"),
+              ],
+              return_type: relations_typed ? relation_class : "T.untyped",
+            )
+            relation_methods_module.create_method(
+              "tag_counts_on",
+              parameters: [
+                create_param("context", type: "T.untyped"),
+                create_opt_param("options", type: "T.untyped", default: "{}"),
+              ],
+              return_type: tag_relation,
+            )
+          end
+        end
+
         #: (RBI::Scope model, String tag_type) -> void
         def create_context_methods(model, tag_type)
           singular = tag_type.singularize

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

@@ -3,6 +3,8 @@
 
 return unless defined?(AttrJson::Record)
 
+require "boba/active_record/attribute_service"
+
 module Tapioca
   module Dsl
     module Compilers
@@ -25,14 +27,20 @@ module Tapioca
       #   extend AttrJson::Record::ClassMethods
       #
       #   module AttrJsonGeneratedMethods
-      #     sig { returns(::Integer) }
+      #     sig { returns(T.nilable(::Integer)) }
       #     def price_cents; end
       #
-      #     sig { params(value: Integer).returns(::Integer) }
+      #     sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
       #     def price_cents=(value); end
       #   end
       # end
       # ~~~
+      #
+      # A scalar attribute reads as `nil` until it is set, so it is typed as nilable unless it has a non-nil
+      # `default:`. As with columns in `ActiveRecordColumnsPersisted`, an unconditional presence validator
+      # (no `if:`, `unless:` or `on:`) types it as it is on a valid record instead:
+      # `validates :price_cents, presence: true` turns the methods above into `returns(::Integer)` and
+      # `params(value: ::Integer)`.
       class AttrJson < Tapioca::Dsl::Compiler
         # Class methods module is already defined in the gem rbi, so just reference it here.
         ClassMethodsModuleName = "AttrJson::Record::ClassMethods"
@@ -63,13 +71,27 @@ module Tapioca
         private
 
         def decorate_attributes(rbi_scope)
+          # Both AttrJson::Record and AttrJson::Model bring in ActiveModel validations; the check lets Sorbet see it.
+          klass = constant
+          validated = klass if klass.is_a?(::ActiveModel::Validations::ClassMethods)
+
           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.to_s
-              type_name = sorbet_type(type, array: !!options[:array], nilable: !!options[:nil])
+              array = !!options[:array]
+              # AttrJson has no option that forbids nil: an attribute reads as nil unless it has a default,
+              # which AttrJson also fills in when a stored record lacks the key. An array one defaults to []
+              # on its own unless the default is overridden. As with columns, an unconditional presence
+              # validator types the attribute as it is on a valid record.
+              nilable = array ? options.key?(:default) && options[:default].nil? : options[:default].nil?
+              nilable &&= !(validated && Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+                validated,
+                attribute_name,
+              ))
+              type_name = sorbet_type(type, array: array, nilable: nilable)
 
               # Model: attr_json(:other_model_id, :string)
               # => other_model_id

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

@@ -39,12 +39,19 @@ module Tapioca
       # # typed: true
       # class Chat
       #   include RubyLLM::ActiveRecord::ChatMethods
+      #
+      #   Elem = type_member { { fixed: ::RubyLLM::Message } }
       # end
       # ~~~
       #
       # The module is declared rather than re-implemented, so `ask`, `with_instructions`,
       # `with_runtime_instructions` and the rest keep the signatures they have in the gem RBI. Models that
       # never call an `acts_as_*` method are left alone.
+      #
+      # Since ruby_llm 2.0 `ChatMethods` includes `Enumerable` and hands `each` over to the underlying
+      # `RubyLLM::Chat`, which yields `RubyLLM::Message`s. A class that includes a generic module has to
+      # re-declare its type members, so the chat model gets `Elem` fixed to that; on older versions,
+      # where the module is not enumerable, nothing is added.
       class RubyLLM < Tapioca::Dsl::Compiler
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
@@ -66,9 +73,20 @@ module Tapioca
 
           root.create_path(constant) do |model|
             mixins.each { |name| model.create_include(name) }
+
+            add_message_elem_type_member(model, mixins)
           end
         end
 
+        private
+
+        #: (RBI::Scope model, Array[String] mixins) -> void
+        def add_message_elem_type_member(model, mixins)
+          return unless constant < ::Enumerable && mixins.include?("RubyLLM::ActiveRecord::ChatMethods")
+
+          model.create_type_variable("Elem", type: "type_member", fixed: "::RubyLLM::Message")
+        end
+
         class << self
           # @override
           #: -> Enumerable[Module[top]]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexander Stathis
@@ -74,9 +74,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/stathis-alexander/boba/issues
-  changelog_uri: https://github.com/stathis-alexander/boba/blob/0.2.0/History.md
+  changelog_uri: https://github.com/stathis-alexander/boba/blob/0.3.0/History.md
   homepage_uri: https://github.com/stathis-alexander/boba
-  source_code_uri: https://github.com/stathis-alexander/boba/tree/0.2.0
+  source_code_uri: https://github.com/stathis-alexander/boba/tree/0.3.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: