miscellany 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bbb29d549980dccc437f08518643092d0f77cbac6cbfa73f0f4dc728cd9586a
-  data.tar.gz: b8fe8463a2ffa603036803d25a34a815087a52829ae5a2e9e1f0360c27e6f04b
+  metadata.gz: 735168167aa19b15e9b56db6a20025dc7374526319744526d08238577caf4983
+  data.tar.gz: c4df4a5c364cb04632ab017f2e7393d9f8dc5f5228ba7da41303d8a7595606ea
 SHA512:
-  metadata.gz: 5b0fb52043a3d4bbfc1bf503661f1162b370b19a6b03b9fcca642656ac1008b2920b3858b680023c0ce986b10c9646d5ee1d419e2244f337811c2dc9ec1c9233
-  data.tar.gz: f634b8330eb9f290cc5e76eeebf14e3cf2178a046ddade0230c2399642528e8976cdb8b6abf6e998a199e2f6696db4849ec66e72124dcd0b9f960199d89c85cc
+  metadata.gz: 94f572010617e6295e19d0167c05cb59b683496f87502a83bb53f91c3303fb11cfb65a7c7f0a2c85c254896700c22bc9d441e02ebb09a93741cb4867e13596a3
+  data.tar.gz: 8064920b660a82326a0172ac4828c95bf072b65ec3e9e7fe87dcb842ace9ec4a11072e0095eb73e4247c8d83e5e412bd4bd62947b35edefb9b82576b1a5e9423

data/app/views/miscellany/_slice.json.jbuilder

@@ -0,0 +1,5 @@
+json.merge!(slice)
+
+json.items slice[:items] do |item|
+  block.call(item)
+end

data/lib/miscellany/active_record/arbitrary_prefetch.rb

@@ -80,7 +80,7 @@ module Miscellany
           pfc = PrefetcherContext.new(model, opts)
           pfc.link_models(records)
 
-          unless defined?(Goldiloader)
+          unless defined?(Goldiloader) && Goldiloader.enabled?
             if PRE_RAILS_6_2
               ::ActiveRecord::Associations::Preloader.new.preload(records, [opts[:attribute]])
             else
@@ -139,18 +139,31 @@ module Miscellany
     end
 
     module ActiveRecordPreloaderPatch
-      if ACTIVE_RECORD_VERSION >= ::Gem::Version.new('6.0.0')
-        def grouped_records(association, records, polymorphic_parent)
-          h = {}
-          records.each do |record|
-            next unless record
-            reflection = record.class._reflect_on_association(association)
-            reflection ||= record.association(association)&.reflection rescue nil
-            next if polymorphic_parent && !reflection || !record.association(association).klass
-            (h[reflection] ||= []) << record
-          end
-          h
+      def grouped_records(association, records, polymorphic_parent)
+        h = {}
+        records.each do |record|
+          next unless record
+          reflection = record.class._reflect_on_association(association)
+          reflection ||= record.association(association)&.reflection rescue nil
+          next if polymorphic_parent && !reflection || !record.association(association).klass
+          (h[reflection] ||= []) << record
+        end
+        h
+      end
+    end
+
+    module ActiveRecordPreloaderBranchPatch
+      def grouped_records
+        h = {}
+        polymorphic_parent = !root? && parent.polymorphic?
+        source_records.each do |record|
+          next unless record
+          reflection = record.class._reflect_on_association(association)
+          reflection ||= record.association(association)&.reflection rescue nil
+          next if polymorphic_parent && !reflection || !record.association(association).klass
+          (h[reflection] ||= []) << record
         end
+        h
       end
     end
 
@@ -167,7 +180,11 @@ module Miscellany
       ::ActiveRecord::Relation.prepend(ActiveRecordRelationPatch)
       ::ActiveRecord::Relation::Merger.prepend(ActiveRecordMergerPatch)
 
-      ::ActiveRecord::Associations::Preloader.prepend(ActiveRecordPreloaderPatch)
+      if ACTIVE_RECORD_VERSION >= ::Gem::Version.new('7.0.0')
+        ::ActiveRecord::Associations::Preloader::Branch.prepend(ActiveRecordPreloaderBranchPatch)
+      elsif ACTIVE_RECORD_VERSION >= ::Gem::Version.new('6.0.0')
+        ::ActiveRecord::Associations::Preloader.prepend(ActiveRecordPreloaderPatch)
+      end
 
       ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecordReflectionPatch)
 

