quo 1.0.0.beta2 → 2.0.0

data/lib/quo/results.rb

@@ -3,6 +3,7 @@
 # rbs_inline: enabled
 
 module Quo
+  # Base results wrapper providing enumeration with optional transformation
   class Results
     def empty? #: bool
       !exists?
@@ -23,6 +24,23 @@ module Quo
       page_count
     end
 
+    FILTER_METHODS = %i[
+      select filter find_all reject
+      find detect
+      take_while drop_while
+      sort_by min_by max_by
+      uniq
+    ].to_set.freeze
+
+    PAIR_FILTER_METHODS = %i[partition minmax_by].to_set.freeze
+
+    PASSTHROUGH_METHODS = %i[
+      any? all? none? one? include? member?
+      count tally sum
+      each_with_object inject reduce
+      map collect flat_map collect_concat filter_map
+    ].to_set.freeze
+
     # @rbs &block: (untyped, *untyped) -> untyped
     # @rbs return: Hash[untyped, Array[untyped]]
     def group_by(&block)
@@ -45,16 +63,20 @@ module Quo
       return super unless respond_to_missing?(method)
 
       if block
-        @configured_query.send(method, *args, **kwargs) do |*block_args|
+        raw = @configured_query.send(method, *args, **kwargs) do |*block_args|
           x = block_args.first
           transformed = transform? ? @transformer.call(x) : x
           other_args = block_args[1..] || []
           block.call(transformed, *other_args)
         end
+        return raw if PASSTHROUGH_METHODS.include?(method)
+        return transform_pair(raw) if PAIR_FILTER_METHODS.include?(method)
+        return transform_results(raw) if FILTER_METHODS.include?(method)
+        raw
       else
         raw = @configured_query.send(method, *args, **kwargs)
-        # FIXME: consider how to handle applying a transformer to a Enumerator...
         return raw if raw.is_a?(Quo::RelationResults) || raw.is_a?(::Enumerator)
+        return raw if PASSTHROUGH_METHODS.include?(method)
         transform_results(raw)
       end
     end
@@ -85,5 +107,12 @@ module Quo
         @transformer.call(results)
       end
     end
+
+    # @rbs pair: untyped
+    # @rbs return: untyped
+    def transform_pair(pair)
+      return pair unless transform?
+      pair.map { |part| transform_results(part) }
+    end
   end
 end

data/lib/quo/rspec/helpers.rb

@@ -1,40 +1,29 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require_relative "../testing/collection_backed_fake"
 require_relative "../testing/relation_backed_fake"
+require_relative "../testing/fake_helpers"
 
 module Quo
   module Rspec
+    # Test helpers for stubbing query objects in RSpec
     module Helpers
-      def fake_query(query_class, with: nil, results: [], total_count: nil, page_count: nil, &block)
-        # make it so that results of instances of this class return a fake Result object
-        # of the right type which returns the results passed in
-        if query_class < Quo::CollectionBackedQuery
-          klass = Class.new(Quo::Testing::CollectionBackedFake) do
-            if query_class < Quo::Preloadable
-              include Quo::Preloadable
+      include Quo::Testing::FakeHelpers
 
-              def query
-                collection
-              end
-            end
-          end
-          fake = ->(*kwargs) {
-            klass.new(results: results, total_count: total_count, page_count: page_count)
-          }
-          expectation = allow(query_class).to receive(:new)
-          expectation = expectation.with(with) if with
-          expectation.and_invoke(fake)
-        elsif query_class < Quo::RelationBackedQuery
-          fake = ->(*kwargs) {
-            Quo::Testing::RelationBackedFake.new(results: results, total_count: total_count, page_count: page_count)
-          }
-          expectation = allow(query_class).to receive(:new)
-          expectation = expectation.with(with) if with
-          expectation.and_invoke(fake)
-        else
+      def fake_query(query_class, with: nil, results: [], total_count: nil, page_count: nil, &block)
+        unless query_class < Quo::Query
           raise ArgumentError, "Not a Query class: #{query_class}"
         end
+
+        klass = build_fake_class(query_class)
+        fake = ->(*kwargs) {
+          klass.new(results: results, total_count: total_count, page_count: page_count)
+        }
+        expectation = allow(query_class).to receive(:new)
+        expectation = expectation.with(with) if with
+        expectation.and_invoke(fake)
       end
     end
   end

