boba 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c9a2d5e0d2f3dea9f67511011f5928b09d46bcaf6c5d9056df938df87e10f29
-  data.tar.gz: 6fdbf66a2cdd5359b468ab247014ae1a190c018e31de1f5e4557af06774a3006
+  metadata.gz: fc8f00fb09f7dc829a0f4c174ef8a3916068328de2868496e5430c83475c9e02
+  data.tar.gz: fa0393e8df72dfa4fe170dfe2c6ede7d07f308e257b3a5a347f875a6eba9915a
 SHA512:
-  metadata.gz: 345a07f95dbad2db1f4efc2901ced50f904fd07d260597f43082ba165401e66f1e82b056b1c36a4aeee8fdfede466b9ffc2c8d27100c4bdeb05fb35f6b60b2c7
-  data.tar.gz: 7bf6a4b2aebf8a48317152aa37ac179ca932a0c57cb3545edc34aebcbd346024a7cf85b8aa79d648ffbe0f1deb0b7734cbec31387e4d381e9c5b2769b5330ace
+  metadata.gz: 948d54418c7e911be046e53504ebf66ebb2c1190d8633643b01aadc5dbd12d137a9b7fc3d1da33ddab2298cdad40d9edcfe03ce4d9b0fe04dc59d83b17d67618
+  data.tar.gz: 83921a7f8c4285fb0fe36d65dcb565ca3cc01c421df4e123cec5abb97afa17f3393a08dcf10977f4653190511669c1f5211bbda4a324f030804d3ff19d684953

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 AngelList
+Copyright (c) 2024-2026 Alexander Stathis
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,5 +1,7 @@
 # Boba
 
