miscellany 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 592322f721c82c3a296438d483a372ac5dc4b06d2da56e1b4d614999ed7f1cb4
-  data.tar.gz: affc6540ac3f73d4096a544ab45d67e617da481aa97334e399bea704c5055c1e
+  metadata.gz: 70a91bb987b7c99319cbe607cdfba6c32e9637a5a3fb8bec3ec38725339ea3c6
+  data.tar.gz: f9607f408e91b1abadb51e73c4238b1a1d9f378fe294461efe11f3172783d9e2
 SHA512:
-  metadata.gz: e7c5dd2f97d9998656c7eae1a1ef69c7091c09fdc0d34f7b98ccce3d18067751d67ee0b6790fa2c355149703becfe124a32eb6f65fc9b620cd5425ea66e8f6e4
-  data.tar.gz: 2cb31549f3dda188c255e0e3fb11d2770039eda248f63612e88bcfea13422e26228efc451369e69f2e688d5a0627ccbb815457d73b7b443fc19bec1b312d357e
+  metadata.gz: f8c1ba0f079635d38ed0d3a29d3cb865899fb66112593625a2ae159061c5fd48f63cfa2300a825f671bdbd04e4e2317d6ccedd80702391bdadd7329c0a2deae9
+  data.tar.gz: a73fd773078016b440b08243c4c6dc5477ff26cdbacb054f57d8b99b77c15305af7a1741d0c94b02399c3b59af7553254a23be5441d1d30948f4f51cb53b6ccf

data/lib/miscellany/active_record/arbitrary_prefetch.rb

@@ -4,16 +4,6 @@
 #   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
@@ -111,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)
@@ -155,7 +145,7 @@ module Miscellany
           records.each do |record|
             next unless record
             reflection = record.class._reflect_on_association(association)
-            reflection ||= record.association(association)&.reflection
+            reflection ||= record.association(association)&.reflection rescue nil
             next if polymorphic_parent && !reflection || !record.association(association).klass
             (h[reflection] ||= []) << record
           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/controller/sliced_response.rb

@@ -86,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 }
@@ -215,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.3".freeze
+  VERSION = "0.1.4".freeze
 end

data/lib/miscellany.rb

@@ -1,4 +1,6 @@
 
+require "active_support/lazy_load_hooks"
+
 Dir[File.dirname(__FILE__) + "/miscellany/**/*.rb"].each { |file| require file }
 
 module Miscellany
@@ -7,4 +9,10 @@ module Miscellany
     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:"

data/spec/miscellany/arbitrary_prefetch_spec.rb

@@ -0,0 +1,69 @@
+
+require 'spec_helper'
+
+describe Miscellany::ArbitraryPrefetch do
+  with_model :Post do
+    table do |t|
+      t.string :title
+      t.timestamps null: false
+    end
+
+    model do
+      has_many :comments
+    end
+  end
+
+  with_model :Comment do
+    table do |t|
+      t.belongs_to :post
+      t.string :title
+      t.boolean :favorite
+      t.timestamps null: false
+    end
+
+    model do
+      belongs_to :post
+    end
+  end
+
+  let!(:posts) { 10.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+  before :each do
+    posts.each do |p|
+      5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
+      p.comments.last.update!(favorite: true)
+    end
+  end
+
+  it 'generally works' do
+    posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+    expect(posts.count).to eq 10
+    expect(posts[0].favorite_comment).to be
+  end
+
+  context 'prefetch is singluar' do
+    it 'returns a single object' do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: true))
+      expect(posts[0].favorite_comment).to be_a Comment
+    end
+
+    it 'with multiple items returns a single object' do
+      posts = Post.prefetch(favorite_comment: Comment.where(favorite: nil))
+      expect(posts[0].favorite_comment).to be_a Comment
+    end
+  end
+
+  context 'prefetch is plural' do
+    it 'returns an Array' do
+      posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: nil))
+      expect(posts[0].non_favorite_comments).to respond_to :[]
+      expect(posts[0].non_favorite_comments.length).to eq 4
+    end
+
+    it 'with 1 item returns an Array' do
+      posts = Post.prefetch(non_favorite_comments: Comment.where(favorite: true))
+      expect(posts[0].non_favorite_comments).to respond_to :[]
+      expect(posts[0].non_favorite_comments.length).to eq 1
+    end
+  end
+end