data/lib/quo/testing/collection_backed_fake.rb

@@ -4,6 +4,7 @@
 
 module Quo
   module Testing
+    # Test helper for creating fake collection-backed queries with predefined results
     class CollectionBackedFake < Quo.collection_backed_query_base_class
       prop :results, _Any, reader: false
       prop :page_count, _Nilable(Integer), reader: false

data/lib/quo/testing/fake_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module Quo
+  module Testing
+    # Shared helpers for creating fake query objects in tests
+    module FakeHelpers
+      private
+
+      # @rbs query_class: Class
+      # @rbs return: Class
+      def build_fake_class(query_class)
+        if query_class < Quo::CollectionBackedQuery
+          Class.new(Quo::Testing::CollectionBackedFake) do
+            if query_class < Quo::Preloadable
+              include Quo::Preloadable
+
+              def query
+                collection
+              end
+            end
+          end
+        else
+          Quo::Testing::RelationBackedFake
+        end
+      end
+    end
+  end
+end

data/lib/quo/testing/relation_backed_fake.rb

@@ -4,6 +4,7 @@
 
 module Quo
   module Testing
+    # Test helper for creating fake relation-backed queries with predefined results
     class RelationBackedFake < Quo.relation_backed_query_base_class
       prop :results, _Any, reader: false
       prop :page_count, _Nilable(Integer), reader: false

data/lib/quo/version.rb

@@ -3,5 +3,5 @@
 # rbs_inline: enabled
 
 module Quo
-  VERSION = "1.0.0.beta2"
+  VERSION = "2.0.0"
 end

data/lib/quo/wrapped_collection_backed_query.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module Quo
+  class WrappedCollectionBackedQuery < Quo.collection_backed_query_base_class
+    # @rbs!
+    #   @wrapped: Enumerable[untyped]
+    prop :wrapped, Enumerable, writer: false
+
+    # @rbs override
+    def collection
+      wrapped
+    end
+
+    # @rbs override
+    def inspect
+      "#{self.class.name}[#{wrapped.class.name}]"
+    end
+  end
+end

data/lib/quo/wrapped_relation_backed_query.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module Quo
+  class WrappedRelationBackedQuery < Quo.relation_backed_query_base_class
+    # @rbs!
+    #   @wrapped: ActiveRecord::Relation
+    prop :wrapped, ::ActiveRecord::Relation, writer: false
+
+    # @rbs override
+    def query
+      wrapped
+    end
+
+    # @rbs override
+    def inspect
+      "#{self.class.name}[#{wrapped.klass.name}]"
+    end
+  end
+end

data/lib/quo.rb

@@ -4,7 +4,9 @@
 
 require_relative "quo/version"
 require "quo/engine"
+require "literal"
 
+# Query object library for ActiveRecord with composable queries and pagination
 module Quo
   extend ActiveSupport::Autoload
 
@@ -16,7 +18,13 @@ module Quo
   autoload :RelationResults
   autoload :CollectionResults
   autoload :ComposedQuery
+  autoload :ComposedInstance
+  autoload :ComposedRelationBackedQuery
+  autoload :ComposedCollectionBackedQuery
+  autoload :WrappedRelationBackedQuery
+  autoload :WrappedCollectionBackedQuery
   autoload :CollectionBackedQuery
+  autoload :Composing
 
   mattr_accessor :relation_backed_query_base_class, default: "Quo::RelationBackedQuery"
   mattr_accessor :collection_backed_query_base_class, default: "Quo::CollectionBackedQuery"

data/sig/generated/quo/collection_backed_query.rbs

@@ -1,11 +1,17 @@
 # Generated from lib/quo/collection_backed_query.rb with RBS::Inline
 
 module Quo
+  # Query object backed by in-memory collections
   class CollectionBackedQuery < Query
-    # Wrap an enumerable collection or a block that returns an enumerable collection
-    # @rbs data: untyped, props: Symbol => untyped, block: () -> untyped
+    # @rbs data: Enumerable[untyped] | Quo::CollectionBackedQuery
+    # @rbs props: Hash[Symbol, untyped]
+    # @rbs &block: ? () -> Enumerable[untyped]
     # @rbs return: Quo::CollectionBackedQuery