data/lib/miscellany/active_record/batch_matcher.rb

@@ -88,7 +88,6 @@ module Miscellany
       end
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def resolve_row_value(row, resolver)
       found_values = []
       @columns.each do |c|
@@ -103,18 +102,16 @@ module Miscellany
       end
 
       if @options[:validate_all] && found_values.uniq.count > 1
-        raise ActiveRecord::RecordNotFound, "multiple of [#{@columns.pluck(2).join(', ')}] were supplied, but resolved to different objects" # rubocop:disable Metrics/LineLength
+        raise ActiveRecord::RecordNotFound, "multiple of [#{@columns.pluck(2).join(', ')}] were supplied, but resolved to different objects"
       end
 
       found_values[0]
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
     def get_column_map(column, row, via_column: nil)
       base_query = get_base_query(row)
       clazz = as_class(base_query)
-      raise ActiveRecord::RecordNotFound, "invalid #{@options[:polymorphic_on]}: #{row[@options[:polymorphic_on]]}" if clazz.nil? # rubocop:disable Metrics/LineLength
+      raise ActiveRecord::RecordNotFound, "invalid #{@options[:polymorphic_on]}: #{row[@options[:polymorphic_on]]}" if clazz.nil?
 
       load_column(clazz, column, via_column) do
         relevant_rows = rows
@@ -128,10 +125,9 @@ module Miscellany
         loaded_hash = load_column_data(column, base_query, row_keys)
 
         # In :lazy mode, the corresponding primary_column data is loaded with each column
-        load_column_data(primary_column, base_query, loaded_hash.values) if @options[:mode] == :lazy && column != @primary_column # rubocop:disable Metrics/LineLength
+        load_column_data(primary_column, base_query, loaded_hash.values) if @options[:mode] == :lazy && column != @primary_column
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
     def load_column_data(column, base_query, keys)
       data = if column == @primary_column

data/lib/miscellany/active_record/complex_query.rb

@@ -0,0 +1,141 @@
+module Miscellany
+  class ComplexQuery
+    attr_reader :options
+
+    def initialize(options)
+      @options = options.with_indifferent_access
+    end
+
+    def count
+      res = ActiveRecord::Base.connection.execute(build_count_query)
+      res[0].to_h.values[0]
+    end
+
+    def page(page, page_size: 40)
+      total_items = count
+
+      page = page.to_i || 1
+      page = 1 if page < 1
+      page_size = page_size.to_i
+      page_size = 10 if page_size < 2
+      offset = (page - 1) * page_size
+
+      psql = sql
+      psql += " LIMIT #{page_size} OFFSET #{offset}"
+
+      records = ActiveRecord::Base.connection.exec_query(psql).to_a
+      augment_batch(records)
+
+      {
+        page: page,
+        total_count: total_items,
+        page_count: (total_items.to_f / page_size).ceil,
+        page_size: page_size,
+        sort: parsed_sort&.map do |s|
+          "#{s[:key] || s[:column]} #{s[:order] || 'ASC'}"
+        end&.join(', '),
+        records: records,
+      }
+    end
+
+    def slice(start, length, raw_sort: nil)
+      psql = build_query
+      if raw_sort.present?
+        psql += " ORDER BY #{raw_sort}"
+      elsif sort_sql.present?
+        psql += " ORDER BY #{sort_sql}"
+      end
+      psql += " LIMIT #{length} OFFSET #{start}"
+      records = ActiveRecord::Base.connection.exec_query(psql).to_a
+      augment_batch(records)
+      records
+    end
+
+    def in_batches(of: 1000)
+      conn = ActiveRecord::Base.connection
+      tbl = "#{self.class.name.split('::').last.underscore}_#{SecureRandom.hex[0..10]}"
+
+      conn.execute("CREATE TEMP TABLE #{tbl} AS (#{sql})")
+
+      offset = 0
+      loop do
+        batch = ActiveRecord::Base.connection.exec_query(
+          "SELECT * FROM #{tbl} LIMIT #{batch_size} OFFSET #{offset}",
+        )
+        augment_batch(batch)
+        yield batch
+        offset += batch_size
+        break if batch.empty?
+      end
+    ensure
+      conn.execute("DROP TABLE IF EXISTS #{tbl}")
+    end
+
+    def find_each(batch_size: 1000, &block)
+      in_batches(of: batch_size) do |batch|
+        batch.each(&block)
+      end
+    end
+
+    def sql
+      sql = build_query
+      sql += " ORDER BY #{sort_sql}" if sort_sql.present?
+      sql
+    end
+
+    def valid_sort?(sort)
+      sort_parser.valid?(sort)
+      return false unless sort.present?
+    end
+
+    protected
+
+    def augment_batch(records); end
+
+    def build_query; end
+
+    def build_count_query; end
+
+    def sort_sql
+      return options[:raw_sort] if options[:raw_sort].present? && !options[:raw_sort].is_a?(ActionController::Parameters)
+      return nil unless options[:sort].present?
+
+      Miscellany::SortLang.sqlize(parsed_sort)
+    end
+
+    def parsed_sort
+      return nil if options[:raw_sort].present?
+      @parsed_sort ||= sort_parser.parse(options[:sort])
+    end
+
+    def valid_sorts
+      return self.class::SORTABLE_COLUMNS.with_indifferent_access if defined?(self.class::SORTABLE_COLUMNS)
+    end
+
+    def sort_parser
+      @sort_parser ||= Miscellany::SortLang::Parser.new(valid_sorts || {})
+    end
+
+    def sanitize_sql(*args)
+      ApplicationRecord.sanitize_sql(args)
+    end
+
+    def filters
+      options[:filters] || {}
+    end
+
+    def join_filters(*filters)
+      filters.flatten.select(&:present?).map { |q| "(#{q})" }.join(' AND ').presence || '1=1'
+    end
+
+    def date_filter(column, key)
+      if filters["#{key}_end"].present? && filters["#{key}_start"].present?
+        "#{column} BETWEEN '#{DateTime.parse(filters["#{key}_start"]).beginning_of_day}' AND '#{DateTime.parse(filters["#{key}_end"]).end_of_day}'"
+      elsif filters["#{key}_start"].present?
+        "#{column} >= '#{DateTime.parse(filters["#{key}_start"]).beginning_of_day}'"
+      elsif filters["#{key}_end"].present?
+        "#{column} <= '#{DateTime.parse(filters["#{key}_end"]).end_of_day}'"
+      end
+    end
+  end
+end

