quo 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88c53b53f941762022f3b012abe6fe3e977e125c562f771aca630c28a087c13e
-  data.tar.gz: dfdeb96c25d7a3e06fef0524b6c77be0cff1ae94368b39f17d6a3a3c8400e181
+  metadata.gz: 071f43a86ac28245731999ddf6f605c89802b71e3d51139d44263214ad25dbd5
+  data.tar.gz: 5eaf5d72a701679c599e5d07f60e8f1c7c9eb1f2e00a7f8ad1503270bc9cda64
 SHA512:
-  metadata.gz: 281cad72c46e498166255f5f973fd09dfec37d309e406bccbfe27cd8ae80cfd95321f2dace615d0be36db8b9b9f38b3257e7e2acf3fd81c7f05788daa48d8e9d
-  data.tar.gz: f09f1213677fb08bc45ac5c27262afc0692555fe24a0da0547ad37e15661019d92d9e49f7eda7651c9c518334cca2f1195a38e0c7d60b61384240f34046032d6
+  metadata.gz: ed91b9a82feb1c8f165672ffa4d2b1212ea7e8780cb85980f82353eca7fdfb247e67101fb6156ceaad65be94f27406daa4a5832e4950ab0204f7a9dc326329a7
+  data.tar.gz: 503525140bd10ed28817e61dc0a2de8ef4e60ca32805427b72763a039982fd069a147ce8eb18d91896ac83202645a12092a8b186b530c97322f465baeeba687a

data/README.md

@@ -201,50 +201,44 @@ Specify extra options to enable pagination:
 * `page`: the current page number to fetch
 * `page_size`: the number of elements to fetch in the page
 
-## 'Eager loaded' Quo::Query objects
+### `Quo::EagerQuery` & `Quo::LoadedQuery` objects
 
-When a query object returns an `Array` from `query` it is assumed as 'eager loaded', ie that the query has actually
-already been executed and the array contains the return values. This can also be used to encapsulate data that doesn't
-actually come from an ActiveRecord query.
-
-For example, the Query below executes the query inside on the first call and memoises the resulting data. Note
-however that this then means that this Query is not reusuable to `merge` with other ActiveRecord queries. If it is
-`compose`d with other Query objects then it will be seen as an array-like, and concatenated to whatever it is being
-joined to.
+`Quo::EagerQuery` is a subclass of `Quo::Query` which can be used to create query objects which are 'eager loaded' by 
+default. This is useful for encapsulating data that doesn't come from an ActiveRecord query or queries that
+execute immediately. Subclass EasyQuery and override `collection` to return the data you want to encapsulate.
 
 ```ruby
-class CachedTags < Quo::Query
-  def query
-    @tags ||= Tag.where(active: true).to_a
+class MyEagerQuery < Quo::EagerQuery
+  def collection
+    [1, 2, 3]
   end
 end
-
-q = CachedTags.new(active: false)
+q = MyEagerQuery.new
 q.eager? # is it 'eager'? Yes it is!
-q.count # array size
+q.count # '3'
 ```
 
-### `Quo::EagerQuery` objects
-
-`Quo::EagerQuery` is a subclass of `Quo::Query` which takes a data value on instantiation and returns it on calls to `query`
+Sometimes it is useful to create similar Queries without needing to create a explicit subclass of your own. For this
+use `Quo::LoadedQuery`:
 
 ```ruby
-q = Quo::EagerQuery.new(collection: [1, 2, 3])
+q = Quo::LoadedQuery.new([1, 2, 3])
 q.eager? # is it 'eager'? Yes it is!
 q.count # '3'
 ```
 
-This is useful to create eager loaded Queries without needing to create a explicit subclass of your own.
-
 `Quo::EagerQuery` also uses `total_count` option value as the specified 'total count', useful when the data is
 actually just a page of the data and not the total count.
 
 Example of an EagerQuery used to wrap a page of enumerable data:
 
 ```ruby
-Quo::EagerQuery.new(collection: my_data, total_count: 100, page: current_page)
+Quo::LoadedQuery.new(my_data, total_count: 100, page: current_page)
 ```
 
+If a loaded query is `compose`d with other Query objects then it will be seen as an array-like, and concatenated to whatever 
+results are returned from the other queries. An loaded or eager query will force all other queries to be eager loaded.
+
 ### Composition
 
 Examples of composition of eager loaded queries
@@ -262,7 +256,7 @@ composed.last
 composed.first
 # => #<Tag id: ...>
 
