quo 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88c53b53f941762022f3b012abe6fe3e977e125c562f771aca630c28a087c13e
-  data.tar.gz: dfdeb96c25d7a3e06fef0524b6c77be0cff1ae94368b39f17d6a3a3c8400e181
+  metadata.gz: 61bf7495c0092bf641ff6e85bed8dc0073ea61e15a5292f0825f50eca4348a92
+  data.tar.gz: c10cc10dfe8ce323e4395640604a1c6358333bb7ea26b1c109d43eee67ed2d73
 SHA512:
-  metadata.gz: 281cad72c46e498166255f5f973fd09dfec37d309e406bccbfe27cd8ae80cfd95321f2dace615d0be36db8b9b9f38b3257e7e2acf3fd81c7f05788daa48d8e9d
-  data.tar.gz: f09f1213677fb08bc45ac5c27262afc0692555fe24a0da0547ad37e15661019d92d9e49f7eda7651c9c518334cca2f1195a38e0c7d60b61384240f34046032d6
+  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

@@ -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,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

@@ -4,18 +4,18 @@ module Quo
   class MergedQuery < Quo::Query
     class << self
       def call(**options)
-        build_from_options(**options).first
+        build_from_options(options).first
       end
 
       def call!(**options)
-        build_from_options(**options).first!
+        build_from_options(options).first!
       end
 
-      def build_from_options(**options)
+      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
+        raise ArgumentError, "MergedQuery needs the merged result and operands" unless merged_query && left && right
         new(merged_query, left, right, **options)
       end
     end

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,56 @@ 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
+    # Some convenience methods for working with results
     delegate :each,
       :map,
       :flat_map,
@@ -151,8 +150,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 +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
 
@@ -238,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,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,26 @@ 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 + unwrapped_right.to_a
+      else
+        unwrapped_left + unwrapped_right
       end
     end
 
@@ -49,16 +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_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::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

@@ -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::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.1"
+  VERSION = "0.4.0"
 end

data/lib/quo/wrapped_query.rb

@@ -13,7 +13,7 @@ module Quo
 
       def build_from_options(**options)
         query = options[:wrapped_query]
-        raise ArgumentError "WrappedQuery needs a scope" unless query
+        raise ArgumentError, "WrappedQuery needs a scope" unless query
         new(query, **options)
       end
     end

data/lib/quo.rb

@@ -7,7 +7,7 @@ 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
@@ -22,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

@@ -1,13 +1,18 @@
 module Quo
   class EagerQuery < Quo::Query
-    def initialize: (**untyped options) -> void
+    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
-    attr_reader collection: enumerable
 
     private
 
+    attr_reader collection: enumerable
+
     def preload_includes: (untyped records, ?untyped? preload) -> untyped
   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,14 @@ 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 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 +29,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.4.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,11 @@ 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
@@ -82,10 +82,10 @@ files:
 - 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/results.rbs
 - sig/quo/utilities/callstack.rbs
 - sig/quo/utilities/compose.rbs
 - sig/quo/utilities/sanitize.rbs