quo 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f8a79b64bd0db1439df6ffcfb820786ed082405bb24d56ac2ac08cb47c052b7
-  data.tar.gz: 0b46427745aa9433130c4ec495cf2c9d79bff517b00ea99f17029b3a2714b604
+  metadata.gz: 88c53b53f941762022f3b012abe6fe3e977e125c562f771aca630c28a087c13e
+  data.tar.gz: dfdeb96c25d7a3e06fef0524b6c77be0cff1ae94368b39f17d6a3a3c8400e181
 SHA512:
-  metadata.gz: 514f649e606616d7a46de0c409b4c3f635c11fe900f179e0f94952a594adb49877e82ced68e9541e2dd398e2b0e35e9ea8ff1c4995701ed8f30361de48f8ae78
-  data.tar.gz: 7562f9cfc712ac473e6a32bb1c9f5b9e88123fb0abaa696f29dbf24e90dcedaaf716d42e0cd8bf6b8a5594a6f888fbf20f3e2b665ff9dda108ddc7ededfbe9a9
+  metadata.gz: 281cad72c46e498166255f5f973fd09dfec37d309e406bccbfe27cd8ae80cfd95321f2dace615d0be36db8b9b9f38b3257e7e2acf3fd81c7f05788daa48d8e9d
+  data.tar.gz: f09f1213677fb08bc45ac5c27262afc0692555fe24a0da0547ad37e15661019d92d9e49f7eda7651c9c518334cca2f1195a38e0c7d60b61384240f34046032d6

data/Steepfile

@@ -27,8 +27,10 @@
 # end
 
 target :lib do
-  check "lib/quo"
+  check "lib"
   signature "sig"
+  ignore "lib/quo/rspec/*.rb"
+  ignore "lib/tasks/*"
 
   library "forwardable"
 end

data/lib/quo/enumerator.rb

@@ -21,30 +21,36 @@ 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.call(transformed, *block_args[1..])
+      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)
+          raw = unwrapped.send(method, *args, **kwargs)
           return raw if raw.is_a?(Quo::Enumerator) || raw.is_a?(::Enumerator)
           transform_results(raw)
         end
@@ -62,7 +68,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/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

@@ -29,19 +29,16 @@ module Quo
       @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])
     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
 
     # Combine (compose) this query object with another composeable entity, see notes for `.compose` above.
     # Compose is aliased as `+`. Can optionally take `joins()` parameters to perform a joins before the merge
-    def compose(right, joins = nil)
+    def compose(right, joins: nil)
       Quo::QueryComposer.new(self, right, joins).compose
     end
 
@@ -147,7 +144,15 @@ module Quo
     end
 
     # Some convenience methods for iterating over the results
-    delegate :each, :map, :flat_map, :reduce, :reject, :filter, to: :enumerator
+    delegate :each,
+      :map,
+      :flat_map,
+      :reduce,
+      :reject,
+      :filter,
+      :find,
+      :each_with_object,
+      to: :enumerator
 
     # 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,7 @@ module Quo
 
     def offset
       per_page = sanitised_page_size
-      page = current_page.positive? ? current_page : 1
+      page = current_page&.positive? ? current_page : 1
       per_page * (page - 1)
     end
 
@@ -252,7 +257,6 @@ module Quo
             rel = rel.limit(@options[:limit]) if @options[:limit].present?
             rel = rel.preload(@options[:preload]) if @options[:preload].present?
             rel = rel.includes(@options[:includes]) if @options[:includes].present?
-            rel = rel.joins(@options[:joins]) if @options[:joins].present?
             rel = rel.select(@options[:select]) if @options[:select].present?
           end
           rel

data/lib/quo/query_composer.rb

@@ -9,9 +9,11 @@ module Quo
     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
 
@@ -19,22 +21,20 @@ module Quo
 
     attr_reader :left, :right, :joins
 
-    def merge
+    def merge_left_and_right
       left_rel = unwrap_relation(left)
       right_rel = unwrap_relation(right)