-    def self.wrap: (?untyped data, ?props: untyped) ?{ (?) -> untyped } -> Quo::CollectionBackedQuery
+    def self.wrap: (?Enumerable[untyped] | Quo::CollectionBackedQuery data, ?props: Hash[Symbol, untyped]) ?{ () -> Enumerable[untyped] } -> Quo::CollectionBackedQuery
+
+    # @rbs enumerable: Enumerable[untyped]
+    # @rbs return: Quo::WrappedCollectionBackedQuery
+    def self.from: (Enumerable[untyped] enumerable) -> Quo::WrappedCollectionBackedQuery
 
     # @rbs return: Object & Enumerable[untyped]
     def collection: () -> (Object & Enumerable[untyped])
@@ -15,7 +21,7 @@ module Quo
     # @rbs return: Object & Enumerable[untyped]
     def query: () -> (Object & Enumerable[untyped])
 
-    def results: () -> untyped
+    def results: () -> Quo::Results
 
     # @rbs override
     def relation?: ...

data/sig/generated/quo/collection_results.rbs

@@ -1,6 +1,7 @@
 # Generated from lib/quo/collection_results.rb with RBS::Inline
 
 module Quo
+  # Results wrapper for collection-backed queries providing pagination and counting
   class CollectionResults < Results
     # @rbs override
     def initialize: ...

data/sig/generated/quo/composed_collection_backed_query.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/quo/composed_collection_backed_query.rb with RBS::Inline
+
+module Quo
+  class ComposedCollectionBackedQuery
+    include ComposedInstance
+
+    @left: Quo::Query | Enumerable[untyped]
+
+    @right: Quo::Query | Enumerable[untyped]
+
+    @merge_joins: Symbol | Hash[untyped, untyped] | Array[untyped] | nil
+
+    # @rbs override
+    def collection: ...
+
+    # @rbs override
+    def inspect: ...
+
+    private
+
+    # @rbs operand: untyped
+    # @rbs return: String
+    def operand_desc: (untyped operand) -> String
+  end
+end

data/sig/generated/quo/composed_instance.rbs

@@ -0,0 +1,61 @@
+# Generated from lib/quo/composed_instance.rb with RBS::Inline
+
+module Quo
+  module ComposedInstance
+    # @rbs **overrides: untyped
+    # @rbs return: Quo::Query
+    def copy: (**untyped overrides) -> Quo::Query
+
+    private
+
+    # @rbs prop_name: Symbol
+    # @rbs value: untyped
+    # @rbs return: Quo::Query
+    def fan_override: (Symbol prop_name, untyped value) -> Quo::Query
+
+    # @rbs return: Array[Symbol]
+    def own_property_names: () -> Array[Symbol]
+
+    # @rbs operand: untyped
+    # @rbs prop_name: Symbol
+    # @rbs return: bool
+    def operand_accepts?: (untyped operand, Symbol prop_name) -> bool
+
+    # @rbs operand: untyped
+    # @rbs prop_name: Symbol
+    # @rbs value: untyped
+    # @rbs return: untyped
+    def apply_to_operand: (untyped operand, Symbol prop_name, untyped value) -> untyped
+
+    # @rbs return: ActiveRecord::Relation | Enumerable[untyped]
+    def merge_left_and_right: () -> (ActiveRecord::Relation | Enumerable[untyped])
+
+    # @rbs operand: untyped
+    # @rbs return: ActiveRecord::Relation | Enumerable[untyped]
+    def unwrap_operand: (untyped operand) -> (ActiveRecord::Relation | Enumerable[untyped])
+
+    # @rbs left_rel: ActiveRecord::Relation
+    # @rbs right_rel: ActiveRecord::Relation
+    # @rbs return: ActiveRecord::Relation
+    def merge_active_record_relations: (ActiveRecord::Relation left_rel, ActiveRecord::Relation right_rel) -> ActiveRecord::Relation
+
+    # @rbs rel: untyped
+    # @rbs return: bool
+    def is_relation?: (untyped rel) -> bool
+
+    # @rbs lr: untyped
+    # @rbs rr: untyped
+    # @rbs return: bool
+    def both_relations?: (untyped lr, untyped rr) -> bool
+
+    # @rbs lr: untyped
+    # @rbs rr: untyped
+    # @rbs return: bool
+    def left_relation_right_enumerable?: (untyped lr, untyped rr) -> bool
+
+    # @rbs lr: untyped
+    # @rbs rr: untyped
+    # @rbs return: bool
+    def left_enumerable_right_relation?: (untyped lr, untyped rr) -> bool
+  end
+end