data/lib/miscellany/active_record/goldiload_value.rb

@@ -1,5 +1,5 @@
 module Miscellany
-  module GoldiloadValue # TODO Write Specs
+  module GoldiloadValue
     attr_accessor :goldi_values
 
     def goldiload_value(key, &blk)

data/lib/miscellany/controller/sliced_response.rb

@@ -6,11 +6,11 @@ module Miscellany
 
     include HttpErrorHandling
 
+    # Deprecated
     def slice_results(queryset, **kwargs)
       @sliced_data = sliced_json(queryset, **kwargs) { |x| x }
     end
 
-    # rubocop:disable Metrics/ParameterLists
     def sliced_json(
       queryset, slice_params = params,
       max_size: 50, default_size: 25, allow_all: false,
@@ -19,7 +19,12 @@ module Miscellany
     )
       valid_sorts ||= queryset.column_names if queryset.respond_to?(:column_names)
       valid_sorts ||= []
-      normalized_sorts = normalize_sort_options(valid_sorts, default: default_sort)
+
+      if !valid_sorts.present? && defined?(Miscellany::ComplexQuery) && queryset.is_a?(Miscellany::ComplexQuery)
+        sort_parser = queryset.send(:sort_parser)
+      else
+        sort_parser = Miscellany::SortLang::Parser.new(valid_sorts, default: default_sort)
+      end
 
       slice = Slice.build(
         queryset, slice_params,
@@ -28,18 +33,22 @@ module Miscellany
         max_size: max_size,
         default_size: default_size,
         allow_all: allow_all,
-        valid_sorts: normalized_sorts,
+        sort_parser: sort_parser,
       )
 
       slice.render_json
     end
-    # rubocop:enable Metrics/ParameterLists
 
+    # Format the given data as a JSON slice, but doesn't expect slicing parameters
     def as_sliced_json(queryset, slice: nil, total_count: nil, &blk)
       slice = Slice.build(queryset, slice, total_count: total_count, item_transformer: blk)
       slice.render_json
     end
 