+> This project has moved from `angellist/boba` to [`stathis-alexander/boba`](https://github.com/stathis-alexander/boba).
+
 > :warning: This software is currently under active development. It should not be considered stable until 1.0.0.
 
 Boba is a collection of compilers for Sorbet & Tapioca.
@@ -8,7 +10,7 @@ Tapioca is very opinionated about what types of compilers or changes are accepte
 
 ### Available Compilers
 
-See [the compilers manual](https://github.com/angellist/boba/blob/main/manual/compilers.md) for a list of available compilers.
+See [the compilers manual](https://github.com/stathis-alexander/boba/blob/main/manual/compilers.md) for a list of available compilers.
 
 ## Usage
 
@@ -82,7 +84,7 @@ We try to stay as up-to-date with Tapioca versions as possible, but can sometime
 
 ## Contributing
 
-Bugs and feature requests are welcome and should be [filed as issues on github](https://github.com/angellist/boba/issues).
+Bugs and feature requests are welcome and should be [filed as issues on github](https://github.com/stathis-alexander/boba/issues).
 
 ### New Compilers
 

data/lib/boba/version.rb

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

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

@@ -0,0 +1,115 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(ActionMCP::Tool)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActionMCPTool` decorates RBI files for tools of the `actionmcp` gem.
+      # https://github.com/seuros/action_mcp
+      #
+      # `property` and `collection` declare an Active Model attribute, so Tapioca's own
+      # `ActiveModelAttributes` compiler already generates a reader for each of them — but always nilable and,
+      # for collections, always `T::Array[T.untyped]`. A tool knows more than the attribute does: a property
+      # declared `required: true` is validated before `perform` runs, and a collection knows its item type.
+      #
+      # For example, with the following tool:
+      #
+      # ~~~rb
+      # class SearchTool < ApplicationMCPTool
+      #   property :query, type: "string", required: true
+      #   property :limit, type: "integer"
+      #   collection :tags, type: "string"
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `search_tool.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # search_tool.rbi
+      # # typed: true
+      # class SearchTool
+      #   sig { returns(::String) }
+      #   def query; end
+      #
+      #   sig { returns(T.nilable(T::Array[::String])) }
+      #   def tags; end
+      # end
+      # ~~~
+      #
+      # `limit` is left to the `ActiveModelAttributes` compiler: nothing is known about it beyond the
+      # attribute type. The readers generated here sit on the class itself, so they take precedence over the
+      # ones in `GeneratedAttributeMethods` without conflicting with them.
+      class ActionMCPTool < Tapioca::Dsl::Compiler
+        ConstantType = type_member { { fixed: T.class_of(::ActionMCP::Tool) } }
+
+        JSON_TYPES = {
+          "string" => "::String",
+          "integer" => "::Integer",
+          "number" => "::Float",
+          "boolean" => "T::Boolean",
+          "object" => "T::Hash[::String, T.untyped]",
+        }.freeze #: Hash[String, String]
+
+        # @override
+        #: -> void
+        def decorate
+          methods = readers_to_narrow
+          return if methods.empty?
+
+          root.create_path(constant) do |tool|
+            methods.each do |name, type|
+              tool.create_method(name, return_type: type)
+            end
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            descendants_of(::ActionMCP::Tool).reject { |tool| T.unsafe(tool).abstract? }
+          end
+        end
+
+        private
+
+        # Only properties the attribute type cannot describe on its own: required ones, whose reader is not
+        # nilable, and collections, whose item type is known.
+        #: -> Hash[String, String]
+        def readers_to_narrow
+          required = T.unsafe(constant)._required_properties.map(&:to_s)
+
+          T.unsafe(constant)._schema_properties.each_with_object({}) do |(name, definition), methods|
+            property_name = name.to_s
+            type = type_for(definition)
+            next unless type
+
+            property_required = required.include?(property_name)
+            next unless property_required || definition[:type].to_s == "array"
+
+            methods[property_name] = property_required ? type : "T.nilable(#{type})"
+          end
+        end
+
+        #: (Hash[Symbol, untyped] definition) -> String?
+        def type_for(definition)
+          json_type = definition[:type].to_s
+          return array_type_for(definition) if json_type == "array"
+
+          JSON_TYPES[json_type]
+        end
+
+        #: (Hash[Symbol, untyped] definition) -> String?
+        def array_type_for(definition)
+          item_type = definition.dig(:items, :type).to_s
+          item = JSON_TYPES[item_type]
+          return unless item
+
+          "T::Array[#{item}]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(ActsAsTaggableOn)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActsAsTaggableOn` decorates RBI files for models using the
+      # `acts-as-taggable-on` gem. https://github.com/mbleigh/acts-as-taggable-on
+      #
+      # `acts_as_taggable_on` itself needs no compiler: the gem extends `ActiveRecord::Base` from an
+      # `ActiveSupport.on_load(:active_record)` hook, and anything that loads `ActiveRecord::Base` during gem
+      # RBI generation fires it, so tapioca records the extend in the gem RBI. What only exists per model is
+      # what the declaration then installs on the declaring class: the five mixin pairs that carry the
+      # tagging API, and one set of accessors per tag context.
+      #
+      # For example, with the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ApplicationRecord
+      #   acts_as_taggable_on :tags
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   include ActsAsTaggableOn::Taggable::Core
+      #   extend ActsAsTaggableOn::Taggable::Core::ClassMethods
+      #   include ActsAsTaggableOn::Taggable::Collection
+      #   extend ActsAsTaggableOn::Taggable::Collection::ClassMethods
+      #
+      #   sig { returns(::ActsAsTaggableOn::TagList) }
+      #   def all_tags_list; end
+      #
+      #   sig { params(options: T.untyped).returns(T.untyped) }
+      #   def find_related_on_tags(options = {}); end
+      #
+      #   sig { params(options: T.untyped).returns(T.untyped) }
+      #   def find_related_tags(options = {}); end
+      #
+      #   sig { params(klass: T.untyped, options: T.untyped).returns(T.untyped) }
+      #   def find_related_tags_for(klass, options = {}); end
+      #
+      #   sig { params(options: T.untyped).returns(T.untyped) }
+      #   def tag_counts(options = {}); end
+      #
+      #   sig { returns(::ActsAsTaggableOn::TagList) }
+      #   def tag_list; end
+      #
+      #   sig { params(new_tags: T.untyped).returns(T.untyped) }
+      #   def tag_list=(new_tags); end
+      #
+      #   sig { params(owner: T.untyped).returns(::ActsAsTaggableOn::TagList) }
+      #   def tags_from(owner); end
+      #
+      #   sig { params(limit: Integer).returns(T.untyped) }
+      #   def top_tags(limit = 10); end
+      #
+      #   class << self
+      #     sig { params(options: T.untyped).returns(T.untyped) }
+      #     def tag_counts(options = {}); end
+      #
+      #     sig { params(limit: Integer).returns(T.untyped) }
+      #     def top_tags(limit = 10); 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.
+      class ActsAsTaggableOn < Tapioca::Dsl::Compiler
+        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
+        # discover by walking ancestors.
+        MIXINS = ["Core", "Collection", "Caching", "Ownership", "Related"] #: Array[String]
+
+        # @override
+        #: -> void
+        def decorate
+          tag_types = T.unsafe(constant).tag_types.map(&:to_s)
+          return if tag_types.empty?
+
+          root.create_path(constant) do |model|
+            MIXINS.each do |mixin|
+              model.create_include("ActsAsTaggableOn::Taggable::#{mixin}")
+              model.create_extend("ActsAsTaggableOn::Taggable::#{mixin}::ClassMethods")
+            end
+
+            tag_types.each do |tag_type|
+              create_context_methods(model, tag_type)
+            end
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            descendants_of(::ActiveRecord::Base)
+              .reject(&:abstract_class?)
+              .select { |model| model.respond_to?(:taggable?) && T.unsafe(model).taggable? }
+          end
+        end
+
+        private
+
+        #: (RBI::Scope model, String tag_type) -> void
+        def create_context_methods(model, tag_type)
+          singular = tag_type.singularize
+
+          model.create_method("#{singular}_list", return_type: "::ActsAsTaggableOn::TagList")
+          model.create_method(
+            "#{singular}_list=",
+            parameters: [create_param("new_tags", type: "T.untyped")],
+            return_type: "T.untyped",
+          )
+          model.create_method("all_#{tag_type}_list", return_type: "::ActsAsTaggableOn::TagList")
+          model.create_method(
+            "#{tag_type}_from",
+            parameters: [create_param("owner", type: "T.untyped")],
+            return_type: "::ActsAsTaggableOn::TagList",
+          )
+
+          # `Related` builds these off the same context list; `find_related_on_` is an alias of the first.
+          # They answer a relation of whichever class was asked for, so the return stays untyped.
+          ["find_related_#{tag_type}", "find_related_on_#{tag_type}"].each do |name|
+            model.create_method(
+              name,
+              parameters: [create_opt_param("options", type: "T.untyped", default: "{}")],
+              return_type: "T.untyped",
+            )
+          end
+          model.create_method(
+            "find_related_#{tag_type}_for",
+            parameters: [
+              create_param("klass", type: "T.untyped"),
+              create_opt_param("options", type: "T.untyped", default: "{}"),
+            ],
+            return_type: "T.untyped",
+          )
+
+          [false, true].each do |class_method|
+            model.create_method(
+              "#{singular}_counts",
+              parameters: [create_opt_param("options", type: "T.untyped", default: "{}")],
+              return_type: "T.untyped",
+              class_method: class_method,
+            )
+            model.create_method(
+              "top_#{tag_type}",
+              parameters: [create_opt_param("limit", type: "Integer", default: "10")],
+              return_type: "T.untyped",
+              class_method: class_method,
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(FriendlyId)
+
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::FriendlyId` decorates RBI files for models using the `friendly_id` gem.
+      # https://github.com/norman/friendly_id
+      #
+      # A model opts in with `extend FriendlyId`, but the modules that carry the DSL are mixed in from
+      # `self.extended` and `Configuration#use` hooks at runtime, so Sorbet sees none of them: not the
+      # `friendly_id` declaration itself, not `friendly`, and not the instance methods the `use:` modules add.
+      #
+      # For example, with the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ApplicationRecord
+      #   extend FriendlyId
+      #
+      #   friendly_id :title, use: :slugged
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   include FriendlyId::Slugged
+      #   include FriendlyId::Model
+      #   include FriendlyId::Reserved
+      #   include FriendlyId::UnfriendlyUtils
+      #   extend FriendlyId::Base
+      #
+      #   module GeneratedAssociationRelationMethods
+      #     sig { returns(PrivateAssociationRelation) }
+      #     def friendly; end
+      #   end
+      #
+      #   module GeneratedRelationMethods
+      #     sig { returns(PrivateRelation) }
+      #     def friendly; end
+      #   end
+      # end
+      # ~~~
+      #
+      # The mixins are taken from the model as it is actually configured, so a model using `use: :history`
+      # or `use: :scoped` gets the modules that go with it. Their signatures already live in the gem RBI,
+      # which leaves nothing to hand-write here. `friendly` is declared on the relation modules as well
+      # because `ActiveRecord::Relation` reaches it by delegating to the model class.
+      class FriendlyId < Tapioca::Dsl::Compiler
+        include Helpers::ActiveRecordConstantsHelper
+
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        # @override
+        #: -> void
+        def decorate
+          root.create_path(constant) do |model|
+            model_mixins.each { |name| model.create_include(name) }
+            model_class_mixins.each { |name| model.create_extend(name) }
+
+            target_modules.each do |module_name, return_type|
+              model.create_module(module_name).create_method("friendly", return_type: return_type)
+            end
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            descendants_of(::ActiveRecord::Base)
+              .reject(&:abstract_class?)
+              .select { |model| model.singleton_class.include?(::FriendlyId::Base) }
+          end
+        end
+
+        private
+
+        #: -> Array[String]
+        def model_mixins
+          friendly_id_modules(constant.ancestors - ::Object.ancestors)
+        end
+
+        #: -> Array[String]
+        def model_class_mixins
+          friendly_id_modules(constant.singleton_class.ancestors - ::Object.singleton_class.ancestors)
+        end
+
+        # `FriendlyId::ObjectUtils` and friends are mixed into `Object` when the gem is required, so they
+        # are already part of the gem RBI. Only the modules the model itself picked up are of interest here.
+        #: (Array[Module[top]] ancestors) -> Array[String]
+        def friendly_id_modules(ancestors)
+          ancestors.filter_map do |ancestor|
+            name = ancestor.name
+            next unless name
+            next unless name.start_with?("FriendlyId::")
+
+            name
+          end
+        end
+
+        #: -> 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

@@ -33,10 +33,13 @@ module Tapioca
       #  include MoneyRailsGeneratedMethods
       #
       #  module MoneyRailsGeneratedMethods
+      #    sig { returns(::Money::Currency) }
+      #    def currency_for_price; end
+      #
       #    sig { returns(::Money) }
       #    def price; end
       #
-      #    sig { params(value: ::Money).returns(::Money) }
+      #    sig { params(value: T.any(::Money, ::Numeric, ::String)).returns(::Money) }
       #    def price=(value); end
       #  end
       # end
@@ -44,6 +47,11 @@ module Tapioca
       class MoneyRails < Tapioca::Dsl::Compiler
         include RBIHelper
 
+        # `write_monetized` calls `value.to_money(...)` for anything that is not already a `Money`,
+        # so the writer accepts any object money-rails knows how to monetize, not only `Money`.
+        # https://github.com/RubyMoney/money-rails/blob/main/lib/money-rails/active_record/monetizable.rb
+        SetterValueType = "T.any(::Money, ::Numeric, ::String)"
+
         ConstantType = type_member do
           {
             fixed: T.all(
@@ -90,8 +98,10 @@ module Tapioca
             constant.monetized_attributes.each do |attribute_name, column_name|
               if column_type_option.untyped?
                 type_name = "T.untyped"
+                setter_type_name = "T.untyped"
               else
                 type_name = "::Money"
+                setter_type_name = SetterValueType
 
                 nilable_attribute = if constant < ::ActiveRecord::Base && column_type_option.persisted?
                   Boba::ActiveRecord::AttributeService.nilable_attribute?(
@@ -103,7 +113,10 @@ module Tapioca
                   true
                 end
 
-                type_name = as_nilable_type(type_name) if nilable_attribute
+                if nilable_attribute
+                  type_name = as_nilable_type(type_name)
+                  setter_type_name = as_nilable_type(setter_type_name)
+                end
               end
 
               # Model: monetize :amount_cents
@@ -112,9 +125,13 @@ module Tapioca
               instance_module.create_method(attribute_name, return_type: type_name)
               instance_module.create_method(
                 "#{attribute_name}=",
-                parameters: [create_param("value", type: type_name)],
+                parameters: [create_param("value", type: setter_type_name)],
                 return_type: type_name,
               )
+              instance_module.create_method(
+                "currency_for_#{attribute_name}",
+                return_type: "::Money::Currency",
+              )
             end
 
             klass << instance_module

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

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(PaperTrail)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::PaperTrail` decorates RBI files for models versioned with the `paper_trail`
+      # gem. https://github.com/paper-trail-gem/paper_trail
+      #
+      # `PaperTrail::Model` is included into `ActiveRecord::Base` once, by the gem itself, so a
+      # `sorbet/tapioca/require.rb` carrying `require "paper_trail/frameworks/active_record"` is enough for
+      # `has_paper_trail` to land in the gem RBI — no compiler needed for that part. What no shim can express
+      # is what `has_paper_trail` then does to the model that declares it, at runtime: it includes
+      # `PaperTrail::Model::InstanceMethods` into that class and defines two accessors on it, one of them
+      # under a name the model chooses.
+      #
+      # For example, with the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Post < ApplicationRecord
+      #   has_paper_trail
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `post.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   include PaperTrail::Model::InstanceMethods
+      #
+      #   sig { returns(T.nilable(::PaperTrail::Version)) }
+      #   def version; end
+      #
+      #   sig { params(value: T.nilable(::PaperTrail::Version)).returns(T.nilable(::PaperTrail::Version)) }
+      #   def version=(value); end
+      #
+      #   sig { returns(T.nilable(::String)) }
+      #   def paper_trail_event; end
+      #
+      #   sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+      #   def paper_trail_event=(value); end
+      # end
+      # ~~~
+      #
+      # `version` holds the version record the model was reified from; it is named by the `:version` option
+      # and typed by `versions: { class_name: ... }`, so both are only knowable per model. The `versions`
+      # association is declared with `has_many`, which Tapioca's own association compiler already sees.
+      class PaperTrail < Tapioca::Dsl::Compiler
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        # @override
+        #: -> void
+        def decorate
+          version_class_name = T.unsafe(constant).version_class_name.to_s.delete_prefix("::")
+          reified_type = "T.nilable(::#{version_class_name})"
+          version_name = T.unsafe(constant).version_association_name.to_s
+
+          root.create_path(constant) do |model|
+            model.create_include("PaperTrail::Model::InstanceMethods")
+            create_accessor(model, version_name, reified_type)
+            create_accessor(model, "paper_trail_event", "T.nilable(::String)")
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            descendants_of(::ActiveRecord::Base)
+              .reject(&:abstract_class?)
+              .select { |model| model.include?(::PaperTrail::Model::InstanceMethods) }
+          end
+        end
+
+        private
+
+        #: (RBI::Scope model, String name, String type) -> void
+        def create_accessor(model, name, type)
+          model.create_method(name, return_type: type)
+          model.create_method(
+            "#{name}=",
+            parameters: [create_param("value", type: type)],
+            return_type: type,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Ransack)
+
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Ransack` decorates RBI files for models searchable with the `ransack` gem.
+      # https://github.com/activerecord-hackery/ransack
+      #
+      # The class methods (`ransack`, `ransacker`, `ransackable_attributes`, ...) need no compiler: ransack
+      # extends `ActiveRecord::Base` from an `ActiveSupport.on_load(:active_record)` hook, and anything that
+      # loads `ActiveRecord::Base` during gem RBI generation fires it, so tapioca records the extend in the
+      # gem RBI. What stays invisible is the relation side: `ActiveRecord::Relation` reaches those methods by
+      # delegating to the model class, which Sorbet cannot follow.
+      #
+      # For example, 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
+      #   module GeneratedAssociationRelationMethods
+      #     sig { params(params: T.untyped, options: T.untyped).returns(::Ransack::Search) }
+      #     def ransack(params = nil, options = nil); end
+      #
+      #     sig { params(params: T.untyped, options: T.untyped).returns(::Ransack::Search) }
+      #     def ransack!(params = nil, options = nil); end
+      #   end
+      #
+      #   module GeneratedRelationMethods
+      #     sig { params(params: T.untyped, options: T.untyped).returns(::Ransack::Search) }
+      #     def ransack(params = nil, options = nil); end
+      #
+      #     sig { params(params: T.untyped, options: T.untyped).returns(::Ransack::Search) }
+      #     def ransack!(params = nil, options = nil); end
+      #   end
+      # end
+      # ~~~
+      #
+      # The signatures are the ones the gem RBI already carries for
+      # `Ransack::Adapters::ActiveRecord::Base`; only the delegation is re-stated.
+      class Ransack < Tapioca::Dsl::Compiler
+        include Helpers::ActiveRecordConstantsHelper
+
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        # @override
+        #: -> void
+        def decorate
+          root.create_path(constant) do |model|
+            [RelationMethodsModuleName, AssociationRelationMethodsModuleName].each do |module_name|
+              relation_methods_module = model.create_module(module_name)
+
+              ["ransack", "ransack!"].each do |method_name|
+                relation_methods_module.create_method(
+                  method_name,
+                  parameters: [
+                    create_opt_param("params", type: "T.untyped", default: "nil"),
+                    create_opt_param("options", type: "T.untyped", default: "nil"),
+                  ],
+                  return_type: "::Ransack::Search",
+                )
+              end
+            end
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(RubyLLM::ActiveRecord)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::RubyLLM` decorates RBI files for models using the `acts_as_*` DSL of the
+      # `ruby_llm` gem. https://github.com/crmne/ruby_llm
+      #
+      # The `acts_as_*` class methods themselves are out of reach of a compiler and of gem RBI generation
+      # alike: the gem includes `RubyLLM::ActiveRecord::ActsAs` into `ActiveRecord::Base` from an
+      # `on_load(:active_record)` hook inside a **railtie initializer**, so nothing short of booting the
+      # application runs it. Declare that one include in a shim, and the DSL types itself from the gem RBI:
+      #
+      # ~~~rbi
+      # # sorbet/rbi/shims/ruby_llm.rbi
+      # class ActiveRecord::Base
+      #   include RubyLLM::ActiveRecord::ActsAs
+      # end
+      # ~~~
+      #
+      # What is left for a compiler is per model: the methods module each `acts_as_*` call mixes into the
+      # class that declares it.
+      #
+      # For example, with the following `ActiveRecord::Base` subclass:
+      #
+      # ~~~rb
+      # class Chat < ApplicationRecord
+      #   acts_as_chat
+      # end
+      # ~~~
+      #
+      # This compiler will produce the RBI file `chat.rbi` with the following content:
+      #
+      # ~~~rbi
+      # # chat.rbi
+      # # typed: true
+      # class Chat
+      #   include RubyLLM::ActiveRecord::ChatMethods
+      # 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.
+      class RubyLLM < Tapioca::Dsl::Compiler
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        # One module per `acts_as_*`, under both the current and the legacy API; the names are fixed, so
+        # there is nothing to discover by walking ancestors with a name prefix.
+        MIXINS = [
+          "RubyLLM::ActiveRecord::ChatMethods",
+          "RubyLLM::ActiveRecord::MessageMethods",
+          "RubyLLM::ActiveRecord::ModelMethods",
+          "RubyLLM::ActiveRecord::ToolCallMethods",
+          "RubyLLM::ActiveRecord::ChatLegacyMethods",
+          "RubyLLM::ActiveRecord::MessageLegacyMethods",
+        ] #: Array[String]
+
+        # @override
+        #: -> void
+        def decorate
+          mixins = self.class.mixins_of(constant)
+
+          root.create_path(constant) do |model|
+            mixins.each { |name| model.create_include(name) }
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            descendants_of(::ActiveRecord::Base)
+              .reject(&:abstract_class?)
+              .select { |model| mixins_of(model).any? }
+          end
+
+          # The DSL itself is included into `ActiveRecord::Base`, so every model carries it. What tells a
+          # model apart is the methods module an `acts_as_*` call mixed into the model itself.
+          #: (singleton(::ActiveRecord::Base) model) -> Array[String]
+          def mixins_of(model)
+            own_ancestors = model.ancestors - ::ActiveRecord::Base.ancestors
+            names = own_ancestors.filter_map(&:name)
+
+            MIXINS & names
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.0
 platform: ruby
 authors:
-- Angellist
+- Alexander Stathis
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -29,16 +29,16 @@ dependencies:
     requirements:
     - - "<="
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: 0.20.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "<="
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: 0.20.0
 email:
-- alex.stathis@angellist.com
+- stathis.alexanderj@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -51,26 +51,32 @@ files:
 - lib/boba/options/association_type_option.rb
 - lib/boba/relations_railtie.rb
 - lib/boba/version.rb
+- lib/tapioca/dsl/compilers/action_mcp_tool.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/acts_as_taggable_on.rb
 - lib/tapioca/dsl/compilers/attr_json.rb
 - lib/tapioca/dsl/compilers/draper.rb
 - lib/tapioca/dsl/compilers/flag_shih_tzu.rb
+- lib/tapioca/dsl/compilers/friendly_id.rb
 - lib/tapioca/dsl/compilers/kaminari.rb
 - lib/tapioca/dsl/compilers/money_rails.rb
 - lib/tapioca/dsl/compilers/noticed.rb
+- lib/tapioca/dsl/compilers/paper_trail.rb
 - lib/tapioca/dsl/compilers/paperclip.rb
+- lib/tapioca/dsl/compilers/ransack.rb
+- lib/tapioca/dsl/compilers/ruby_llm.rb
 - lib/tapioca/dsl/compilers/shrine.rb
 - lib/tapioca/dsl/compilers/state_machines_extended.rb
-homepage: https://github.com/angellist/boba
+homepage: https://github.com/stathis-alexander/boba
 licenses:
 - MIT
 metadata:
-  bug_tracker_uri: https://github.com/angellist/boba/issues
-  changelog_uri: https://github.com/angellist/boba/blob/0.1.12/History.md
-  homepage_uri: https://github.com/angellist/boba
-  source_code_uri: https://github.com/angellist/boba/tree/0.1.12
+  bug_tracker_uri: https://github.com/stathis-alexander/boba/issues
+  changelog_uri: https://github.com/stathis-alexander/boba/blob/0.2.0/History.md
+  homepage_uri: https://github.com/stathis-alexander/boba
+  source_code_uri: https://github.com/stathis-alexander/boba/tree/0.2.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: