miscellany 0.1.2 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee3173a46bc8dfb9c07bc8e6533776c332b6267e8d2465bada2e9d395192f199
-  data.tar.gz: cfef42a0855f7fe772e0ae50d08aaaca4fa6dba6a69caf189c1fbea1d076a168
+  metadata.gz: 0c92b625438d9027f73a5cd7b5f4ef168e1ed3e083b0c13924cb9f3f0e2db6bd
+  data.tar.gz: 0a52d0877c7eea6a0c2189efdd4c30cb65a3419abf149a8ae0ce4e63467741de
 SHA512:
-  metadata.gz: 1035b6798d130d137a6feef1892dde982f04394fbdc228a63ab275685ba9cf460b84f909bdcae6bb5f41a78e952c237d331aaaf94ba4241d0c10bf984e24c3fe
-  data.tar.gz: d07f4e9beacb29caa4d5ca6e22e265240dc87857bab04b5165ed8d1587090811495095ba0a95579bb8ceac2fc25e7fec2c7af1c04ce06ea370fa5137d30c5ea9
+  metadata.gz: 9cbc439200d8a6c1604aa0153cbed6cfeead8636eb7330880371d2e8c6d2d412739e8a2d302c5dfd1cd9b038bec9f6de663f8fc7ddfd1fb1d8c99afe029e0306
+  data.tar.gz: d4bea4b5fd11c1830a8f18302c7f6c95d6f4c3fc147faf715f675850e7dee4e02d08632b05aa3e61ce4277de494a9784e6dc3ef55c8e92f99a0a22ba9a9d4fbc

data/lib/miscellany/active_record/arbitrary_prefetch.rb

@@ -4,18 +4,11 @@
 #   The values of the Hash may be an array of [Symbol, Relation] or another (filtered) Relation.
 #   Objects are queried from an existing Association on the model. This Association is detemrined
 #   by either the Symbol when an array is passed, or by finding an Assoication for the passed Relation's model
-#
-# NOTICE: This implementation is NOT COMPLETE by itself - it depends on Goldiloader
-#   to detect the use of the virtual associations and prevent N+1s. We were already using
-#   Goldiloader, so this made sense. If this module is ever needed stand-alone,
-#   the following options have been identified:
-#     1. Extend ActiveRecordRelationPatch#exec_queries to execute an ActiveRecord::Associations::Preloader
-#        that will load the related objects
-#     2. Duplicates the relevant snippets from Goldiloader into this module. See Goldiloader::AutoIncludeContext
-#   The current Goldiloader implementation uses Option 1 internally, but also makes the relations lazy - even
-#     if you define a prefetch, it won't actually be loaded until you attempt to access it on one of the models.
 module Miscellany
   module ArbitraryPrefetch
+    ACTIVE_RECORD_VERSION = ::Gem::Version.new(::ActiveRecord::VERSION::STRING).release
+    PRE_RAILS_6_2 = ACTIVE_RECORD_VERSION < ::Gem::Version.new('6.2.0')
+
     class PrefetcherContext
       attr_accessor :model, :target_attribute
       attr_reader :options
@@ -49,7 +42,7 @@ module Miscellany
         @reflection ||= begin
           queryset = @queryset
           source_refl = model.reflections[@source_key.to_s]
