quo 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3278d72f55569eb93fb569185467cd4b327ffd157e249c8538d4a643c652443c
-  data.tar.gz: e936c5fd0de429b941e110c273cb12ff302079095ab0f3d7d38023718b80b5e3
+  metadata.gz: 61bf7495c0092bf641ff6e85bed8dc0073ea61e15a5292f0825f50eca4348a92
+  data.tar.gz: c10cc10dfe8ce323e4395640604a1c6358333bb7ea26b1c109d43eee67ed2d73
 SHA512:
-  metadata.gz: 4adcb23af540cf2db462bd21640aef4497c1f2509a1ac6968a5a15b1cd2004d7db9935638ba5496eb57ffc655ad515688fc9468a191d17b32735da1a7c652705
-  data.tar.gz: f99119cdf52a97e956317a530e9074e12b07816405f6dd5fd80f74665dd34c0294368ed6d6a7d88f8147484486f52606462864663357e430ca2eebc36b7372d7
+  metadata.gz: e8e4105330e725058ca4c94f2c58229a0018e9379c38ac189cc2dbd007163468b845dd9632d727f824a35d4bc8cebbb7e40f5d24267277b0c1cbe0b580abb100
+  data.tar.gz: 7180ea2d74f1849628a1635c381685c5d2841c27229868280cd59a580dae759d61cc5236fba06b4044a93b667a23f670f4ba5960720165ccb1a6a103a4d06f37

data/README.md

@@ -229,7 +229,7 @@ q.count # array size
 `Quo::EagerQuery` is a subclass of `Quo::Query` which takes a data value on instantiation and returns it on calls to `query`
 
 ```ruby
-q = Quo::EagerQuery.new(collection: [1, 2, 3])
+q = Quo::EagerQuery.new([1, 2, 3])
 q.eager? # is it 'eager'? Yes it is!
 q.count # '3'
 ```