-Quo::EagerQuery.new([3, 4]).compose(Quo::EagerQuery.new(collection: [1, 2])).last
+Quo::LoadedQuery.new([3, 4]).compose(Quo::LoadedQuery.new([1, 2])).last
 # => 2
 Quo::Query.compose([1, 2], [3, 4]).last
 # => 4
@@ -292,7 +286,7 @@ maybe desirable.
 
 The spec helper method `stub_query(query_class, {results: ..., with: ...})` can do this for you.
 
-It stubs `.new` on the Query object and returns instances of `EagerQuery` instead with the given `results`. 
+It stubs `.new` on the Query object and returns instances of `LoadedQuery` instead with the given `results`. 
 The `with` option is passed to the Query object on initialisation and used when setting up the method stub on the 
 query class.
 

data/Steepfile

@@ -31,6 +31,7 @@ target :lib do
   signature "sig"
   ignore "lib/quo/rspec/*.rb"
   ignore "lib/tasks/*"
+  ignore "lib/quo/railtie.rb"
 
   library "forwardable"
 end

data/lib/quo/eager_query.rb

@@ -2,25 +2,22 @@
 
 module Quo
   class EagerQuery < Quo::Query
-    def initialize(**options)
-      @collection = Array.wrap(options[:collection])
-      super(**options.except(:collection))
-    end
-
     # Optionally return the `total_count` option if it has been set.
     # This is useful when the total count is known and not equal to size
     # of wrapped collection.
     def count
       options[:total_count] || super
     end
-    alias_method :total_count, :count
-    alias_method :size, :count
 
     # Is this query object paged? (when no total count)
     def paged?
       options[:total_count].nil? && current_page.present?
     end
 
+    def collection
+      raise NotImplementedError, "EagerQuery objects must define a 'collection' method"
+    end
+
     def query
       preload_includes(collection) if options[:includes]
       collection
@@ -36,7 +33,13 @@ module Quo
 
     private
 