-          scope = lambda { |*_args|
+          scope = lambda {|*_args|
             qs = queryset
             qs = qs.merge(source_refl.scope_for(model.unscoped)) if source_refl.scope
             qs
@@ -83,14 +76,16 @@ module Miscellany
         return super if loaded?
 
         records = super
-        preloader = nil
         (@values[:prefetches] || {}).each do |_key, opts|
           pfc = PrefetcherContext.new(model, opts)
           pfc.link_models(records)
 
           unless defined?(Goldiloader)
-            preloader ||= build_preloader
-            preloader.preload(records, opts[:attribute])
+            if PRE_RAILS_6_2
+              ::ActiveRecord::Associations::Preloader.new.preload(records, [opts[:attribute]])
+            else
+              ::ActiveRecord::Associations::Preloader.new(records: records, associations: [opts[:attribute]]).call
+            end
           end
         end
         records
@@ -106,12 +101,12 @@ module Miscellany
         assert_mutability!
         @values[:prefetches] ||= {}
         kwargs.each do |attr, opts|
-          @values[:prefetches][attr] = normalize_options(attr, opts)
+          @values[:prefetches][attr] = normalize_prefetch_options(attr, opts)
         end
         self
       end
 
-      def normalize_options(attr, opts)
+      def normalize_prefetch_options(attr, opts)
         norm = if opts.is_a?(Array)
             { relation: opts[0], queryset: opts[1] }
           elsif opts.is_a?(ActiveRecord::Relation)
@@ -143,15 +138,43 @@ module Miscellany
       end
     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
+        end
+      end
+    end
+
+    module ActiveRecordReflectionPatch
+      def check_preloadable!
+        return if scope && scope.arity < 0
+        super
+      end
+    end
+
     def self.install
       ::ActiveRecord::Base.include(ActiveRecordBasePatch)
+
       ::ActiveRecord::Relation.prepend(ActiveRecordRelationPatch)
       ::ActiveRecord::Relation::Merger.prepend(ActiveRecordMergerPatch)
 
+      ::ActiveRecord::Associations::Preloader.prepend(ActiveRecordPreloaderPatch)
+
+      ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecordReflectionPatch)
+
       return unless defined? ::Goldiloader
 
       ::Goldiloader::AssociationLoader.module_eval do
-        def self.has_association?(model, association_name) # rubocop:disable Naming/PredicateName
+        def self.has_association?(model, association_name)
           model.association(association_name)
           true
         rescue ::ActiveRecord::AssociationNotFoundError => _err

data/lib/miscellany/active_record/batched_destruction.rb

@@ -16,7 +16,6 @@ module Miscellany
 
     class_methods do
       def bulk_destroy(**kwargs)
-        return to_sql
         bulk_destroy_internal(self, **kwargs)
       end
 

data/lib/miscellany/active_record/computed_columns.rb

@@ -0,0 +1,107 @@
+
+module Miscellany
+  module ComputedColumns
+    module ActiveRecordBasePatch
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          delegate :with_computed, to: :all
+        end
+      end
+
+      class_methods do
+        def define_computed(key, dirblk = nil, &blk)
+          blk ||= dirblk
+          @defined_computeds ||= {}
+          @defined_computeds[key] = blk
+        end
+
+        def get_defined_computed(key)
+          @defined_computeds ||= {}
+          @defined_computeds[key] || superclass.try(:get_defined_computed, key)
+        end
+      end
+    end
+
+    module ActiveRecordRelationPatch
+      def with_computed(*args, **kwargs)
+        entries = { **kwargs }
+        args.each do |k|
+          entries[k] = []
+        end
+
+        entries.reduce(self) do |query, (k, v)|
+          comp = model.get_defined_computed(k)
+          raise "Undefined ComputedColum :#{k}" if comp.nil?
+
+          builder = ComputedBuilder.new(k, v, &comp)
+          builder.apply(query)
+        end
+      end
+    end
+
+    class ComputedBuilder
+      def initialize(key, args, &blk)
+        @key = key
+        @args = args.is_a?(Array) ? args : [args]
+        @block = blk
+        @compiled = {}
+      end
+
+      %i[select join_condition query].each do |m|
+        define_method(m) do |arg=:not_given, &blk|
+          raise "Must provide either a value or a block" if arg != :not_given && blk
+          raise "Must provide either a value or a block" if arg == :not_given && !blk
+
+          if arg == :not_given
+            arg = blk.call
+          end
+
+          @compiled[m] = arg
+        end
+      end
+
+      def apply(q)
+        instance_exec(*@args, &@block)
+
+        c = @compiled
+        raise "defined_computed: query must be provided" unless c[:query]
+
+        join_name = @key.to_s
+        base_table_name = current_table_from_scope(q)
+        c[:join_condition] ||= "COMPUTED.id = #{base_table_name}.id"
+        c[:select] ||= "#{join_name}.value AS #{@key}"
+
+        q = q.select("#{base_table_name}.*") if !q.values[:select].present?
+
+        select_statement = c[:select].gsub('COMPUTED', join_name)
+        join_condition = c[:join_condition].gsub('COMPUTED', join_name)
+        join_query = c[:query]
+        join_query = join_query.to_sql if join_query.respond_to?(:to_sql)
+
+        q.select(select_statement).joins("LEFT OUTER JOIN (#{join_query}) #{join_name} ON #{join_condition}")
+      end
+
+      protected
+
+      def current_table_from_scope(q)
+        current_table = q.current_scope.arel.source.left
+
+        case current_table
+        when Arel::Table
+          current_table.name
+        when Arel::Nodes::TableAlias
+          current_table.right
+        else
+          fail
+        end
+      end
+    end
+
+    def self.install
+      ::ActiveRecord::Base.include(ActiveRecordBasePatch)
+      ::ActiveRecord::Relation.prepend(ActiveRecordRelationPatch)
+    end
+  end
+end

data/lib/miscellany/batch_processor.rb

@@ -8,12 +8,15 @@ module Miscellany
   #   enumerator_of_some_kind.each { |item| batches << item }
   #   batches.flush
   class BatchProcessor
-    attr_reader :batch_size
+    attr_reader :batch_size, :ensure_once
 
-    def initialize(of: 1000, &blk)
+    def initialize(of: 1000, ensure_once: false, &blk)
       @batch_size = of
       @block = blk
+      @ensure_once = ensure_once
       @current_batch = []
+
+      @flush_count = 0
     end
 
     def <<(item)
@@ -28,7 +31,7 @@ module Miscellany
     end
 
     def flush
-      process_batch if @current_batch.present?
+      process_batch if @current_batch.present? || (@flush_count.zero? && ensure_once)
     end
 
     protected
@@ -36,6 +39,7 @@ module Miscellany
     def process_batch
       @block.call(@current_batch)
       @current_batch = []
+      @flush_count += 1
     end
   end
 end

data/lib/miscellany/controller/sliced_response.rb

@@ -17,7 +17,9 @@ module Miscellany
       default_sort: nil, valid_sorts: nil,
       &blk
     )
-      normalized_sorts = normalize_sort_options(valid_sorts || queryset.column_names, default: default_sort)
+      valid_sorts ||= queryset.column_names if queryset.respond_to?(:column_names)
+      valid_sorts ||= []
+      normalized_sorts = normalize_sort_options(valid_sorts, default: default_sort)
 
       slice = Slice.build(
         queryset, slice_params,
@@ -85,8 +87,10 @@ module Miscellany
 
     def normalize_sort(sort, key: nil)
       sort = sort.to_s if sort.is_a?(Symbol)
-      if sort.is_a?(String)
-        m = sort.match(/(\w+)(?: (ASC|DESC)(!?))?/)
+      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 }
@@ -215,18 +219,31 @@ module Miscellany
 
       def rendered_items
         ritems = sliced_items
-        ritems = ritems.map(&options[:item_transformer]) if options[:item_transformer]
+        ritems = ritems.to_a.map(&options[:item_transformer]) if options[:item_transformer]
         ritems
       end
 
       def total_item_count
-        @total_item_count ||= options[:total_count] || (items.respond_to?(:count) && items.count) || nil
+        @total_item_count ||= options[:total_count] || begin
+          if items.is_a?(ActiveRecord::Relation)
+            items.except(:select).count
+          elsif items.respond_to?(:count)
+            items.count
+          else
+            nil
+          end
+        end
       end
 
       def sliced_items
         @sliced_items ||= begin
           if items.is_a?(Array)
-            items
+            start, finish = slice_bounds
+            if start && finish
+              items[start...finish]
+            else
+              items
+            end
           elsif items.is_a?(Proc)
             items.call(self)
           elsif items.is_a?(ActiveRecord::Relation)
@@ -247,10 +264,20 @@ module Miscellany
           sorts << options[:valid_sorts][:default] if options.dig(:valid_sorts, :default).present?
 
           sorts.reduce(qset) do |qset, sort|
+            order = sort[:order] || 'ASC'
             if sort[:column].is_a?(Proc)
-              sort[:column].call(qset, sort[:order] || 'ASC')
+              sort[:column].call(qset, order)
             else
-              qset.order(sort[:column] => sort[:order] || 'ASC')
+              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

data/lib/miscellany/param_validator.rb

@@ -1,6 +1,7 @@
 module Miscellany
   class ParamValidator
-    attr_accessor :context, :options, :errors
+    attr_accessor :context, :errors
+    attr_reader :params
 
     delegate_missing_to :context
 
@@ -9,7 +10,7 @@ module Miscellany
     CHECKS = %i[type specified present default transform in block items pattern].freeze
     NON_PREFIXED = %i[default transform type message timezone].freeze
     PREFIXES = %i[all onem onep one none].freeze
-    PREFIX_ALIASES = { any: :onep, not: :none }.freeze
+    PREFIX_ALIASES = { any: :onep, not: :none, one_or_less: :onem, one_or_more: :onem }.freeze
     ALL_PREFIXES = (PREFIXES + PREFIX_ALIASES.keys).freeze
     VALID_FLAGS = %i[present specified].freeze
 
@@ -21,14 +22,11 @@ module Miscellany
       end
     end
 
-    def initialize(block, context, parameters = nil, options = nil)
+    def initialize(block, context, parameters = nil)
       @block = block
       @context = context
       @params = parameters || context.params
-      @subkeys = []
-      @options = options || {}
-      @errors = {}
-      @explicit_parameters = []
+      @errors = ErrorStore.new
     end
 
     def self.check(params, context: nil, &blk)
@@ -48,8 +46,13 @@ module Miscellany
 
     def apply_checks(&blk)
       blk ||= @block
-      args = trim_arguments(blk, [params, @subkeys[-1]])
-      instance_exec(*args, &blk)
+      args = trim_arguments(blk, [@params, :TODO])
+
+      dresult = instance_exec(*args, &blk)
+      dresult = "failed validation #{check}" if dresult == false
+      if dresult.present? && dresult != true
+        @errors.push(dresult)
+      end
     end
 
     def parameter(param_keys, *args, **kwargs, &blk)
@@ -107,45 +110,57 @@ module Miscellany
 
         # Nested check
         run_check[:block] do |blk|
-          iterate_array = false # TODO
-          sub_parameter(pk) do
-            if params.is_a?(Array) && iterate_array
-              params.each_with_index do |v, i|
-                sub_parameter(i) { apply_checks(&blk) }
-              end
-            else
-              apply_checks(&blk)
-            end
-          end
+          ParamValidator.check(params[pk], context: context, &blk)
         end
 
-        # Nested check
+        # Array Items check
         run_check[:items] do |blk|
-          sub_parameter(pk) do
-            if params.is_a?(Array)
-              params.each_with_index do |v, i|
-                sub_parameter(i) { apply_checks(&blk) }
+          if params[pk].is_a?(Array)
+            error_items = 0
+            astore = ErrorStore.new
+
+            params[pk].each_with_index do |v, i|
+              errs = nil
+              if blk.is_a?(Hash)
+                pv = ParamValidator.new(nil, self.context, params[pk])
+                pv.parameter(i, **blk)
+                errs = pv.errors.store_for(i)
+              else
+                errs = ParamValidator.check(params[pk][i], context: context, &blk)
+              end
+
+              if errs.present?
+                error_items += 1
+                if error_items > 5
+                  check_results[:items]
+                  astore.push("Too Many Errors")
+                  break
+                else
+                  astore.push_to(i, errs)
+                end
               end
-            else
-              raise "items: validator can only be used with Arrays"
             end
+
+            astore
+          else
+            raise "items: validator can only be used with Arrays"
           end
         end
       end
 
-      final_errors = {}
+      final_errors = ErrorStore.new
       checks.each do |check, check_prefix|
         if check_prefix == :all || check_prefix == nil
           all_results.each do |field, err_map|
             errs = err_map[check]
             next unless errs.present?
 
-            final_errors[field] = merge_error_hashes(final_errors[field], errs)
+            final_errors.push_to(field, errs)
           end
         elsif check_prefix == :none
           all_results.each do |field, err_map|
             errs = err_map[check]
-            final_errors[field] = merge_error_hashes(final_errors[field], "must NOT be #{check}") unless errs.present?
+            final_errors.push_to(field, "must NOT be #{check}") unless errs.present?
           end
         else
           counts = check_pass_count(check, all_results)
@@ -160,13 +175,14 @@ module Miscellany
             (counts[:passed] > 1 && check_prefix == :onem) ||
             (counts[:passed] < 1 && check_prefix == :onep)
 
-            final_errors = merge_error_hashes(final_errors, "#{string_prefixes[check_prefix]} #{field_key} #{check}")
+            final_errors.push("#{string_prefixes[check_prefix]} #{field_key} must be #{check}")
           end
         end
       end
 
-      @errors = merge_error_hashes(@errors, final_errors)
-      final_errors
+      @errors.merge!(final_errors)
+
+      nil
     end
 
     alias p parameter
@@ -197,27 +213,27 @@ module Miscellany
       check_prefixes = NON_PREFIXED.include?(check) ? [nil] : Array(checks_to_run&.[](check))
       return true unless check_prefixes.present?
 
+      encountered_errors = false
+
       check_prefixes.each do |check_prefix|
-        initial_errors = @errors
-        @errors = []
+        prefixed_check = [check_prefix, check].compact.join('_')
         prefix_options = (check_prefix.nil? ? options : options&.[](check_prefix)) || {}
-        args = trim_arguments(blk, [prefix_options[check]])
 
-        result = yield(*args)
+        result = blk.call(*trim_arguments(blk, [prefix_options[check]]))
         result = "failed validation #{check}" if result == false
 
+        store = state[check] ||= ErrorStore.new
+
         if result.present? && result != true
           result = options[:message] if options&.[](:message).present?