data/spec/miscellany/computed_columns_spec.rb

@@ -0,0 +1,62 @@
+
+require 'spec_helper'
+
+describe Miscellany::ComputedColumns do
+  with_model :Post do
+    table do |t|
+      t.string :title
+      t.timestamps null: false
+    end
+
+    model do
+      has_many :comments
+
+      define_computed :favorite_comments_count, ->() {
+        select "COMPUTED.count AS favorite_comments_count"
+
+        query do
+          Comment.select(<<~SQL)
+              post_id AS id,
+              count(*) AS count
+            SQL
+          .group(:post_id)
+            .where(favorite: true)
+        end
+      }
+    end
+  end
+
+  with_model :Comment do
+    table do |t|
+      t.belongs_to :post
+      t.string :title
+      t.boolean :favorite
+      t.timestamps null: false
+    end
+
+    model do
+      belongs_to :post
+    end
+  end
+
+  let!(:posts) { 3.times.map{|i| Post.create!(title: "Post #{i}") } }
+
+  before :each do
+    posts.each do |p|
+      5.times{|i| p.comments.create!(title: "#{p.title} Comment #{i}") }
+      p.comments.last.update!(favorite: true)
+    end
+  end
+
+  it 'generally works' do
+    ActiveRecord::Base.verbose_query_logs = true
+    posts = Post.with_computed(:favorite_comments_count)
+    expect(posts.except(:select).count).to eq 3
+    expect(posts[0].favorite_comments_count).to eq 1
+
+    Comment.update_all(favorite: true)
+    posts = Post.with_computed(:favorite_comments_count)
+    expect(posts.except(:select).count).to eq 3
+    expect(posts[0].favorite_comments_count).to eq 5
+  end
+end

data/spec/miscellany/param_validator_spec.rb