data/sig/generated/quo/composed_query.rbs

@@ -1,68 +1,39 @@
 # Generated from lib/quo/composed_query.rb with RBS::Inline
 
 module Quo
+  # Mixin for queries composed of two child queries
   module ComposedQuery
-    # Combine two Query classes into a new composed query class
-    # Combine two query-like or composeable entities:
-    # These can be Quo::Query, Quo::ComposedQuery, Quo::CollectionBackedQuery and ActiveRecord::Relations.
-    # See the `README.md` docs for more details.
-    # @rbs chosen_superclass: singleton(Quo::RelationBackedQuery | Quo::CollectionBackedQuery)
-    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    # @rbs joins: untyped
-    # @rbs return: singleton(Quo::ComposedQuery)
-    def self?.composer: (untyped chosen_superclass, untyped left_query_class, untyped right_query_class, ?joins: untyped) -> singleton(Quo::ComposedQuery)
-
-    # We can also merge instance of prepared queries
-    # @rbs left_instance: Quo::Query | ::ActiveRecord::Relation
-    # @rbs right_instance: Quo::Query | ::ActiveRecord::Relation
-    # @rbs joins: untyped
-    # @rbs return: Quo::ComposedQuery
-    def self?.merge_instances: (Quo::Query | ::ActiveRecord::Relation left_instance, Quo::Query | ::ActiveRecord::Relation right_instance, ?joins: untyped) -> Quo::ComposedQuery
+    # Class-level methods shared by every composed query class. Defined once
+    # here and extended onto each anon class via the `included` hook below
+    # rather than being re-defined on every Class.new in the composer.
+    module ClassMethods
+      attr_reader _composing_joins: untyped
 
-    # @rbs override
-    def query: ...
+      attr_reader _left_specification: untyped
 
-    # @rbs override
-    def inspect: ...
+      attr_reader _right_specification: untyped
 
-    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    private def self.validate_query_classes: (untyped left_query_class, untyped right_query_class) -> untyped
+      attr_reader _left_query: untyped
 
-    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    private def self.collect_properties: (untyped left_query_class, untyped right_query_class) -> untyped
+      attr_reader _right_query: untyped
 
-    private def self.create_composed_class: (untyped chosen_superclass, untyped props) -> untyped
+      # @rbs return: String
+      def inspect: () -> String
 
-    # @rbs klass: Class
-    # @rbs left_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    # @rbs right_query_class: singleton(Quo::Query | ::ActiveRecord::Relation)
-    # @rbs joins: untyped
-    private def self.assign_query_metadata: (Class klass, untyped left_query_class, untyped right_query_class, untyped joins) -> untyped
+      # @rbs operand: Class
+      # @rbs return: String
+      def quo_operand_desc: (Class operand) -> String
+    end
 
-    # @rbs left_instance: Quo::Query | ::ActiveRecord::Relation
-    # @rbs right_instance: Quo::Query | ::ActiveRecord::Relation
-    private def self.validate_instances: (Quo::Query | ::ActiveRecord::Relation left_instance, Quo::Query | ::ActiveRecord::Relation right_instance) -> untyped
+    # @rbs base: Class
+    # @rbs return: void
+    def self.included: (Class base) -> void
 
-    # @rbs relation: ::ActiveRecord::Relation
-    # @rbs query: Quo::Query
-    # @rbs joins: untyped
-    private def self.merge_query_and_relation: (Quo::Query query, ::ActiveRecord::Relation relation, untyped joins) -> untyped
-
-    # @rbs relation: ::ActiveRecord::Relation
-    # @rbs query: Quo::Query
-    # @rbs joins: untyped
-    private def self.merge_relation_and_query: (::ActiveRecord::Relation relation, Quo::Query query, untyped joins) -> untyped
-
-    # @rbs left_query: Quo::Query | ::ActiveRecord::Relation
-    # @rbs right_query: Quo::Query | ::ActiveRecord::Relation
-    private def self.merge_query_instances: (Quo::Query | ::ActiveRecord::Relation left_query, Quo::Query | ::ActiveRecord::Relation right_query, untyped joins) -> untyped
+    # @rbs override
+    def query: ...
 
