miscellany 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 296f82b755fbbff37b7b939e31d30d53c1e1ed3b528df93992460a5c5093e1bb
-  data.tar.gz: f42d95c04a728a4b16e9b0286e900d243b18b1385649150fed2b1a0501e7098a
+  metadata.gz: 70a91bb987b7c99319cbe607cdfba6c32e9637a5a3fb8bec3ec38725339ea3c6
+  data.tar.gz: f9607f408e91b1abadb51e73c4238b1a1d9f378fe294461efe11f3172783d9e2
 SHA512:
-  metadata.gz: 513b776e716e713413ee7f1c45cb2300c6142ffad6fcd3b550bfa06f5f496b630dea82fb99274853e2f825d47387648d015364d619de3b7572e0565b83160219
-  data.tar.gz: 85540e4cca127328d52c1b68a51be2b2366e5bcf5dfef95464703ece61539ba68ed3e0689fd55e22d8c258bbb625efa486b2d5f0b32075bffcf43da866d4e110
+  metadata.gz: f8c1ba0f079635d38ed0d3a29d3cb865899fb66112593625a2ae159061c5fd48f63cfa2300a825f671bdbd04e4e2317d6ccedd80702391bdadd7329c0a2deae9
+  data.tar.gz: a73fd773078016b440b08243c4c6dc5477ff26cdbacb054f57d8b99b77c15305af7a1741d0c94b02399c3b59af7553254a23be5441d1d30948f4f51cb53b6ccf

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/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/controller/sliced_response.rb

@@ -1,3 +1,5 @@
+require_relative './http_error_handling'
+
 module Miscellany
   module SlicedResponse
     extend ActiveSupport::Concern
@@ -84,7 +86,7 @@ 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)(!?))?/)
+        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 }
@@ -213,12 +215,20 @@ 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

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)
+                ers = pv.errors
+              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.0".freeze
+  VERSION = "0.1.4".freeze
 end

data/lib/miscellany.rb

@@ -1,6 +1,18 @@
 
+require "active_support/lazy_load_hooks"
+
 Dir[File.dirname(__FILE__) + "/miscellany/**/*.rb"].each { |file| require file }
 
 module Miscellany
 
+  if defined?(Rails)
+    class Engine < ::Rails::Engine
+    end
+  end
+
+  ActiveSupport.on_load(:active_record) do
+    Miscellany::CustomPreloaders.install
+    Miscellany::ArbitraryPrefetch.install
+    Miscellany::ComputedColumns.install
+  end
 end

data/miscellany.gemspec

@@ -22,22 +22,13 @@ Gem::Specification.new do |spec|
   spec.test_files = Dir["spec/**/*"]
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rspec-rails"
-  spec.add_development_dependency "pg"
-  spec.add_development_dependency "factory"
-  spec.add_development_dependency "factory_bot"
-  spec.add_development_dependency "timecop"
-  spec.add_development_dependency "webmock"
-  spec.add_development_dependency "sinatra", ">= 0"
-  spec.add_development_dependency "shoulda-matchers"
-  spec.add_development_dependency "yard"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "pry-nav"
-  spec.add_development_dependency "rubocop"
+  spec.add_dependency 'rails', '>= 5', '< 6.3'
+  # spec.add_dependency 'activerecord', '>= 5', '< 6.3'
+  # spec.add_dependency 'activesupport', '>= 5', '< 6.3'
 
-  spec.add_dependency "rails", ">= 5"
-  spec.add_dependency "activerecord-import"
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'database_cleaner', '>= 1.2'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'with_model'
 end

data/spec/db/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"