@@ -242,7 +242,7 @@ 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::EagerQuery.new(my_data, total_count: 100, page: current_page)
 ```
 
 ### Composition
@@ -262,7 +262,7 @@ composed.last
 composed.first
 # => #<Tag id: ...>
 
-Quo::EagerQuery.new([3, 4]).compose(Quo::EagerQuery.new(collection: [1, 2])).last
+Quo::EagerQuery.new([3, 4]).compose(Quo::EagerQuery.new([1, 2])).last
 # => 2
 Quo::Query.compose([1, 2], [3, 4]).last
 # => 4

data/Steepfile

@@ -27,8 +27,11 @@
 # end
 
 target :lib do
-  check "lib/quo"
+  check "lib"
   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,9 +2,29 @@
 
 module Quo
   class EagerQuery < Quo::Query
-    def initialize(**options)
-      @collection = Array.wrap(options[:collection])
-      super(**options.except(:collection))
+    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)
+        collection = options[:collection]
+        raise ArgumentError, "EagerQuery needs a collection" unless collection
+        new(collection, **options.except(:collection))
+      end
+    end
+
+    def initialize(collection, **options)
+      @collection = Array.wrap(collection)
+      super(**options)
+    end
+
+    def copy(**options)
+      self.class.new(@collection, **@options.merge(options))
     end
 
     # Optionally return the `total_count` option if it has been set.

data/lib/quo/merged_query.rb

@@ -2,39 +2,52 @@
 
 module Quo
   class MergedQuery < Quo::Query
-    def initialize(options, source_queries = [])
-      @source_queries = source_queries
+    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
+      @right = right
       super(**options)
     end
 
     def query
-      @scope
+      @merged_query
     end
 
-    def to_s
-      left = operand_desc(source_queries_left)
-      right = operand_desc(source_queries_right)
-      "Quo::MergedQuery[#{left}, #{right}]"
+    def copy(**options)
+      self.class.new(query, left, right, **@options.merge(options))
     end
 
-    private
-
-    def source_queries_left
-      source_queries&.first
+    def to_s
+      "Quo::MergedQuery[#{operand_desc(left)}, #{operand_desc(right)}]"
     end
 
-    def source_queries_right
-      source_queries&.last
-    end
+    private
 
-    attr_reader :source_queries
+    attr_reader :left, :right
 
     def operand_desc(operand)
-      return unless operand
       if operand.is_a? Quo::MergedQuery
         operand.to_s
       else
-        operand.class.name
+        operand.class.name || "(anonymous)"
       end
     end
   end

data/lib/quo/query.rb

@@ -28,14 +28,11 @@ 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
-      @scope = unwrap_relation(options[:scope])
+      @page_size = options[:page_size]&.to_i || Quo.configuration.default_page_size || 20
     end
 
     # Returns a active record query, or a Quo::Query instance
-    # You must provide an implementation of this of pass the 'scope' option on instantiation
     def query
-      return @scope unless @scope.nil?
       raise NotImplementedError, "Query objects must define a 'query' method"
     end
 
@@ -96,58 +93,66 @@ 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
       else
-        query_with_logging.first(*args)
+        query_with_logging.first(limit)
       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
       else
-        query_with_logging.last(*args)
+        query_with_logging.last(limit)
       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::EagerQuery.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
-    delegate :each, :map, :flat_map, :reduce, :reject, :filter, to: :enumerator
+    # Some convenience methods for working with results
+    delegate :each,
+      :map,
+      :flat_map,
+      :reduce,
+      :reject,
+      :filter,
+      :find,
+      :include?,
+      :each_with_object,
+      to: :results
 
     # Set a block used to transform data after query fetching
     def transform(&block)
@@ -202,7 +207,7 @@ module Quo
     private
 
     def formatted_queries?
-      Quo.configuration&.formatted_query_log
+      !!Quo.configuration.formatted_query_log
     end
 
     # 'trim' a query, ie remove comments and remove newlines
@@ -221,7 +226,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
 
@@ -233,7 +242,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

data/lib/quo/query_composer.rb

@@ -5,36 +5,44 @@ 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
 
     def compose
-      combined = merge
       Quo::MergedQuery.new(
-        merged_options.merge({scope: combined, source_queries: [left, right]})
+        merge_left_and_right,
+        left,
+        right,
+        **merged_options
       )
     end
 
     private
 
-    attr_reader :left, :right, :joins
+    attr_reader :left, :right, :joins, :unwrapped_left, :unwrapped_right
 
-    def merge
-      left_rel = unwrap_relation(left)
-      right_rel = unwrap_relation(right)
-      left_type = relation_type?(left)
-      right_type = relation_type?(right)
+    def left_relation?
+      @left_relation
+    end
+
+    def right_relation?
+      @right_relation
+    end
 
-      if both_relations?(left_type, right_type)
-        apply_joins(left_rel, joins).merge(right_rel)
-      elsif left_relation_right_eager?(left_type, right_type)
-        left_rel.to_a + right_rel
-      elsif left_eager_right_relation?(left_type, right_type) && left_rel.respond_to?(:+)
-        left_rel + right_rel.to_a
-      elsif both_eager_loaded?(left_type, right_type) && left_rel.respond_to?(:+)
-        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 + unwrapped_right.to_a
       else
-        raise_error
+        unwrapped_left + unwrapped_right
       end
     end
 
@@ -49,38 +57,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_rel_type, right_rel_type)
-      left_rel_type && right_rel_type
-    end
-
-    def left_relation_right_eager?(left_rel_type, right_rel_type)
-      left_rel_type && !right_rel_type
-    end
-
-    def left_eager_right_relation?(left_rel_type, right_rel_type)
-      !left_rel_type && right_rel_type
+    def both_relations?
+      left_relation? && right_relation?
     end
 
-    def both_eager_loaded?(left_rel_type, right_rel_type)
-      !left_rel_type && !right_rel_type
+    def left_relation_right_enumerable?
+      left_relation? && !right_relation?
     end
 
-    def raise_error
-      raise ArgumentError, "Unable to composite queries #{left.class.name} and " \
-            "#{right.class.name}. You cannot compose queries where #query " \
-            "returns an ActiveRecord::Relation in one and an Enumerable in the other."
+    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
 
@@ -21,31 +21,38 @@ module Quo
       :any?,
       :none?,
       :one?,
-      :tally,
-      :count,
-      :group_by,
-      :partition,
-      :slice_before,
-      :slice_after,
-      :slice_when,
-      :chunk,
-      :chunk_while,
-      :sum,
-      :zip
+      :count
+
+    def group_by(&block)
+      debug_callstack
+      grouped = unwrapped.group_by do |*block_args|
+        x = block_args.first
+        transformed = transformer ? transformer.call(x) : x
+        block ? block.call(transformed, *(block_args[1..] || [])) : transformed
+      end
+
+      grouped.tap do |groups|
+        groups.transform_values! do |values|
+          transformer ? values.map { |x| transformer.call(x) } : values
+        end
+      end
+    end
 
     # Delegate other enumerable methods to underlying collection but also transform
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args, **kwargs, &block)
       if unwrapped.respond_to?(method)
         debug_callstack
         if block
-          unwrapped.send(method, *args) do |*block_args|
+          unwrapped.send(method, *args, **kwargs) do |*block_args|
             x = block_args.first
-            transformed = transformer.present? ? transformer.call(x) : x
-            block.call(transformed, *block_args[1..])
+            transformed = transformer ? transformer.call(x) : x
+            other_args = block_args[1..] || []
+            block.call(transformed, *other_args)
           end
         else
-          raw = unwrapped.send(method, *args)
-          return raw if raw.is_a?(Quo::Enumerator) || raw.is_a?(::Enumerator)
+          raw = unwrapped.send(method, *args, **kwargs)
+          # 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
@@ -62,7 +69,7 @@ module Quo
     attr_reader :transformer, :unwrapped
 
     def transform_results(results)
-      return results unless transformer.present?
+      return results unless transformer
 
       if results.is_a?(Enumerable)
         results.map.with_index { |item, i| transformer.call(item, i) }

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::EagerQuery.new(results) }
           )
         end
-        allow(query_class).to receive(:new) { ::Quo::EagerQuery.new(collection: results) }
+        allow(query_class).to receive(:new) { ::Quo::EagerQuery.new(results) }
       end
     end
   end

data/lib/quo/utilities/callstack.rb

@@ -4,14 +4,15 @@ module Quo
   module Utilities
     module Callstack
       def debug_callstack
-        return unless Quo.configuration&.query_show_callstack_size&.positive? && Rails.env.development?
-        max_stack = Quo.configuration.query_show_callstack_size
+        return unless Rails.env.development?
+        callstack_size = Quo.configuration.query_show_callstack_size
+        return unless callstack_size&.positive?
         working_dir = Dir.pwd
         exclude = %r{/(gems/|rubies/|query\.rb)}
         stack = Kernel.caller.grep_v(exclude).map { |l| l.gsub(working_dir + "/", "") }
-        trace_message = stack[0..max_stack].join("\n               &> ")
-        message = "\n[Query stack]: -> #{trace_message}\n"
-        message += " (truncated to #{max_stack} most recent)" if stack.size > max_stack
+        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 callstack_size && stack.size > callstack_size
         Quo.configuration.logger&.info(message)
       end
     end

data/lib/quo/utilities/wrap.rb

@@ -13,9 +13,9 @@ module Quo
         end
 
         if query_rel_or_data.is_a? ActiveRecord::Relation
-          new(**options.merge(scope: query_rel_or_data))
+          Quo::WrappedQuery.new(query_rel_or_data, **options)
         else
-          Quo::EagerQuery.new(**options.merge(collection: query_rel_or_data))
+          Quo::EagerQuery.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.0"
+  VERSION = "0.4.0"
 end

data/lib/quo/wrapped_query.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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 query
+      @wrapped_query
+    end
+  end
+end

data/lib/quo.rb

@@ -5,8 +5,9 @@ require_relative "quo/railtie" if defined?(Rails)
 require_relative "quo/query"
 require_relative "quo/eager_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
@@ -21,12 +22,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

@@ -0,0 +1,18 @@
+module Quo
+  class EagerQuery < Quo::Query
+    def self.call: (**untyped) -> untyped
+    def self.call!: (**untyped) -> untyped
+    def self.build_from_options: (queryOptions) -> EagerQuery
+
+    def initialize: (enumerable, **untyped options) -> void
+    def query: () -> enumerable
+    def relation?: () -> false
+    def eager?: () -> true
+
+    private
+
+    attr_reader collection: enumerable
+
+    def preload_includes: (untyped records, ?untyped? preload) -> untyped
+  end
+end

data/sig/quo/merged_query.rbs

@@ -0,0 +1,19 @@
+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: () -> relOrEnumerable
+
+    def to_s: () -> ::String
+
+    private
+
+    attr_reader left: composable
+    attr_reader right: composable
+    def operand_desc: (composable operand) -> String
+  end
+end

data/sig/quo/query.rbs

@@ -0,0 +1,83 @@
+module Quo
+  class Query
+    include Quo::Utilities::Callstack
+    extend Quo::Utilities::Compose
+    extend Quo::Utilities::Sanitize
+    extend Quo::Utilities::Wrap
+
+    @underlying_query: ActiveRecord::Relation
+
+    def self.call: (**untyped options) -> untyped
+    def self.call!: (**untyped options) -> untyped
+
+    @scope: ActiveRecord::Relation | nil
+
+    attr_reader current_page: Integer?
+    attr_reader page_size: Integer?
+    attr_reader options: Hash[untyped, untyped]
+
+    def initialize: (**untyped options) -> void
+    def query: () -> queryOrRel
+    def compose: (composable right, ?joins: untyped?) -> Quo::MergedQuery
+    alias + compose
+
+    def copy: (**untyped options) -> Quo::Query
+
+    def limit: (untyped limit) -> Quo::Query
+    def order: (untyped options) -> Quo::Query
+    def group: (*untyped options) -> Quo::Query
+    def includes: (*untyped options) -> Quo::Query
+    def preload: (*untyped options) -> Quo::Query
+    def select: (*untyped options) -> Quo::Query
+
+    def sum: (?untyped column_name) -> Numeric
+    def average: (untyped column_name) -> Numeric
+    def minimum: (untyped column_name) -> Numeric
+    def maximum: (untyped column_name) -> Numeric
+    def count: () -> Integer
+
+    alias total_count count
+
+    alias size count
+    def page_count: () -> Integer
+    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 results: () -> Quo::Results
+
+    # Set a block used to transform data after query fetching
+    def transform: () ?{ () -> untyped } -> self
+
+    def exists?: () -> bool
+    def none?: () -> bool
+    alias empty? none?
+    def relation?: () -> bool
+    def eager?: () -> bool
+    def paged?: () -> bool
+
+    def model: () -> (untyped | nil)
+    def klass: () -> (untyped | nil)
+
+    def transform?: () -> bool
+    def to_sql: () -> (String | nil)
+    def unwrap: () -> ActiveRecord::Relation
+
+    private
+
+    def formatted_queries?: () -> bool
+    def trim_query: (String sql) -> String
+    def format_query: (String sql_str) -> String
+    def transformer: () -> (nil | ^(untyped, ?Integer) -> untyped)
+    def offset: () -> Integer
+    def configured_query: () -> ActiveRecord::Relation
+    def sanitised_page_size: () -> Integer
+    def query_with_logging: () -> ActiveRecord::Relation
+    def underlying_query: () -> ActiveRecord::Relation
+    def unwrap_relation: (queryOrRel query) -> ActiveRecord::Relation
+    def test_eager: (composable rel) -> bool
+    def test_relation: (composable rel) -> bool
+  end
+end

data/sig/quo/query_composer.rbs

@@ -0,0 +1,32 @@
+module Quo
+  class QueryComposer
+    @left_relation: bool
+    @right_relation: bool
+
+    def initialize: (composable left, composable right, ?untyped? joins) -> void
+    def compose: () -> Quo::MergedQuery
+
+    private
+
+    attr_reader left: composable
+    attr_reader right: composable
+    attr_reader joins: 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?: (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/results.rbs

@@ -0,0 +1,22 @@
+module Quo
+  class Results
+    extend Forwardable
+
+    include Quo::Utilities::Callstack
+
+    def initialize: (Quo::Query query, ?transformer: (^(untyped, ?Integer) -> untyped)?) -> void
+
+    @query: Quo::Query
+
+    def group_by: () { (untyped, *untyped) -> untyped } -> Hash[untyped, Array[untyped]]
+
+    def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+
+    private
+
+    attr_reader transformer: (^(untyped, ?Integer) -> untyped)?
+    attr_reader unwrapped: relOrEnumerable
+
+    def transform_results: (untyped) -> untyped
+  end
+end

data/sig/quo/utilities/callstack.rbs

@@ -0,0 +1,7 @@
+module Quo
+  module Utilities
+    module Callstack
+      def debug_callstack: () -> void
+    end
+  end
+end

data/sig/quo/utilities/compose.rbs

@@ -0,0 +1,8 @@
+module Quo
+  module Utilities
+    module Compose
+      def compose: (composable query1, composable query2, ?joins: untyped?) -> Quo::MergedQuery
+      def composable_with?: (queryOrRel query) -> bool
+    end
+  end
+end

data/sig/quo/utilities/sanitize.rbs

@@ -0,0 +1,9 @@
+module Quo
+  module Utilities
+    module Sanitize
+      def sanitize_sql_for_conditions: (untyped conditions) -> untyped?
+      def sanitize_sql_string: (untyped string) -> untyped?
+      def sanitize_sql_parameter: (untyped value) -> untyped?
+    end
+  end
+end

data/sig/quo/utilities/wrap.rbs

@@ -0,0 +1,11 @@
+module Quo
+  module Utilities
+    interface _Wrapable
+      def new: (**untyped options) -> query
+    end
+
+    module Wrap : _Wrapable
+      def wrap: (composable query_rel_or_data, **untyped options) -> query
+    end
+  end
+end

data/sig/quo/wrapped_query.rbs

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

data/sig/quo.rbs

@@ -1,205 +1,40 @@
-module Quo
-  VERSION: String
-
-  interface _Enumerable
-    def each: { (untyped) -> void } -> untyped
-  end
-
-  interface _Collection
-    include _Enumerable
-    def is_a?: (Class) -> bool
-    def class: -> Class
-    def +: (untyped) -> _Collection
-  end
-
-  type query = Quo::MergedQuery | Quo::EagerQuery | Quo::Query
-  type merge_composable = query | ActiveRecord::Relation
-  type enumerable = _Collection
-  type query_like = ActiveRecord::Relation | enumerable
-  type composable = query | query_like
-
-  module Utilities
-    module Callstack
-      def debug_callstack: () -> void
-    end
-
-    module Compose
-      # Combine two query-like or composeable entities:
-      # These can be Quo::Query, Quo::MergedQuery, Quo::EagerQuery and ActiveRecord::Relations.
-      # See the `README.md` docs for more details.
-      def compose: (composable query1, composable query2, ?joins: untyped?) -> Quo::MergedQuery
-
-      # Determines if the object `query` is something which can be composed with query objects
-      def composable_with?: (merge_composable query) -> bool
-    end
-
-    module Sanitize
-      def sanitize_sql_for_conditions: (untyped conditions) -> (untyped | nil)
-
-      def sanitize_sql_string: (untyped string) -> (untyped | nil)
-
-      def sanitize_sql_parameter: (untyped value) -> (untyped | nil)
+module ActiveRecord
+  module Associations
+    class Preloader
+      def initialize: (records: untyped, associations: untyped, ?scope: untyped, ?available_records: Array[untyped], ?associate_by_default: bool) -> void
     end
-
-    interface _Wrapable
-      def new: (**untyped options) -> query
-    end
-
-    module Wrap : _Wrapable
-      def wrap: (composable query_rel_or_data, **untyped options) -> query
-    end
-
-  end
-
-  class Enumerator
-    extend Forwardable
-
-    include Quo::Utilities::Callstack
-
-    def initialize: (Quo::Query query, ?transformer: ^(untyped, ?Integer) -> untyped) -> void
-
-    @query: Quo::Query
-
-    def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
-
-    private
-
-    attr_reader transformer: ^(untyped, ?Integer) -> untyped
-    attr_reader unwrapped: ActiveRecord::Relation
-
-    def transform_results: (untyped) -> untyped
   end
+end
 
+module Quo
+  VERSION: String
 
-  class Query
-    include Quo::Utilities::Callstack
-    extend Quo::Utilities::Compose
-    extend Quo::Utilities::Sanitize
-    extend Quo::Utilities::Wrap
-
-    def self.call: (**untyped options) -> untyped
-    def self.call!: (**untyped options) -> untyped
-    def self.description: (?String) -> (String | nil)
-    self.@description: String | nil
-
-    @scope: ActiveRecord::Relation | nil
-
-    attr_reader current_page: (Integer | nil)
-    attr_reader page_size: (Integer | nil)
-    attr_reader options: Hash[untyped, untyped]
-
-    def initialize: (**untyped options) -> void
-    def query: () -> composable
-    def compose: (composable right, ?joins: untyped?) -> Quo::MergedQuery
-    alias + compose
-
-    def copy: (**untyped options) -> query
-
-    def limit: (untyped limit) -> query
-    def order: (untyped options) -> query
-    def group: (*untyped options) -> query
-    def includes: (*untyped options) -> query
-    def preload: (*untyped options) -> query
-    def select: (*untyped options) -> query
-
-    def sum: (?untyped column_name) -> Numeric
-    def average: (untyped column_name) -> Numeric
-    def minimum: (untyped column_name) -> Numeric
-    def maximum: (untyped column_name) -> Numeric
-    def count: () -> Integer
-
-    alias total_count count
-
-    alias size count
-    def page_count: () -> Integer
-    def first: (*untyped args) -> untyped
-    def first!: (*untyped args) -> untyped
-    def last: (*untyped args) -> untyped
-    def to_a: () -> Array[untyped]
-    def to_eager: (?::Hash[untyped, untyped] more_opts) -> Quo::EagerQuery
-    alias load to_eager
-    def enumerator: () -> Quo::Enumerator
-
-    # Set a block used to transform data after query fetching
-    def transform: () ?{ () -> untyped } -> self
-
-    def exists?: () -> bool
-    def none?: () -> bool
-    alias empty? none?
-    def relation?: () -> bool
-    def eager?: () -> bool
-    def paged?: () -> bool
-
-    def model: () -> (untyped | nil)
-    def klass: () -> (untyped | nil)
-
-    def transform?: () -> bool
-    def to_sql: () -> (String | nil)
-    def unwrap: () -> query_like
-
-    private
-
-    def formatted_queries?: () -> bool
-    def trim_query: (String sql) -> String
-    def format_query: (String sql_str) -> String
-    def transformer: () -> (nil | ^(untyped) -> untyped)
-    def offset: () -> Integer
-    def configured_query: () -> ActiveRecord::Relation
-    def sanitised_page_size: () -> Integer
-    def query_with_logging: () -> ActiveRecord::Relation
-    def underlying_query: () -> ActiveRecord::Relation
-    def unwrap_relation: (composable query) -> ActiveRecord::Relation
-    def test_eager: (composable rel) -> bool
-    def test_relation: (composable rel) -> bool
-  end
-
-  class MergedQuery < Quo::Query
-    def initialize: (untyped options, ?untyped source_queries) -> void
-
-    def query: () -> composable
-
-    def to_s: () -> ::String
+  type query = Quo::Query
+  type queryOrRel = query | ActiveRecord::Relation
+  type enumerable = Object & Enumerable[untyped]
+  type relOrEnumerable = ActiveRecord::Relation | enumerable
+  type composable = query | relOrEnumerable
 
-    private
+  # 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]
 
-    def source_queries_left: () -> composable
-    def source_queries_right: () -> composable
-    attr_reader source_queries: Array[composable]
-    def operand_desc: (untyped operand) -> (nil | String)
+  interface _Logger
+    def info: (String) -> void
+    def error: (String) -> void
+    def debug: (String) -> void
   end
 
-  class EagerQuery < Quo::Query
-    def initialize: (**untyped options) -> void
-    def query: () -> enumerable
-    def relation?: () -> false
-    def eager?: () -> true
-    attr_reader collection: enumerable
-
-    private
+  class Configuration
+    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 preload_includes: (untyped records, ?untyped? preload) -> untyped
+    def initialize: () -> void
   end
+  attr_reader self.configuration: Configuration
 
-  class QueryComposer
-    def initialize: (composable left, composable right, ?untyped? joins) -> void
-    def compose: () -> Quo::MergedQuery
-
-    private
-
-    attr_reader left: composable
-    attr_reader right: composable
-    attr_reader joins: untyped
-
-    def merge: () -> (ActiveRecord::Relation | Array[untyped] | void)
-    def merged_options: () -> ::Hash[untyped, untyped]
-    def unwrap_relation: (composable) -> query_like
-    def relation_type?: (composable) -> bool
-    def apply_joins: (ActiveRecord::Relation left_rel, untyped joins) -> ActiveRecord::Relation
-    def both_relations?: (bool left_rel_type, bool right_rel_type) -> bool
-    def left_relation_right_eager?: (bool left_rel_type, bool right_rel_type) -> bool
-    def left_eager_right_relation?: (bool left_rel_type, bool right_rel_type) -> bool
-    def both_eager_loaded?: (bool left_rel_type, bool right_rel_type) -> bool
-
-    def raise_error: () -> void
-  end
+  def self.configure: () { (Configuration config) -> void } -> void
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quo
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-20 00:00:00.000000000 Z
+date: 2022-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,20 +66,31 @@ files:
 - Steepfile
 - lib/quo.rb
 - lib/quo/eager_query.rb
-- lib/quo/enumerator.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
 - lib/quo/utilities/sanitize.rb
 - lib/quo/utilities/wrap.rb
 - lib/quo/version.rb
+- lib/quo/wrapped_query.rb
 - lib/tasks/quo.rake
 - rbs_collection.yaml
 - sig/quo.rbs
+- sig/quo/eager_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
+- sig/quo/utilities/wrap.rbs
+- sig/quo/wrapped_query.rbs
 homepage: https://github.com/stevegeek/quo
 licenses:
 - MIT