-    attr_reader :collection
+    def underlying_query
+      unwrap_relation(query)
+    end
+
+    def unwrap_relation(query)
+      query.is_a?(Quo::Query) ? query.unwrap : query
+    end
 
     def preload_includes(records, preload = nil)
       ::ActiveRecord::Associations::Preloader.new(

data/lib/quo/loaded_query.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quo
+  class LoadedQuery < Quo::EagerQuery
+    def initialize(collection, **options)
+      @collection = collection
+      super(**options)
+    end
+
+    def copy(**options)
+      self.class.new(@collection, **@options.merge(options))
+    end
+
+    private
+
+    attr_reader :collection
+  end
+end

data/lib/quo/merged_query.rb

@@ -2,24 +2,6 @@
 
 module Quo
   class MergedQuery < Quo::Query
-    class << self
-      def call(**options)
-        build_from_options(**options).first
-      end
-
-      def call!(**options)
-        build_from_options(**options).first!
-      end
-
-      def build_from_options(**options)
-        merged_query = options[:merged_query]
-        left = options[:left]
-        right = options[:right]
-        raise ArgumentError "MergedQuery needs the merged result and operands" unless merged_query && left && right
-        new(merged_query, left, right, **options)
-      end
-    end
-
     def initialize(merged_query, left, right, **options)
       @merged_query = merged_query
       @left = left

data/lib/quo/query.rb

@@ -28,7 +28,7 @@ module Quo
     def initialize(**options)
       @options = options
       @current_page = options[:page]&.to_i || options[:current_page]&.to_i
-      @page_size = options[:page_size]&.to_i || 20
+      @page_size = options[:page_size]&.to_i || Quo.configuration.default_page_size || 20
     end
 
     # Returns a active record query, or a Quo::Query instance
@@ -93,57 +93,60 @@ module Quo
     delegate :model, :klass, to: :underlying_query
 
     # Get first elements
-    def first(*args)
+    def first(limit = nil)
       if transform?
-        res = query_with_logging.first(*args)
+        res = query_with_logging.first(limit)
         if res.is_a? Array
-          res.map.with_index { |r, i| transformer.call(r, i) }
+          res.map.with_index { |r, i| transformer&.call(r, i) }
         elsif !res.nil?
-          transformer.call(query_with_logging.first(*args))
+          transformer&.call(query_with_logging.first(limit))
         end
+      elsif limit
+        query_with_logging.first(limit)
       else
-        query_with_logging.first(*args)
+        # Array#first will not take nil as a limit
+        query_with_logging.first
       end
     end
 
-    def first!(*args)
-      item = first(*args)
+    def first!(limit = nil)
+      item = first(limit)
       raise ActiveRecord::RecordNotFound, "No item could be found!" unless item
       item
     end
 
     # Get last elements
-    def last(*args)
+    def last(limit = nil)
       if transform?
-        res = query_with_logging.last(*args)
+        res = query_with_logging.last(limit)
         if res.is_a? Array
-          res.map.with_index { |r, i| transformer.call(r, i) }
+          res.map.with_index { |r, i| transformer&.call(r, i) }
         elsif !res.nil?
-          transformer.call(query_with_logging.last(*args))
+          transformer&.call(res)
         end
+      elsif limit
+        query_with_logging.last(limit)
       else
-        query_with_logging.last(*args)
+        query_with_logging.last
       end
     end
 
     # Convert to array
     def to_a
       arr = query_with_logging.to_a
-      transform? ? arr.map.with_index { |r, i| transformer.call(r, i) } : arr
+      transform? ? arr.map.with_index { |r, i| transformer&.call(r, i) } : arr
     end
 
-    # Convert to EagerQuery, and load all data
     def to_eager(more_opts = {})
-      Quo::EagerQuery.new(collection: to_a, **options.merge(more_opts))
+      Quo::LoadedQuery.new(to_a, **options.merge(more_opts))
     end
     alias_method :load, :to_eager
 
-    # Return an enumerable
-    def enumerator
-      Quo::Enumerator.new(self, transformer: transformer)
+    def results
+      Quo::Results.new(self, transformer: transformer)
     end
 
-    # Some convenience methods for iterating over the results
+    # Some convenience methods for working with results
     delegate :each,
       :map,
       :flat_map,
@@ -151,8 +154,9 @@ module Quo
       :reject,
       :filter,
       :find,
+      :include?,
       :each_with_object,
-      to: :enumerator
+      to: :results
 
     # Set a block used to transform data after query fetching
     def transform(&block)
@@ -226,7 +230,11 @@ module Quo
 
     def offset
       per_page = sanitised_page_size
-      page = current_page&.positive? ? current_page : 1
+      page = if current_page && current_page&.positive?
+        current_page
+      else
+        1
+      end
       per_page * (page - 1)
     end
 
@@ -238,7 +246,17 @@ module Quo
     end
 
     def sanitised_page_size
-      (page_size.present? && page_size.positive?) ? [page_size.to_i, 200].min : 20
+      if page_size && page_size.positive?
+        given_size = page_size.to_i
+        max_page_size = Quo.configuration.max_page_size || 200
+        if given_size > max_page_size
+          max_page_size
+        else
+          given_size
+        end
+      else
+        Quo.configuration.default_page_size || 20
+      end
     end
 
     def query_with_logging
@@ -268,7 +286,7 @@ module Quo
     end
 
     def test_eager(rel)
-      rel.is_a?(Enumerable) && !test_relation(rel)
+      rel.is_a?(Quo::LoadedQuery) || (rel.is_a?(Enumerable) && !test_relation(rel))
     end
 
     def test_relation(rel)

data/lib/quo/query_composer.rb

@@ -5,6 +5,10 @@ module Quo
     def initialize(left, right, joins = nil)
       @left = left
       @right = right
+      @unwrapped_left = unwrap_relation(left)
+      @unwrapped_right = unwrap_relation(right)
+      @left_relation = @unwrapped_left.is_a?(::ActiveRecord::Relation)
+      @right_relation = @unwrapped_right.is_a?(::ActiveRecord::Relation)
       @joins = joins
     end
 
@@ -19,22 +23,28 @@ module Quo
 
     private
 
-    attr_reader :left, :right, :joins
+    attr_reader :left, :right, :joins, :unwrapped_left, :unwrapped_right
 
-    def merge_left_and_right
-      left_rel = unwrap_relation(left)
-      right_rel = unwrap_relation(right)
-      left_is_relation = relation_type?(left)
-      right_is_relation = relation_type?(right)
+    def left_relation?
+      @left_relation
+    end
+
+    def right_relation?
+      @right_relation
+    end
 
-      if left_is_relation && right_is_relation
-        apply_joins(left_rel, joins).merge(right_rel)
-      elsif left_is_relation && !right_is_relation
-        left_rel.to_a + right_rel
-      elsif !left_is_relation && right_is_relation
-        left_rel + right_rel.to_a
-      elsif !left_is_relation && !right_is_relation
-        left_rel + right_rel
+    def merge_left_and_right
+      # FIXME: Skipping type checks here, as not sure how to make this type check with RBS
+      __skip__ = if both_relations?
+        apply_joins(unwrapped_left, joins).merge(unwrapped_right)
+      elsif left_relation_right_enumerable?
+        unwrapped_left.to_a + unwrapped_right
+      elsif left_enumerable_right_relation? && unwrapped_left.respond_to?(:+)
+        unwrapped_left + unwrapped_right.to_a
+      elsif unwrapped_left.respond_to?(:+)
+        unwrapped_left + unwrapped_right
+      else
+        raise ArgumentError, "Cannot merge #{left.class} with #{right.class}"
       end
     end
 
@@ -49,16 +59,20 @@ module Quo
       query.is_a?(Quo::Query) ? query.unwrap : query
     end
 
-    def relation_type?(query)
-      if query.is_a?(::Quo::Query)
-        query.relation?
-      else
-        query.is_a?(::ActiveRecord::Relation)
-      end
-    end
-
     def apply_joins(left_rel, joins)
       joins.present? ? left_rel.joins(joins) : left_rel
     end
+
+    def both_relations?
+      left_relation? && right_relation?
+    end
+
+    def left_relation_right_enumerable?
+      left_relation? && !right_relation?
+    end
+
+    def left_enumerable_right_relation?
+      !left_relation? && right_relation?
+    end
   end
 end

data/lib/quo/{enumerator.rb → results.rb}

@@ -4,7 +4,7 @@ require "forwardable"
 require_relative "./utilities/callstack"
 
 module Quo
-  class Enumerator
+  class Results
     extend Forwardable
     include Quo::Utilities::Callstack
 
@@ -28,7 +28,7 @@ module Quo
       grouped = unwrapped.group_by do |*block_args|
         x = block_args.first
         transformed = transformer ? transformer.call(x) : x
-        block.call(transformed, *block_args[1..])
+        block ? block.call(transformed, *(block_args[1..] || [])) : transformed
       end
 
       grouped.tap do |groups|
@@ -51,7 +51,8 @@ module Quo
           end
         else
           raw = unwrapped.send(method, *args, **kwargs)
-          return raw if raw.is_a?(Quo::Enumerator) || raw.is_a?(::Enumerator)
+          # FIXME: consider how to handle applying a transformer to a Enumerator...
+          return raw if raw.is_a?(Quo::Results) || raw.is_a?(::Enumerator)
           transform_results(raw)
         end
       else

data/lib/quo/rspec/helpers.rb

@@ -9,10 +9,10 @@ module Quo
         unless with.nil?
           return(
             allow(query_class).to receive(:new)
-                                    .with(with) { ::Quo::EagerQuery.new(collection: results) }
+                                    .with(with) { ::Quo::LoadedQuery.new(results) }
           )
         end
-        allow(query_class).to receive(:new) { ::Quo::EagerQuery.new(collection: results) }
+        allow(query_class).to receive(:new) { ::Quo::LoadedQuery.new(results) }
       end
     end
   end

data/lib/quo/utilities/callstack.rb

@@ -12,7 +12,7 @@ module Quo
         stack = Kernel.caller.grep_v(exclude).map { |l| l.gsub(working_dir + "/", "") }
         stack_to_display = stack[0..callstack_size]
         message = "\n[Query stack]: -> #{stack_to_display&.join("\n               &> ")}\n"
-        message += " (truncated to #{callstack_size} most recent)" if stack.size > callstack_size
+        message += " (truncated to #{callstack_size} most recent)" if callstack_size && stack.size > callstack_size
         Quo.configuration.logger&.info(message)
       end
     end

data/lib/quo/utilities/wrap.rb

@@ -15,7 +15,7 @@ module Quo
         if query_rel_or_data.is_a? ActiveRecord::Relation
           Quo::WrappedQuery.new(query_rel_or_data, **options)
         else
-          Quo::EagerQuery.new(**options.merge(collection: query_rel_or_data))
+          Quo::LoadedQuery.new(query_rel_or_data, **options)
         end
       end
     end

data/lib/quo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quo
-  VERSION = "0.3.1"
+  VERSION = "0.5.0"
 end

data/lib/quo/wrapped_query.rb

@@ -2,27 +2,15 @@
 
 module Quo
   class WrappedQuery < Quo::Query
-    class << self
-      def call(**options)
-        build_from_options(**options).first
-      end
-
-      def call!(**options)
-        build_from_options(**options).first!
-      end
-
-      def build_from_options(**options)
-        query = options[:wrapped_query]
-        raise ArgumentError "WrappedQuery needs a scope" unless query
-        new(query, **options)
-      end
-    end
-
     def initialize(wrapped_query, **options)
       @wrapped_query = wrapped_query
       super(**options)
     end
 
+    def copy(**options)
+      self.class.new(query, **@options.merge(options))
+    end
+
     def query
       @wrapped_query
     end

data/lib/quo.rb

@@ -4,10 +4,11 @@ require_relative "quo/version"
 require_relative "quo/railtie" if defined?(Rails)
 require_relative "quo/query"
 require_relative "quo/eager_query"
+require_relative "quo/loaded_query"
 require_relative "quo/merged_query"
 require_relative "quo/wrapped_query"
 require_relative "quo/query_composer"
-require_relative "quo/enumerator"
+require_relative "quo/results"
 
 module Quo
   class << self
@@ -22,12 +23,18 @@ module Quo
   end
 
   class Configuration
-    attr_accessor :formatted_query_log, :query_show_callstack_size, :logger
+    attr_accessor :formatted_query_log,
+      :query_show_callstack_size,
+      :logger,
+      :max_page_size,
+      :default_page_size
 
     def initialize
       @formatted_query_log = true
       @query_show_callstack_size = 10
       @logger = nil
+      @max_page_size = 200
+      @default_page_size = 20
     end
   end
 end

data/sig/quo/eager_query.rbs

@@ -1,13 +1,15 @@
 module Quo
   class EagerQuery < Quo::Query
-    def initialize: (**untyped options) -> void
-    def query: () -> enumerable
+    def collection: () -> loadedQueryOrEnumerable
+    def query: () -> loadedQueryOrEnumerable
+
     def relation?: () -> false
     def eager?: () -> true
-    attr_reader collection: enumerable
 
     private
 
     def preload_includes: (untyped records, ?untyped? preload) -> untyped
+    def underlying_query: () -> enumerable
+    def unwrap_relation: (loadedQueryOrEnumerable collection) -> enumerable
   end
 end

data/sig/quo/loaded_query.rbs

@@ -0,0 +1,7 @@
+module Quo
+  class LoadedQuery < Quo::EagerQuery
+    @collection: enumerable
+
+    def initialize: (enumerable, **untyped options) -> void
+  end
+end

data/sig/quo/merged_query.rbs

@@ -1,10 +1,12 @@
 module Quo
   class MergedQuery < Quo::Query
+    def self.build_from_options: (queryOptions) -> MergedQuery
+
     def initialize: (relOrEnumerable merged, composable left, composable right, **untyped options) -> void
 
     @merged_query: relOrEnumerable
 
-    def query: () -> composable
+    def query: () -> relOrEnumerable
 
     def to_s: () -> ::String
 

data/sig/quo/query.rbs

@@ -40,13 +40,13 @@ module Quo
 
     alias size count
     def page_count: () -> Integer
-    def first: (*untyped args) -> untyped
-    def first!: (*untyped args) -> untyped
-    def last: (*untyped args) -> untyped
+    def first: (?Integer? limit) -> untyped
+    def first!: (?Integer? limit) -> untyped
+    def last: (?Integer? limit) -> untyped
     def to_a: () -> Array[untyped]
     def to_eager: (?::Hash[untyped, untyped] more_opts) -> Quo::EagerQuery
     alias load to_eager
-    def enumerator: () -> Quo::Enumerator
+    def results: () -> Quo::Results
 
     # Set a block used to transform data after query fetching
     def transform: () ?{ () -> untyped } -> self
@@ -70,7 +70,7 @@ module Quo
     def formatted_queries?: () -> bool
     def trim_query: (String sql) -> String
     def format_query: (String sql_str) -> String
-    def transformer: () -> (nil | ^(untyped) -> untyped)
+    def transformer: () -> (nil | ^(untyped, ?Integer) -> untyped)
     def offset: () -> Integer
     def configured_query: () -> ActiveRecord::Relation
     def sanitised_page_size: () -> Integer

data/sig/quo/query_composer.rbs

@@ -1,5 +1,8 @@
 module Quo
   class QueryComposer
+    @left_relation: bool
+    @right_relation: bool
+
     def initialize: (composable left, composable right, ?untyped? joins) -> void
     def compose: () -> Quo::MergedQuery
 
@@ -9,10 +12,21 @@ module Quo
     attr_reader right: composable
     attr_reader joins: untyped
 
-    def merge_left_and_right: () -> (ActiveRecord::Relation | Array[untyped])
+    attr_reader unwrapped_left: relOrEnumerable
+    attr_reader unwrapped_right: relOrEnumerable
+
+    def left_relation?: -> bool
+
+    def merge_left_and_right: () -> relOrEnumerable
     def merged_options: () -> ::Hash[untyped, untyped]
+
+    def right_relation?: -> bool
+
     def unwrap_relation: (composable) -> relOrEnumerable
-    def relation_type?: (composable) -> bool
+    def relation_type?: (relOrEnumerable) -> bool
     def apply_joins: (ActiveRecord::Relation left_rel, untyped joins) -> ActiveRecord::Relation
+    def both_relations?: () -> bool
+    def left_relation_right_enumerable?: () -> bool
+    def left_enumerable_right_relation?: () -> bool
   end
 end

data/sig/quo/{enumerator.rbs → results.rbs}

@@ -1,5 +1,5 @@
 module Quo
-  class Enumerator
+  class Results
     extend Forwardable
 
     include Quo::Utilities::Callstack
@@ -8,7 +8,7 @@ module Quo
 
     @query: Quo::Query
 
-    def group_by: -> Hash[untyped, Array[untyped]]
+    def group_by: () { (untyped, *untyped) -> untyped } -> Hash[untyped, Array[untyped]]
 
     def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
 

data/sig/quo/wrapped_query.rbs

@@ -1,9 +1,9 @@
 module Quo
   class WrappedQuery < Quo::Query
-    @wrapped_query:  ActiveRecord::Relation
-
     def self.build_from_options: (**untyped options) -> WrappedQuery
 
+    @wrapped_query:  ActiveRecord::Relation
+
     def initialize: (ActiveRecord::Relation query, **untyped options) -> void
 
     def query: () -> ActiveRecord::Relation

data/sig/quo.rbs

@@ -11,11 +11,15 @@ module Quo
 
   type query = Quo::Query
   type queryOrRel = query | ActiveRecord::Relation
-  # FIXME: anything that is Enumerable should be composable, but I don't know how to express that
-  type enumerable = Array[untyped] | Set[untyped]
+  type enumerable = Object & Enumerable[untyped]
   type relOrEnumerable = ActiveRecord::Relation | enumerable
+  type loadedQueryOrEnumerable = LoadedQuery | EagerQuery | enumerable
   type composable = query | relOrEnumerable
 
+  # TODO: how can we do the known options, eg `page` and then allow anything else?
+  # Maybe we should separate out the known options from the unknown options
+  type queryOptions = Hash[Symbol, untyped]
+
   interface _Logger
     def info: (String) -> void
     def error: (String) -> void
@@ -26,6 +30,8 @@ module Quo
     attr_accessor formatted_query_log: bool?
     attr_accessor query_show_callstack_size: Integer?
     attr_accessor logger: _Logger?
+    attr_accessor max_page_size: Integer?
+    attr_accessor default_page_size: Integer?
 
     def initialize: () -> void
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quo
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-22 00:00:00.000000000 Z
+date: 2022-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,11 +66,12 @@ files:
 - Steepfile
 - lib/quo.rb
 - lib/quo/eager_query.rb
-- lib/quo/enumerator.rb
+- lib/quo/loaded_query.rb
 - lib/quo/merged_query.rb
 - lib/quo/query.rb
 - lib/quo/query_composer.rb
 - lib/quo/railtie.rb
+- lib/quo/results.rb
 - lib/quo/rspec/helpers.rb
 - lib/quo/utilities/callstack.rb
 - lib/quo/utilities/compose.rb
@@ -82,10 +83,11 @@ files:
 - rbs_collection.yaml
 - sig/quo.rbs
 - sig/quo/eager_query.rbs
-- sig/quo/enumerator.rbs
+- sig/quo/loaded_query.rbs
 - sig/quo/merged_query.rbs
 - sig/quo/query.rbs
 - sig/quo/query_composer.rbs
+- sig/quo/results.rbs
 - sig/quo/utilities/callstack.rbs
 - sig/quo/utilities/compose.rbs
 - sig/quo/utilities/sanitize.rbs