@@ -0,0 +1,295 @@
+
+require 'spec_helper'
+
+describe Miscellany::ParamValidator do
+  let!(:value) do
+    {
+      int_array: [1,2,3],
+      string_array: %w[A B C],
+      some_number: 2,
+      some_string: "Robert",
+      specified: nil,
+      array: [
+        {a: 2},
+        {a: 3},
+      ],
+      hash: {
+        nested_hash: {
+          value: 1,
+        }
+      },
+    }
+  end
+
+  # TODO transform:
+
+  def expect_valid(&blk)
+    result = Miscellany::ParamValidator.check(value, &blk)
+    expect(result.serialize).to be_nil
+  end
+
+  def expect_invalid(&blk)
+    result = Miscellany::ParamValidator.check(value, &blk)
+    expect(result.serialize).to be_present
+  end
+
+  def expect_coercion(raw, type, expectation)
+    result = Miscellany::ParamValidator.assert({ value: raw }, handle: ->(v){ raise 'Invalid' }) do
+      p :value, type: type
+    end
+    expect(result[:value]).to eq expectation
+  end
+
+  describe 'default:' do
+    it 'sets a default value' do
+      result = Miscellany::ParamValidator.assert({ }, handle: ->(v){ raise 'Invalid' }) do
+        p :value, default: 'HIA'
+      end
+      expect(result[:value]).to eq 'HIA'
+    end
+
+    it 'works deep' do
+      result = Miscellany::ParamValidator.assert({ value: {} }, handle: ->(v){ raise 'Invalid' }) do
+        p :value do |x|
+          p :value, default: 'Hia'
+        end
+      end
+      expect(result).to eq ({ value: { value: 'Hia' } })
+    end
+  end
+
+  describe 'specified' do
+    it 'passes a given value' do
+      expect_valid do
+        p :some_string, :specified
+      end
+    end
+
+    it 'passes a given nil' do
+      expect_valid do
+        p :specified, :specified
+      end
+    end
+
+    it 'fails an unspecified key' do
+      expect_invalid do
+        p :not_specified, :specified
+      end
+    end
+  end
+
+  describe 'present' do
+    it 'passes a given value' do
+      expect_valid do
+        p :some_string, :present
+      end
+    end
+
+    it 'fails a given nil' do
+      expect_invalid do
+        p :specified, :present
+      end
+    end
+
+    it 'fails an unspecified key' do
+      expect_invalid do
+        p :not_specified, :present
+      end
+    end
+  end
+
+  describe 'type:' do
+    it 'passes based on type' do
+      expect_valid do
+        p :some_number, type: Numeric
+        p :some_string, type: String
+      end
+    end
+
+    it 'fails based on type' do
+      expect_invalid do
+        p :some_number, type: String
+        p :some_string, type: Numeric
+      end
+    end
+
+    describe ':bool' do
+      it 'transforms booleans' do
+        expect_coercion('t', :bool, true)
+        expect_coercion('T', :bool, true)
+        expect_coercion('true', :bool, true)
+        expect_coercion('True', :bool, true)
+        expect_coercion('TRUE', :bool, true)
+        expect_coercion('YES', :bool, true)
+        expect_coercion('yes', :bool, true)
+        expect_coercion('Y', :bool, true)
+        expect_coercion('y', :bool, true)
+        expect_coercion('1', :bool, true)
+        expect_coercion(1, :bool, true)
+
+        expect_coercion('f', :bool, false)
+        expect_coercion('F', :bool, false)
+        expect_coercion('false', :bool, false)
+        expect_coercion('False', :bool, false)
+        expect_coercion('FALSE', :bool, false)
+        expect_coercion('NO', :bool, false)
+        expect_coercion('no', :bool, false)
+        expect_coercion('N', :bool, false)
+        expect_coercion('n', :bool, false)
+        expect_coercion('0', :bool, false)
+        expect_coercion(0, :bool, false)
+      end
+    end
+  end
+
+  describe 'in:' do
+    it 'works' do
+      expect_valid do
+        p :some_number, in: [1, 2]
+      end
+
+      expect_invalid do
+        p :some_number, in: [1, 3]
+      end
+    end
+
+    it 'works with modifiers' do
+      expect_valid do
+        p [:some_number, :some_string], one_in: [2]
+        p [:some_number, :some_string], one_in: ['Robert']
+        p [:some_number, :some_string], none_in: ['Steve', 3]
+      end
+    end
+  end
+
+  describe 'pattern:' do
+    it 'works' do
+      expect_valid do
+        p :some_string, pattern: /^Rob/
+        p :some_string, pattern: /^Robert$/
+      end
+      expect_invalid do
+        p :some_string, pattern: /^Steve$/
+      end
+    end
+  end
+
+  describe 'items:' do
+    it 'works when given a Lambda' do
+      expect_valid do
+        p :array, items: ->(*args) {
+          p :a, in: [2, 3]
+          nil
+        }
+      end
+      expect_invalid do
+        p :array, items: ->(*args) {
+          p :a, in: [5]
+        }
+      end
+      expect_invalid do
+        p :array, items: ->(*args) {
+          'bob'
+        }
+      end
+    end
+    it 'works when given a Hash' do
+      # TODO
+    end
+  end
+
+  it 'supports a custom validator block' do
+    expect_valid do
+      p :some_string do |v|
+        nil
+      end
+    end
+
+    expect_invalid do
+      p :some_string do |v|
+        'Bad Length'
+      end
+    end
+  end
+
+  describe 'modifiers' do
+    let!(:value) do
+      {
+        a: 1,
+        b: 1,
+        c: 1,
+        x: nil,
+        y: nil,
+        z: nil,
+      }
+    end
+
+    def assert_modifier(modifier, keys, exp)
+      blk = ->(*args) {
+        p keys, :"#{modifier}_present"
+      }
+      exp ? expect_valid(&blk) : expect_invalid(&blk)
+    end
+
+    it 'the all modifier works as expected' do
+      assert_modifier(:all, %i[a b c], true)
+      assert_modifier(:all, %i[a b z], false)
+      assert_modifier(:all, %i[a y z], false)
+      assert_modifier(:all, %i[x y z], false)
+    end
+
+    it 'the onem modifier works as expected' do
+      assert_modifier(:onem, %i[a b c], false)
+      assert_modifier(:onem, %i[a b z], false)
+      assert_modifier(:onem, %i[a y z], true)
+      assert_modifier(:onem, %i[x y z], true)
+    end
+
+    it 'the onep modifier works as expected' do
+      assert_modifier(:onep, %i[a b c], true)
+      assert_modifier(:onep, %i[a b z], true)
+      assert_modifier(:onep, %i[a y z], true)
+      assert_modifier(:onep, %i[x y z], false)
+    end
+
+    it 'the one modifier works as expected' do
+      assert_modifier(:one, %i[a b c], false)
+      assert_modifier(:one, %i[a b z], false)
+      assert_modifier(:one, %i[a y z], true)
+      assert_modifier(:one, %i[x y z], false)
+    end
+
+    it 'the none modifier works as expected' do
+      assert_modifier(:none, %i[a b c], false)
+      assert_modifier(:none, %i[a b z], false)
+      assert_modifier(:none, %i[a y z], false)
+      assert_modifier(:none, %i[x y z], true)
+    end
+
+    it 'aliases work' do
+      assert_modifier(:any, %i[a b c], true)
+      assert_modifier(:any, %i[a b z], true)
+      assert_modifier(:any, %i[a y z], true)
+      assert_modifier(:any, %i[x y z], false)
+    end
+  end
+
+  describe 'nesting' do
+    it 'works' do
+      expect_valid do
+        p :hash, :present do
+          p :nested_hash do
+            p :value, in: [1]
+          end
+        end
+      end
+      expect_invalid do
+        p :hash, :present do
+          p :nested_hash do
+            p :value, not_in: [1]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'yaml'
+require 'database_cleaner'
+require 'with_model'
+
+require 'miscellany'
+
+FileUtils.makedirs('log')
+
+ActiveRecord::Base.logger = Logger.new('log/test.log')
+ActiveRecord::Base.logger.level = Logger::DEBUG
+ActiveRecord::Migration.verbose = false
+
+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])
+
+RSpec.configure do |config|
+  config.extend WithModel
+
+  # config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before do
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before do
+    DatabaseCleaner.start
+  end
+
+  config.after do
+    DatabaseCleaner.clean
+  end
+end
+
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"

