quo 0.5.3 → 1.0.0.alpha1

data/lib/quo/query_composer.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Quo
-  class QueryComposer
-    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
-      Quo::MergedQuery.new(
-        merge_left_and_right,
-        left,
-        right,
-        **merged_options
-      )
-    end
-
-    private
-
-    attr_reader :left, :right, :joins, :unwrapped_left, :unwrapped_right
-
-    def left_relation?
-      @left_relation
-    end
-
-    def right_relation?
-      @right_relation
-    end
-
-    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
-
-    def merged_options
-      return left.options.merge(right.options) if left.is_a?(Quo::Query) && right.is_a?(Quo::Query)
-      return left.options if left.is_a?(Quo::Query)
-      return right.options if right.is_a?(Quo::Query)
-      {}
-    end
-
-    def unwrap_relation(query)
-      query.is_a?(Quo::Query) ? query.unwrap : query
-    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/railtie.rb

@@ -1,7 +0,0 @@
-module Quo
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load "tasks/quo.rake"
-    end
-  end
-end

data/lib/quo/utilities/callstack.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Quo
-  module Utilities
-    module Callstack
-      def debug_callstack
-        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 + "/", "") }
-        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
-  end
-end

data/lib/quo/utilities/compose.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Quo
-  module Utilities
-    # 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.
-    module Compose
-      def compose(query1, query2, joins: nil)
-        Quo::QueryComposer.new(query1, query2, joins).compose
-      end
-
-      def composable_with?(query)
-        query.is_a?(Quo::Query) || query.is_a?(ActiveRecord::Relation)
-      end
-    end
-  end
-end

data/lib/quo/utilities/sanitize.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Quo
-  module Utilities
-    module Sanitize
-      def sanitize_sql_for_conditions(conditions)
-        ActiveRecord::Base.sanitize_sql_for_conditions(conditions)
-      end
-
-      def sanitize_sql_string(string)
-        sanitize_sql_for_conditions(["'%s'", string])
-      end
-
-      def sanitize_sql_parameter(value)
-        sanitize_sql_for_conditions(["?", value])
-      end
-    end
-  end
-end

data/lib/quo/utilities/wrap.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Quo
-  module Utilities
-    # Wrap a ActiveRecord::Relation or data collection in a Query.
-    #
-    # If the passed in object is already a Query object then just return it or copy it if new options are passed in.
-    # Otherwise if a Relation wrap it in a new Query object or else in an EagerQuery .
-    module Wrap
-      def wrap(query_rel_or_data, **options)
-        if query_rel_or_data.is_a? Quo::Query
-          return options.present? ? query_rel_or_data.copy(**options) : query_rel_or_data
-        end
-
-        if query_rel_or_data.is_a? ActiveRecord::Relation
-          Quo::WrappedQuery.new(query_rel_or_data, **options)
-        else
-          Quo::LoadedQuery.new(query_rel_or_data, **options)
-        end
-      end
-    end
-  end
-end

data/lib/quo/wrapped_query.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Quo
-  class WrappedQuery < Quo::Query
-    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
-  end
-end

data/sig/quo/eager_query.rbs

@@ -1,15 +0,0 @@
-module Quo
-  class EagerQuery < Quo::Query
-    def collection: () -> loadedQueryOrEnumerable
-    def query: () -> loadedQueryOrEnumerable
-
-    def relation?: () -> false
-    def eager?: () -> true
-
-    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

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

data/sig/quo/merged_query.rbs

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

data/sig/quo/query.rbs

@@ -1,83 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

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

data/sig/quo/utilities/compose.rbs

@@ -1,8 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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,41 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      def initialize: (records: untyped, associations: untyped, ?scope: untyped, ?available_records: Array[untyped], ?associate_by_default: bool) -> void
-    end
-  end
-end
-
-module Quo
-  VERSION: String
-
-  type query = Quo::Query
-  type queryOrRel = query | ActiveRecord::Relation
-  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
-    def debug: (String) -> void
-  end
-
-  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 initialize: () -> void
-  end
-  attr_reader self.configuration: Configuration
-
-  def self.configure: () { (Configuration config) -> void } -> void
-end