-      left_type = relation_type?(left)
-      right_type = relation_type?(right)
+      left_is_relation = relation_type?(left)
+      right_is_relation = relation_type?(right)
 
-      if both_relations?(left_type, right_type)
+      if left_is_relation && right_is_relation
         apply_joins(left_rel, joins).merge(right_rel)
-      elsif left_relation_right_eager?(left_type, right_type)
+      elsif left_is_relation && !right_is_relation
         left_rel.to_a + right_rel
-      elsif left_eager_right_relation?(left_type, right_type) && left_rel.respond_to?(:+)
+      elsif !left_is_relation && right_is_relation
         left_rel + right_rel.to_a
-      elsif both_eager_loaded?(left_type, right_type) && left_rel.respond_to?(:+)
+      elsif !left_is_relation && !right_is_relation
         left_rel + right_rel
-      else
-        raise_error
       end
     end
 
@@ -58,29 +58,7 @@ module Quo
     end
 
     def apply_joins(left_rel, joins)
-      joins.present? ? left_rel.joins(joins.to_sym) : 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
-    end
-
-    def both_eager_loaded?(left_rel_type, right_rel_type)
-      !left_rel_type && !right_rel_type
-    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."
+      joins.present? ? left_rel.joins(joins) : left_rel
     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 stack.size > callstack_size
         Quo.configuration.logger&.info(message)
       end
     end

data/lib/quo/utilities/compose.rb

@@ -6,7 +6,7 @@ module Quo
     # These can be Quo::Query, Quo::MergedQuery, Quo::EagerQuery and ActiveRecord::Relations.
     # See the `README.md` docs for more details.
     module Compose
-      def compose(query1, query2, joins = nil)
+      def compose(query1, query2, joins: nil)
         Quo::QueryComposer.new(query1, query2, joins).compose
       end
 

data/lib/quo/utilities/wrap.rb

@@ -13,7 +13,7 @@ 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))
         end

data/lib/quo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quo
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 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,6 +5,7 @@ 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"
 

data/sig/quo/eager_query.rbs

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

data/sig/quo/enumerator.rbs

@@ -0,0 +1,22 @@
+module Quo
+  class Enumerator
+    extend Forwardable
+
+    include Quo::Utilities::Callstack
+
+    def initialize: (Quo::Query query, ?transformer: (^(untyped, ?Integer) -> untyped)?) -> void
+
+    @query: Quo::Query
+
+    def group_by: -> 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/merged_query.rbs

@@ -0,0 +1,17 @@
+module Quo
+  class MergedQuery < Quo::Query
+    def initialize: (relOrEnumerable merged, composable left, composable right, **untyped options) -> void
+
+    @merged_query: relOrEnumerable
+
+    def query: () -> composable
+
+    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: (*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: () -> ActiveRecord::Relation
+
+    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: (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,18 @@
+module Quo
+  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_left_and_right: () -> (ActiveRecord::Relation | Array[untyped])
+    def merged_options: () -> ::Hash[untyped, untyped]
+    def unwrap_relation: (composable) -> relOrEnumerable
+    def relation_type?: (composable) -> bool
+    def apply_joins: (ActiveRecord::Relation left_rel, untyped joins) -> ActiveRecord::Relation
+  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
+    @wrapped_query:  ActiveRecord::Relation
+
+    def self.build_from_options: (**untyped options) -> WrappedQuery
+
+    def initialize: (ActiveRecord::Relation query, **untyped options) -> void
+
+    def query: () -> ActiveRecord::Relation
+  end
+end

data/sig/quo.rbs

@@ -1,205 +1,35 @@
-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, ?untyped? joins) -> 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, ?untyped? joins) -> 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
-
-    private
+  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 relOrEnumerable = ActiveRecord::Relation | enumerable
+  type composable = query | relOrEnumerable
 
-    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?
 
-    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.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-20 00:00:00.000000000 Z
+date: 2022-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -77,9 +77,20 @@ files:
 - 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/enumerator.rbs
+- sig/quo/merged_query.rbs
+- sig/quo/query.rbs
+- sig/quo/query_composer.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