metadata

@@ -1,157 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: miscellany
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Ethan Knapp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-17 00:00:00.000000000 Z
+date: 2021-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rspec-rails
-  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'
-- !ruby/object:Gem::Dependency
-  name: pg
-  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'
-- !ruby/object:Gem::Dependency
-  name: factory
-  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'
-- !ruby/object:Gem::Dependency
-  name: factory_bot
-  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'
-- !ruby/object:Gem::Dependency
-  name: timecop
+  name: rails
   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'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '6.3'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sinatra
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.3'
 - !ruby/object:Gem::Dependency
-  name: shoulda-matchers
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -165,49 +45,49 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: pry-nav
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: with_model
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -220,34 +100,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-- !ruby/object:Gem::Dependency
-  name: activerecord-import
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: 
 email:
 - eknapp@instructure.com
@@ -256,14 +108,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- app/views/miscellany/spa_page.html.erb
-- config/initializers/01_custom_preloaders.rb
-- config/initializers/arbitrary_prefetch.rb
 - 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/computed_columns.rb
 - lib/miscellany/active_record/custom_preloaders.rb
 - lib/miscellany/batch_processor.rb
 - lib/miscellany/batching_csv_processor.rb
@@ -273,6 +123,11 @@ files:
 - lib/miscellany/param_validator.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/param_validator_spec.rb
+- spec/spec_helper.rb
 homepage: https://instructure.com
 licenses: []
 metadata: {}
@@ -295,4 +150,9 @@ rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Gem for a bunch of random, re-usable Rails Concerns & Helpers
-test_files: []
+test_files:
+- spec/db/database.yml
+- spec/miscellany/arbitrary_prefetch_spec.rb
+- spec/miscellany/param_validator_spec.rb
+- spec/miscellany/computed_columns_spec.rb
+- spec/spec_helper.rb

data/app/views/miscellany/spa_page.html.erb

@@ -1,2 +0,0 @@
-<%= stylesheet_pack_tag pack_name %>
-<%= javascript_pack_tag pack_name %>

data/config/initializers/01_custom_preloaders.rb

@@ -1,2 +0,0 @@
-# This Preloader needs to run before any that will load Models
-Miscellany::CustomPreloaders.install

data/config/initializers/arbitrary_prefetch.rb

@@ -1 +0,0 @@
-Miscellany::ArbitraryPrefetch.install