+    # Wrap a Bearcat API instance in a slicing API
+    # bearcat_as_sliced_json() do |params|
+    #   bearcat_instance.courses(params)
+    # end
     def bearcat_as_sliced_json(*args, transform: nil, **kwargs, &blk)
       bearcat_exec = ->(slice) {
         response = blk.call({
@@ -56,49 +65,6 @@ module Miscellany
 
     private
 
-    def normalize_sort_options(sorts, default: nil)
-      norm_sorts = { }
-
-      sorts.each do |s|
-        if s.is_a?(Hash)
-          s.each do |k,v|
-            sort_hash = normalize_sort(v, key: k)
-            norm_sorts[k] = sort_hash
-          end
-        else
-          sort_hash = normalize_sort(s)
-          norm_sorts[sort_hash[:column]] = sort_hash
-          # default ||= sort_hash
-        end
-      end
-
-      if default.present?
-        norm_default = normalize_sort(default)
-        reference = norm_sorts[norm_default[:key].to_s] || norm_default
-        norm_sorts[:default] = {
-          key: reference[:key],
-          column: reference[:column],
-          order: norm_default[:order] || reference[:order],
-        }
-      end
-
-      norm_sorts
-    end
-
-    def normalize_sort(sort, key: nil)
-      sort = sort.to_s if sort.is_a?(Symbol)
-      if sort.is_a?(Array)
-        sort = { **normalize_sort(sort[0]), **(sort[1] || {}) }
-      elsif sort.is_a?(String)
-        m = sort.match(/^([\w\.]+)(?: (ASC|DESC)(!?))?$/)
-        sort = { column: m[1], order: m[2], force_order: m[3].present? }.compact
-      elsif sort.is_a?(Proc)
-        sort = { column: sort }
-      end
-      sort[:key] = key || sort[:column]
-      sort.compact
-    end
-
     class Slice
       attr_accessor :slice_start, :slice_end
       attr_accessor :page_size, :page_number
@@ -112,7 +78,6 @@ module Miscellany
         @options = options
       end
 
-      # rubocop:disable Metrics/PerceivedComplexity
       def self.build(queryset, arg, options={})
         new(queryset, options).tap do |slice|
           if arg.is_a?(Array)
@@ -132,7 +97,11 @@ module Miscellany
               slice_bounds = [(page_number - 1) * page_size, page_number * page_size]
             end
 
-            slice[:sort] = parse_and_validate_sorts(arg[:sort], options[:valid_sorts])
+            begin
+              slice[:sort] = options[:sort_parser]&.parse(arg[:sort], ignore_errors: true)
+            rescue Miscellany::SortLang::Parser::SortParsingError => e
+              raise HttpErrorHandling::HttpError, message: e.message
+            end
           end
 
           if slice_bounds.present?
@@ -149,7 +118,6 @@ module Miscellany
           end
         end
       end
-      # rubocop:enable Metrics/PerceivedComplexity
 
       def [](key)
         send(key)
@@ -194,27 +162,6 @@ module Miscellany
       end
       def rendered_json; render_json; end
 
-      def self.parse_and_validate_sorts(sortstr, sorts_map, silent_failure: true)
-        (sortstr || '').split(',').map do |s|
-          m = s.strip.match(/^(\w+)(?: (ASC|DESC))?$/)
-
-          if m.nil?
-            next if silent_failure
-            raise HttpErrorHandling::HttpError, message: 'Could not parse sort parameter'
-          end
-
-          resolved_sort = sorts_map[m[1]]
-          unless resolved_sort.present?
-            next if silent_failure
-            raise HttpErrorHandling::HttpError, message: 'Could not parse sort parameter'
-          end
-
-          sort = resolved_sort.dup
-          sort[:order] = m[2] if m[2].present? && !sort[:force_order]
-          sort
-        end.compact.presence || [sorts_map[:default]].compact
-      end
-
       private
 
       def rendered_items
@@ -229,6 +176,8 @@ module Miscellany
             items.except(:select).count
           elsif items.respond_to?(:count)
             items.count
+          elsif defined?(Miscellany::ComplexQuery) && items.is_a?(Miscellany::ComplexQuery)
+            items.count
           else
             nil
           end
@@ -249,7 +198,12 @@ module Miscellany
           elsif items.is_a?(ActiveRecord::Relation)
             offset, limit = slice_bounds
             limit -= offset unless limit.nil?
-            apply_ar_sort(items).limit(limit).offset(offset)
+            items.order(Arel.sql(sort_sql)).limit(limit).offset(offset).to_a
+          elsif defined?(Miscellany::ComplexQuery) && items.is_a?(Miscellany::ComplexQuery)
+            offset, limit = slice_bounds
+            limit -= offset unless limit.nil?
+            query = items.send(:build_query)
+            items.slice(offset, limit, raw_sort: sort_sql)
           end
         end
       end
@@ -258,43 +212,15 @@ module Miscellany
         [slice_start, slice_end == -1 ? nil : slice_end]
       end
 
-      def apply_ar_sort(qset)
-        if sort.present?
-          sorts = [ *Array(self.sort) ]
-          sorts << options[:valid_sorts][:default] if options.dig(:valid_sorts, :default).present?
+      def sort_sql
+        sorts = [ *Array(self.sort) ]
+        sorts << options[:sort_parser]&.default
+        sorts.compact!
 
-          sorts.reduce(qset) do |qset, sort|
-            order = sort[:order] || 'ASC'
-            if sort[:column].is_a?(Proc)
-              sort[:column].call(qset, order)
-            else
-              desired_nulls = (sort[:nulls] || :low).to_s.downcase.to_sym
-              nulls = case desired_nulls
-              when :last
-                'LAST'
-              when :first
-                'FIRST'
-              else
-                (desired_nulls == :high) == (order.to_s.upcase == 'DESC') ? 'FIRST' : 'LAST'
-              end
-              qset.order("#{sort[:column]} #{order} NULLS #{nulls}")
-            end
-          end
-        else
-          qset
-        end
-      end
-    end
+        return nil unless sorts.present?
 
-    module JbuilderTemplateExt
-      def partial!(*args, **kwargs, &blk)
-        kwargs[:block] = blk if blk.present?
-        super(*args, **kwargs)
+        Miscellany::SortLang.sqlize(sorts)
       end
     end
-
-    def self.install_extensions
-      ::JbuilderTemplate.prepend JbuilderTemplateExt
-    end
   end
 end

data/lib/miscellany/jbuilder_partial_block.rb

@@ -0,0 +1,26 @@
+module Miscellany
+  module Extensions
+    module JBuilder
+
+      # Enables passing blocks to JBuilder `partial!`
+      # When a block is given, it will be made available as `block` in the partial
+      module JbuilderTemplateExt
+        def partial!(*args, **kwargs, &blk)
+          kwargs[:block] = blk if blk.present?
+          super(*args, **kwargs)
+        end
+      end
+
+      def self.install
+        ::JbuilderTemplate.prepend JbuilderTemplateExt
+      end
+
+      begin
+        require 'jbuilder'
+      rescue LoadError
+      end
+
+      install if defined?(::JbuilderTemplate)
+    end
+  end
+end

data/lib/miscellany/sort_lang.rb

@@ -0,0 +1,121 @@
+module Miscellany
+  module SortLang
+
+    # Normalized Format: {
+    #   key: string,
+    #   column: string,
+    #   order: 'DESC' | 'ASC',
+    #   force_order?: boolean, # Prevent overriding order
+    #   nulls?: 'high' | 'low' | 'first' | 'last',
+    # }
+    def self.normalize_sort(sort, key: nil)
+      sort = sort.to_s if sort.is_a?(Symbol)
+      if sort.is_a?(Array)
+        sort = { **normalize_sort(sort[0]), **(sort[1] || {}) }
+      elsif sort.is_a?(String)
+        m = sort.match(/^([\w\.]+)(?: (ASC|DESC)(!?))?$/)
+        sort = { column: m[1], order: m[2], force_order: m[3].present? }.compact
+      elsif sort.is_a?(Proc)
+        sort = { column: sort }
+      end
+      sort[:key] = key || sort[:column]
+      sort.compact
+    end
+
+    def self.sqlize(sorts)
+      sorts.map do |sort|
+        order = sort[:order] || 'ASC'
+        if sort[:column].is_a?(Proc)
+          sort[:column].call(qset, order)
+        else
+          desired_nulls = (sort[:nulls] || :low).to_s.downcase.to_sym
+          nulls = case desired_nulls
+          when :last
+            'LAST'
+          when :first
+            'FIRST'
+          else
+            (desired_nulls == :high) == (order.to_s.upcase == 'DESC') ? 'FIRST' : 'LAST'
+          end
+          "#{sort[:column]} #{order} NULLS #{nulls}"
+        end
+      end.join(', ')
+    end
+
+    class Parser
+      class SortParsingError < StandardError; end
+
+      def initialize(valid_sorts, default: nil)
+        @sorts_map = normalize_sort_options(valid_sorts, default: default)
+      end
+
+      def default
+        @sorts_map[:default]
+      end
+
+      def valid?(sortstr)
+        parse(sortstr, ignore_errors: false)
+        true
+      rescue SortParsingError
+        false
+      end
+
+      def parse(sortstr, ignore_errors: true)
+        (sortstr || '').split(',').map do |s|
+          m = s.strip.match(/^(\w+)(?: (ASC|DESC))?$/)
+
+          if m.nil?
+            next if ignore_errors
+            raise SortParsingError, message: 'Could not parse sort parameter'
+          end
+
+          resolved_sort = @sorts_map[m[1]]
+          unless resolved_sort.present?
+            next if ignore_errors
+            raise SortParsingError, message: 'Could not parse sort parameter'
+          end
+
+          sort = resolved_sort.dup
+          sort[:order] = m[2] if m[2].present? && !sort[:force_order]
+          sort
+        end.compact.presence
+      end
+
+      protected
+
+      def normalize_sort_options(sorts, default: nil)
+        norm_sorts = { }
+
+        sorts.each do |s|
+          if s.is_a?(Hash)
+            s.each do |k,v|
+              sort_hash = normalize_sort(v, key: k)
+              norm_sorts[k] = sort_hash
+            end
+          else
+            sort_hash = normalize_sort(s)
+            norm_sorts[sort_hash[:column]] = sort_hash
+            # default ||= sort_hash
+          end
+        end
+
+        if default.present?
+          norm_default = normalize_sort(default)
+          reference = norm_sorts[norm_default[:key].to_s] || norm_default
+          norm_sorts[:default] = {
+            key: reference[:key],
+            column: reference[:column],
+            order: norm_default[:order] || reference[:order],
+          }
+        end
+
+        norm_sorts
+      end
+
+      def normalize_sort(*args, **kwargs)
+        SortLang.normalize_sort(*args, **kwargs)
+      end
+    end
+
+  end
+end

data/lib/miscellany/version.rb

@@ -1,3 +1,3 @@
 module Miscellany
-  VERSION = "0.1.12".freeze
+  VERSION = "0.1.14".freeze
 end

data/miscellany.gemspec

@@ -31,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'sqlite3', '~> 1.3'
   spec.add_development_dependency 'with_model'
+  spec.add_development_dependency 'goldiloader'
 end

data/spec/miscellany/arbitrary_prefetch_spec.rb

@@ -41,6 +41,22 @@ describe Miscellany::ArbitraryPrefetch do
     expect(posts[0].favorite_comment).to be
   end
 
+  it 'works with Goldiloader active' do
+    Goldiloader.enabled do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+      expect(posts.count).to eq 10
+      expect(posts[0].favorite_comment).to be
+    end
+  end
+
+  it 'works with Goldiloader disabled' do
+    Goldiloader.disabled do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+      expect(posts.count).to eq 10
+      expect(posts[0].favorite_comment).to be
+    end
+  end
+
   context 'prefetch is singluar' do
     it 'returns a single object' do
       posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))

data/spec/miscellany/goldiload_value_spec.rb

@@ -0,0 +1,53 @@
+
+require 'spec_helper'
+require 'goldiloader'
+
+describe Miscellany::GoldiloadValue do
+  with_model :Post do
+    table do |t|
+      t.string :title
+      t.timestamps null: false
+    end
+
+    model do
+      attr_accessor :read_count
+
+      after_initialize { self.read_count = 0 }
+
+      def gvalue
+        goldiload_value([:key]) do |models|
+          self.read_count += 1
+          models.map{|m| [m.id, 123] }.to_h
+        end
+      end
+    end
+  end
+
+  let!(:posts) { 3.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+  it 'generally works' do
+    posts = Post.limit(2).to_a
+
+    expect(posts[0].goldi_values).to eql nil
+    expect(posts[1].goldi_values).to eql nil
+
+    expect(posts[0].gvalue).to eql 123
+
+    expect(posts[0].goldi_values).to eql ({[:key]=>123})
+    expect(posts[1].goldi_values).to eql ({[:key]=>123})
+  end
+
+  it 'only calculates once per batch' do
+    posts = Post.limit(2).to_a
+
+    expect(posts[0].read_count).to eql 0
+    expect(posts[1].read_count).to eql 0
+
+    expect(posts[0].gvalue).to eql 123
+    expect(posts[0].gvalue).to eql 123
+    expect(posts[1].gvalue).to eql 123
+
+    expect(posts[0].read_count).to eql 1
+    expect(posts[1].read_count).to eql 0
+  end
+end

data/spec/miscellany/sliced_response_spec.rb

@@ -0,0 +1,156 @@
+
+require 'spec_helper'
+require 'action_controller'
+
+describe Miscellany::SlicedResponse do
+  with_model :ARModel do
+    table do |t|
+      t.string :title
+      t.timestamps null: false
+    end
+  end
+
+  subject_class = Class.new(ActionController::Base) do
+    include Miscellany::SlicedResponse
+  end
+
+  complex_query_class = Class.new(Miscellany::ComplexQuery) do
+    def build_query
+      "SELECT * FROM #{ARModel.table_name}"
+    end
+
+    def build_count_query
+      "SELECT COUNT(*) FROM #{ARModel.table_name}"
+    end
+
+    def valid_sorts
+      ["title"]
+    end
+  end
+
+  before do
+    10.times do |i|
+      ARModel.create!(title: i)
+    end
+  end
+
+  let(:subject) { subject_class.new }
+
+  let(:slice_params) { { } }
+  let(:slice_config) { {
+    default_size: 3,
+    default_sort: "title",
+    valid_sorts: ["title", "created_at"],
+  } }
+
+  def expect_items(slice, expected)
+    expected = JSON.parse(expected.to_json).map{|i| i.without("created_at", "updated_at")}
+    slice = JSON.parse(slice.to_json)
+    expect(slice).to be_a Hash
+    expect(slice["items"].map{|i| i.without("created_at", "updated_at")}).to eql expected
+  end
+
+  shared_examples "basic functionality" do
+    it "returns the first page" do
+      r = subject.sliced_json(source, slice_params, **slice_config)
+      expect_items(r, ARModel.all.limit(3))
+    end
+
+    it "returns the second page" do
+      r = subject.sliced_json(source, { **slice_params, page: 2 }, **slice_config)
+      expect_items(r, ARModel.all.offset(3).limit(3))
+    end
+
+    it "allows changing page sizes" do
+      r = subject.sliced_json(source, { **slice_params, page: 2, page_size: 4 }, **slice_config)
+      expect_items(r, ARModel.all.offset(4).limit(4))
+    end
+
+    it "works with a slice" do
+      r = subject.sliced_json(source, { **slice_params, slice: "2:4" }, **slice_config)
+      expect_items(r, ARModel.all.offset(2).limit(2))
+    end
+
+    it "includes metadata" do
+      r = subject.sliced_json(source, slice_params, **slice_config)
+      expect(r[:total_count]).to eql 10
+      expect(r[:page]).to eql 1
+      expect(r[:page_size]).to eql 3
+      expect(r[:page_count]).to eql 4
+      expect(r[:slice_start]).to eql 0
+      expect(r[:slice_end]).to eql 3
+    end
+  end
+
+  shared_examples "sortable" do
+    it "is sortable" do
+      expect_items(subject.sliced_json(source, { **slice_params, sort: "title DESC" }, **slice_config), ARModel.all.order("title DESC").limit(3))
+    end
+  end
+
+  describe "#sliced_json" do
+    context "with an Array source" do
+      let(:source) { ARModel.all.to_a }
+
+      include_examples "basic functionality"
+    end
+
+    context "with an ActiveRecord::Relation source" do
+      let(:source) { ARModel.all }
+
+      include_examples "basic functionality"
+      include_examples "sortable"
+    end
+
+    context "with a ComplexQuery source" do
+      let(:source) { complex_query_class.new({}) }
+
+      include_examples "basic functionality"
+      include_examples "sortable"
+
+      it "uses the ComplexQuery sort_parser if valid_sorts is not given" do
+        r = subject.sliced_json(source, { **slice_params, sort: "created_at" }, {})
+        expect(r[:sort]).to eql nil
+
+        r = subject.sliced_json(source, { **slice_params, sort: "title" }, {})
+        expect(r[:sort]).to eql "title ASC"
+      end
+
+      it "does not reference the ComplexQuery sort_parser if valid_sorts is given" do
+        expect(source).not_to receive(:sort_parser)
+        subject.sliced_json(source, { **slice_params, sort: "title" }, **slice_config)
+      end
+    end
+
+    it "enforces allow_all" do
+      expect do
+        subject.sliced_json(ARModel.all, { page: "all" }, **slice_config)
+      end.to raise_error("cannot request whole collection")
+
+      expect(subject.sliced_json(ARModel.all, { page: "all" }, allow_all: true, **slice_config)).to be_a Hash
+    end
+  end
+
+  describe "#bearcat_as_sliced_json" do
+    # TODO
+  end
+
+  describe Miscellany::SlicedResponse::Slice do
+    let(:sort_parser) { Miscellany::SortLang::Parser.new(slice_config[:valid_sorts], default: slice_config[:default_sort]) }
+    let(:slice) do
+      Miscellany::SlicedResponse::Slice.build(ARModel.all, slice_params, sort_parser: sort_parser, **slice_config)
+    end
+
+    describe "#sort_sql" do
+      it "always includes the default sort" do
+        slice_params[:sort] = "created_at"
+        expect(slice.send(:sort_sql)).to include "created_at ASC NULLS FIRST"
+      end
+
+      it "excludes unknown sorts" do
+        slice_params[:sort] = "updated_at"
+        expect(slice.send(:sort_sql)).not_to include "updated_at"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'logger'
 require 'yaml'
 require 'database_cleaner'
 require 'with_model'
+require 'goldiloader'
 
 require 'miscellany'
 
@@ -17,10 +18,12 @@ db_adapter = ENV.fetch('ADAPTER', 'sqlite3')
 db_config = YAML.safe_load(File.read('spec/db/database.yml'))
 ActiveRecord::Base.establish_connection(db_config[db_adapter])
 
+Goldiloader.globally_enabled = false
+
 RSpec.configure do |config|
   config.extend WithModel
 
-  # config.order = 'random'
+  config.order = 'random'
 
   config.before(:suite) do
     DatabaseCleaner.clean_with(:truncation)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: miscellany
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.14
 platform: ruby
 authors:
 - Ethan Knapp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-15 00:00:00.000000000 Z
+date: 2023-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -100,6 +100,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: goldiloader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - eknapp@instructure.com
@@ -108,11 +122,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- app/views/miscellany/_slice.json.jbuilder
 - config/initializers/cancancan.rb
 - lib/miscellany.rb
 - lib/miscellany/active_record/arbitrary_prefetch.rb
 - lib/miscellany/active_record/batch_matcher.rb
 - lib/miscellany/active_record/batched_destruction.rb
+- lib/miscellany/active_record/complex_query.rb
 - lib/miscellany/active_record/computed_columns.rb
 - lib/miscellany/active_record/custom_preloaders.rb
 - lib/miscellany/active_record/goldiload_value.rb
@@ -121,14 +137,18 @@ files:
 - lib/miscellany/controller/http_error_handling.rb
 - lib/miscellany/controller/json_uploads.rb
 - lib/miscellany/controller/sliced_response.rb
+- lib/miscellany/jbuilder_partial_block.rb
 - lib/miscellany/local_lru_cache.rb
 - lib/miscellany/param_validator.rb
+- lib/miscellany/sort_lang.rb
 - lib/miscellany/version.rb
 - miscellany.gemspec
 - spec/db/database.yml
 - spec/miscellany/arbitrary_prefetch_spec.rb
 - spec/miscellany/computed_columns_spec.rb
+- spec/miscellany/goldiload_value_spec.rb
 - spec/miscellany/param_validator_spec.rb
+- spec/miscellany/sliced_response_spec.rb
 - spec/spec_helper.rb
 homepage: https://instructure.com
 licenses: []
@@ -155,6 +175,8 @@ summary: Gem for a bunch of random, re-usable Rails Concerns & Helpers
 test_files:
 - spec/db/database.yml
 - spec/miscellany/arbitrary_prefetch_spec.rb
+- spec/miscellany/sliced_response_spec.rb
 - spec/miscellany/param_validator_spec.rb
 - spec/miscellany/computed_columns_spec.rb
+- spec/miscellany/goldiload_value_spec.rb
 - spec/spec_helper.rb