-          Array(result).each do |e|
-            @errors << e
-          end
-        end
 
-        state[check] = merge_error_hashes(state[check], @errors)
-        @errors = initial_errors
+          store.push(result)
+
+          encountered_errors = true
+        end
       end
 
-      !state[check].present?
+      !encountered_errors
     end
 
     def coerce_type(params, key, opts)
@@ -243,10 +259,11 @@ module Miscellany
 
       return type.call(param, options) if type.is_a?(Proc)
 
-      if (param.is_a?(Array) && type != Array) || ((param.is_a?(Hash) || param.is_a?(ActionController::Parameters)) && type != Hash)
+      is_rails_parameters = defined?(ActionController::Parameters) && param.is_a?(ActionController::Parameters)
+      if (param.is_a?(Array) && type != Array) || ((param.is_a?(Hash) || is_rails_parameters) && type != Hash)
         raise ArgumentError
       end
-      return param if (param.is_a?(ActionController::Parameters) && type == Hash rescue false)
+      return param if (is_rails_parameters && type == Hash rescue false)
 
       # Primitives
       return Integer(param) if type == Integer
@@ -374,53 +391,13 @@ module Miscellany
       skey = key.to_s
       ALL_PREFIXES.each do |pfx|
         spfx = pfx.to_s
-        next unless skey.starts_with?("#{spfx}_")
+        next unless skey.start_with?("#{spfx}_")
 
         return [skey[(spfx.length + 1)..-1].to_sym, PREFIX_ALIASES[pfx] || pfx]
       end
       [key, nil]
     end
 
-    def sub_parameter(k)
-      @subkeys.push(k)
-      yield
-    ensure
-      @subkeys.pop
-    end
-
-    def params
-      p = @params
-      @subkeys.each { |k| p = p[k] }
-      p
-    end
-
-    def merge_error_hashes(target, from)
-      target ||= []
-      if target.is_a?(Hash)
-        ta = []
-        th = target
-      else
-        ta = target
-        th = target[-1].is_a?(Hash) ? ta.pop : {}
-      end
-
-      if from.is_a?(Hash)
-        from.each_pair do |k, v|
-          th[k] = merge_error_hashes(th[k], v)
-        end
-      elsif from.is_a?(Array)
-        merge_error_hashes(th, from.pop) if from[-1].is_a?(Hash)
-        from.each { |f| ta << f }
-      else
-        ta << from
-      end
-
-      return th if !ta.present? && th.present?
-
-      ta << th if th.present?
-      ta
-    end
-
     def merge_hashes(h1, h2)
       h2.each do |k, v|
         set_hash_key(h1, k, v)
@@ -438,5 +415,75 @@ module Miscellany
       return args if blk.arity.negative?
       args[0..(blk.arity.abs - 1)]
     end
+
+    class ErrorStore
+      attr_reader :errors, :fields
+
+      def initialize
+        @errors = []
+        @fields = {}
+      end
+
+      def push(error)
+        if error.is_a?(ErrorStore)
+          merge!(error)
+        elsif error.is_a?(Array)
+          error.each{|e| push(e) }
+        else
+          @errors << error
+        end
+      end
+
+      def push_to(field, error)
+        store_for(field).push(error)
+      end
+
+      def present?
+        @errors.present? || @fields.values.any?(&:present?)
+      end
+
+      def serialize
+        if @fields.values.any?(&:present?)
+          h = { }
+          h[:_SELF_] = @errors if @errors.present?
+          @fields.each do |k, v|
+            s = v.serialize
+            next unless s.present?
+            h[k] = s
+          end
+          h
+        elsif @errors.present?
+          @errors
+        else
+          nil
+        end
+      end
+
+      def merge!(other_store)
+        return self if other_store == self
+
+        @errors |= other_store.errors
+        other_store.fields.each do |k, v|
+          store_for(k).merge!(v)
+        end
+
+        self
+      end
+
+      def store_for(field)
+        if field.is_a?(Symbol) || field.is_a?(Numeric)
+          field = [field]
+        elsif field.is_a?(String)
+          field = field.split('.')
+        elsif field.is_a?(Array)
+          field = [*field]
+        end
+
+        sfield = field.shift
+        store = @fields[sfield.to_s] ||= ErrorStore.new
+        return store if field.count == 0
+        return store.store_for(field)
+      end
+    end
   end
 end

data/lib/miscellany/version.rb

@@ -1,3 +1,3 @@
 module Miscellany
-  VERSION = "0.1.2".freeze
+  VERSION = "0.1.5".freeze
 end