-    # @rbs left_query: Quo::Query | ::ActiveRecord::Relation
-    # @rbs right_query: Quo::Query | ::ActiveRecord::Relation
-    private def self.determine_base_class_for_queries: (Quo::Query | ::ActiveRecord::Relation left_query, Quo::Query | ::ActiveRecord::Relation right_query) -> untyped
+    # @rbs override
+    def inspect: ...
 
     private
 
@@ -86,10 +57,6 @@ module Quo
     # @rbs return: ActiveRecord::Relation
     def merge_active_record_relations: (ActiveRecord::Relation left_rel, ActiveRecord::Relation right_rel) -> ActiveRecord::Relation
 
-    # @rbs left_rel: ActiveRecord::Relation
-    # @rbs return: ActiveRecord::Relation
-    def apply_joins: (ActiveRecord::Relation left_rel) -> ActiveRecord::Relation
-
     # @rbs rel: untyped
     # @rbs return: bool
     def is_relation?: (untyped rel) -> bool

data/sig/generated/quo/composed_relation_backed_query.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/quo/composed_relation_backed_query.rb with RBS::Inline
+
+module Quo
+  class ComposedRelationBackedQuery
+    include ComposedInstance
+
+    @left: Quo::Query | ActiveRecord::Relation | Enumerable[untyped]
+
+    @right: Quo::Query | ActiveRecord::Relation | Enumerable[untyped]
+
+    @merge_joins: Symbol | Hash[untyped, untyped] | Array[untyped] | nil
+
+    # @rbs override
+    def query: ...
+
+    # @rbs override
+    def inspect: ...
+
+    private
+
+    # @rbs operand: untyped
+    # @rbs return: String
+    def operand_desc: (untyped operand) -> String
+  end
+end

data/sig/generated/quo/composing/base_strategy.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/quo/composing/base_strategy.rb with RBS::Inline
+
+module Quo
+  module Composing
+    # Base class for all composition strategies
+    class BaseStrategy
+      # @rbs left: untyped
+      # @rbs right: untyped
+      # @rbs return: bool
+      def applicable?: (untyped left, untyped right) -> bool
+
+      # @rbs return: untyped
+      def compose: () -> untyped
+    end
+  end
+end

data/sig/generated/quo/composing/class_strategy.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/quo/composing/class_strategy.rb with RBS::Inline
+
+module Quo
+  module Composing
+    # Base class for class composition strategies
+    class ClassStrategy < BaseStrategy
+      # @rbs left_query_class: Class
+      # @rbs right_query_class: Class
+      # @rbs return: void
+      def validate_query_classes: (Class left_query_class, Class right_query_class) -> void
+
+      # Collect properties that need to be (re)defined on the composed class.
+      # Properties already declared on `chosen_superclass` are inherited via the
+      # normal Ruby/Literal class hierarchy and do not need to be re-registered;
+      # skipping them avoids the per-prop Literal::Property allocation, schema
+      # dup, and `module_eval` of reader/writer source on every Class.new.
+      # @rbs chosen_superclass: Class
+      # @rbs left_query_class: Class
+      # @rbs right_query_class: Class
+      # @rbs return: Hash[Symbol, Literal::Property]
+      def collect_properties: (Class chosen_superclass, Class left_query_class, Class right_query_class) -> Hash[Symbol, Literal::Property]
+
+      # @rbs chosen_superclass: Class
+      # @rbs props: Hash[Symbol, Literal::Property]
+      # @rbs return: Class & Quo::ComposedQuery
+      def create_composed_class: (Class chosen_superclass, Hash[Symbol, Literal::Property] props) -> (Class & Quo::ComposedQuery)
+
+      # @rbs klass: Class
+      # @rbs left_query_class: Class
+      # @rbs right_query_class: Class
+      # @rbs joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]?
+      # @rbs left_spec: Quo::RelationBackedQuerySpecification?
+      # @rbs right_spec: Quo::RelationBackedQuerySpecification?
+      # @rbs return: void
+      def assign_query_metadata: (Class klass, Class left_query_class, Class right_query_class, Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]? joins, Quo::RelationBackedQuerySpecification? left_spec, Quo::RelationBackedQuerySpecification? right_spec) -> void
+    end
+  end
+end

data/sig/generated/quo/composing/class_strategy_registry.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/quo/composing/class_strategy_registry.rb with RBS::Inline
+
+module Quo
+  module Composing
+    # Registry for class composition strategies
+    class ClassStrategyRegistry
+      # @rbs return: Array[Quo::Composing::BaseStrategy]
+      def strategies: () -> Array[Quo::Composing::BaseStrategy]
+
+      # @rbs left: Class
+      # @rbs right: Class
+      # @rbs return: Quo::Composing::BaseStrategy
+      def find_strategy: (Class left, Class right) -> Quo::Composing::BaseStrategy
+    end
+  end
+end

data/sig/generated/quo/composing/query_classes_strategy.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/quo/composing/query_classes_strategy.rb with RBS::Inline
+
+module Quo
+  module Composing
+    # Strategy for composing two Query classes
+    class QueryClassesStrategy < ClassStrategy
+      # @rbs override
+      # @rbs left: Class
+      # @rbs right: Class
+      # @rbs return: bool
+      def applicable?: ...
+
+      # @rbs override
+      # @rbs chosen_superclass: Class
+      # @rbs left_query_class: Class
+      # @rbs right_query_class: Class
+      # @rbs joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]?
+      # @rbs left_spec: Quo::RelationBackedQuerySpecification?
+      # @rbs right_spec: Quo::RelationBackedQuerySpecification?
+      # @rbs return: Class & Quo::ComposedQuery
+      def compose: ...
+    end
+  end
+end

data/sig/generated/quo/composing.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/quo/composing.rb with RBS::Inline
+
+module Quo
+  module Composing
+    CLASS_STRATEGY_REGISTRY: untyped
+
+    # @rbs chosen_superclass: Class
+    # @rbs left_query_class: Class
+    # @rbs right_query_class: Class
+    # @rbs joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]?
+    # @rbs left_spec: Quo::RelationBackedQuerySpecification?
+    # @rbs right_spec: Quo::RelationBackedQuerySpecification?
+    # @rbs return: Class & Quo::ComposedQuery
+    def self.composer: (Class chosen_superclass, Class left_query_class, Class right_query_class, ?joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]?, ?left_spec: Quo::RelationBackedQuerySpecification?, ?right_spec: Quo::RelationBackedQuerySpecification?) -> (Class & Quo::ComposedQuery)
+
+    # @rbs left_instance: Quo::Query
+    # @rbs right_instance: Quo::Query | ActiveRecord::Relation | Object & Enumerable[untyped]
+    # @rbs joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]?
+    # @rbs return: Quo::Query
+    def self.merge_instances: (Quo::Query left_instance, Quo::Query | ActiveRecord::Relation | Object & Enumerable[untyped] right_instance, ?joins: Symbol | Hash[Symbol, untyped] | Array[Symbol | Hash[Symbol, untyped]]?) -> Quo::Query
+
+    # @rbs operand: untyped
+    # @rbs return: bool
+    private def self.relation_backed?: (untyped operand) -> bool
+
+    # @rbs left: untyped
+    # @rbs right: untyped
+    # @rbs return: Array[Integer?]
+    private def self.inherited_pagination: (untyped left, untyped right) -> Array[Integer?]
+
+    # @rbs operand: untyped
+    # @rbs return: untyped
+    private def self.pagination_source: (untyped operand) -> untyped
+
+    # @rbs left: untyped
+    # @rbs right: untyped
+    # @rbs return: Proc?
+    private def self.inherited_transformer: (untyped left, untyped right) -> Proc?
+  end
+end

data/sig/generated/quo/engine.rbs

@@ -1,6 +1,7 @@
 # Generated from lib/quo/engine.rb with RBS::Inline
 
 module Quo
+  # Rails engine for integrating Quo with Rails applications
   class Engine < ::Rails::Engine
   end
 end

data/sig/generated/quo/minitest/helpers.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/quo/minitest/helpers.rb with RBS::Inline
+
+module Quo
+  module Minitest
+    # Test helpers for stubbing query objects in Minitest
+    module Helpers
+      include Quo::Testing::FakeHelpers
+
+      def fake_query: (untyped query_class, ?results: untyped, ?total_count: untyped, ?page_count: untyped) ?{ (?) -> untyped } -> untyped
+    end
+  end
+end