advanced_ar 0.1.0

data/lib/advanced_ar/batched_destruction.rb

@@ -0,0 +1,94 @@
+module AdvancedAR::BatchedDestruction
+  extend ActiveSupport::Concern
+
+  included do
+    define_model_callbacks :bulk_destroy
+    define_model_callbacks :destroy_batch
+
+    before_destroy_batch do
+      # TODO Delete Dependant Relations
+      model_class.reflections.each do |name, reflection|
+        options = reflection.options
+      end
+    end
+  end
+
+  class_methods do
+    def bulk_destroy(**kwargs)
+      return to_sql
+      bulk_destroy_internal(self, **kwargs)
+    end
+
+    # Hook for performing the actual deletion of items, may be used to facilitate soft-deletion.
+    # Must not call destroy().
+    # Default implementation is to delete the batch using delete_all(id: batch_ids).
+    def destroy_bulk_batch(batch, options)
+      delete_ids = batch.map(&:id)
+      where(id: delete_ids).delete_all()
+    end
+
+    private
+
+    def bulk_destroy_internal(items, **kwargs)
+      options = {}
+      options.merge!(kwargs)
+      ClassCallbackExector.run_callbacks(model_class, :bulk_destroy, options: options) do
+        if items.respond_to?(:find_in_batches)
+          items.find_in_batches do |batch|
+            _destroy_batch(batch, options)
+          end
+        else
+          _destroy_batch(items, options)
+        end
+      end
+    end
+
+    def _destroy_batch(batch, options)
+      ClassCallbackExector.run_callbacks(model_class, :destroy_batch, {
+        model_class: model_class,
+        batch: batch,
+      }) do
+        model_class.destroy_bulk_batch(batch, options)
+      end
+    end
+
+    private
+
+    def model_class
+      try(:model) || self
+    end
+  end
+
+  def destroy(*args, legacy: false, **kwargs)
+    if legacy
+      super(*args)
+    else
+      self.class.send(:bulk_destroy_internal, [self], **kwargs)
+    end
+  end
+
+  private
+
+  # These classes are some Hackery to allow us to use callbacks against the Model classes instead of Model instances
+  class ClassCallbackExector
+    include ActiveSupport::Callbacks
+
+    attr_reader :callback_class
+    delegate :__callbacks, to: :callback_class
+    delegate_missing_to :callback_class
+
+    def initialize(cls, env)
+      @callback_class = cls
+      env.keys.each do |k|
+        define_singleton_method(k) do
+          env[k]
+        end
+      end
+      @options = options
+    end
+
+    def self.run_callbacks(cls, callback, env={}, &blk)
+      new(cls, env).run_callbacks(callback, &blk)
+    end
+  end
+end

data/lib/advanced_ar/batching_csv_processor.rb

@@ -0,0 +1,86 @@
+module AdvancedAR
+  class BatchingCsvProcessor
+    attr_accessor :csv, :file_name
+
+    class RowError < StandardError; end
+
+    def initialize(csv, file_name: nil)
+      @csv = csv
+      @file_name = file_name
+    end
+
+    def process_in_batches(&blk)
+      batch = BatchProcessor.new(&blk)
+      CSV.new(csv, headers: true, header_converters: :symbol).each.with_index do |row, line|
+        row[:line_number] = line + 1
+        next unless validate_line(row)
+
+        batch << row
+      end
+      batch.flush
+    end
+
+    def get_row_errors(row); end
+
+    def find_or_init(_row)
+      raise NotImplementedError
+    end
+
+    def apply_row_to_model(_row, _instance)
+      raise NotImplementedError
+    end
+
+    def log_line_error(message, line_number, **kwargs)
+      raise NotImplementedError
+    end
+
+    def validate_line(row)
+      errors = get_row_errors(row) || []
+      if errors.present?
+        log_line_error(errors[0], row[:line_number])
+        false
+      else
+        true
+      end
+    end
+
+    def batch_rows_to_models(rows)
+      rows.map { |row| build_model_from_row(row) }.reject! { |inst| inst.nil? || !inst.changed? }
+    end
+
+    def build_model_from_row(row)
+      model = find_or_init(row)
+      apply_row_to_model(row, model)
+      return nil if model.respond_to?(:discarded_at) && model.discarded_at.present? && !model.persisted?
+
+      model
+    rescue ActiveRecord::RecordNotFound, RowError => err
+      log_line_error(err.message, row[:line_number], exception: err)
+      nil
+    rescue StandardError => err
+      log_line_error('An Internal Error Occurred', row[:line_number], exception: err)
+      Raven.capture_exception(err)
+      nil
+    end
+
+    def map_defined_columns(row, map)
+      newh = {}
+      map.each do |newk, oldk|
+        next unless row.include?(oldk)
+
+        newh[newk] = row[oldk]
+      end
+      newh
+    end
+
+    def self.file_matches?(file)
+      header = file.readline.strip.split(',')
+      file.try(:rewind)
+      headers_match?(header)
+    end
+
+    def self.headers_match?(headers)
+      (self::HEADERS - headers).empty?
+    end
+  end
+end

data/lib/advanced_ar/custom_preloaders.rb

@@ -0,0 +1,57 @@
+# Example Usage (Preloading items with reference to the same Polymorphic Object):
+#
+# has_many :related_objects, -> (self) { where(poly_type: self.poly_type, poly_id: self.poly_id) }, preloader: 'RelatedObjectPreloader'
+#
+# class RelatedObjectPreloader < ActiveRecord::Associations::Preloader::Association
+#   def run(preloader)
+#     @preloaded_records = []
+#     owners.group_by(&:poly_type).each do |type, owner_group|
+#       ids = owner_group.map(&:poly_id)
+#
+#       ids_to_priors = {}
+#       scope = Poly.scope_for_association.where(poly_type: self.poly_type, poly_id: self.poly_id)
+#       scope.find_each do |pa|
+#         ids_to_priors[pa.poly_id] ||= []
+#         ids_to_priors[pa.poly_id] << pa
+#         @preloaded_records << pa
+#       end
+#
+#       owner_group.each do |owner|
+#         priors = ids_to_priors[owner.poly_id] || []
+#
+#         association = owner.association(reflection.name)
+#         association.loaded!
+#         association.target = priors
+#
+#         # association.set_inverse_instance(record)
+#       end
+#     end
+#   end
+# end
+#
+module AdvancedAR::CustomPreloaders
+  module AssociationBuilderExtension
+    def self.build(model, reflection); end
+
+    def self.valid_options
+      [:preloader]
+    end
+  end
+
+  module PreloaderExtension
+    def preloader_for(reflection, owners)
+      cust_preloader = reflection.options[:preloader]
+      if cust_preloader.present?
+        cust_preloader = cust_preloader.constantize if cust_preloader.is_a?(String)
+        cust_preloader
+      else
+        super
+      end
+    end
+  end
+
+  def self.install
+    ActiveRecord::Associations::Builder::Association.extensions << AssociationBuilderExtension
+    ActiveRecord::Associations::Preloader.prepend(CustomPreloaders::PreloaderExtension)
+  end
+end

data/lib/advanced_ar/param_validator.rb

@@ -0,0 +1,421 @@
+module AdvancedAR
+  class ParamValidator
+    attr_accessor :context, :options, :errors
+
+    delegate_missing_to :context
+
+    TIME_TYPES = [Date, DateTime, Time].freeze
+
+    CHECKS = %i[type specified present default transform in block items pattern].freeze
+    NON_PREFIXED = %i[default transform type message].freeze
+    PREFIXES = %i[all onem onep one none].freeze
+    PREFIX_ALIASES = { any: :onep, not: :none }.freeze
+    ALL_PREFIXES = (PREFIXES + PREFIX_ALIASES.keys).freeze
+    VALID_FLAGS = %i[present specified].freeze
+
+    def initialize(block, context, parameters = nil, options = nil)
+      @block = block
+      @context = context
+      @params = parameters || context.params
+      @subkeys = []
+      @options = options || {}
+      @errors = {}
+      @explicit_parameters = []
+    end
+
+    def self.check(params, context: nil, &blk)
+      pv = new(blk, context, params)
+      pv.apply_checks
+      pv.errors
+    end
+
+    def self.assert(params, context: nil, handle:, &blk)
+      errors = check(params, context: context, &blk)
+      if errors.present?
+        handle.call(errors)
+      else
+        params
+      end
+    end
+
+    def apply_checks(&blk)
+      blk ||= @block
+      args = trim_arguments(blk, [params, @subkeys[-1]])
+      instance_exec(*args, &blk)
+    end
+
+    def parameter(param_keys, *args, **kwargs, &blk)
+      param_keys = Array(param_keys)
+      opts = normalize_opts(*args, **kwargs, &blk)
+
+      checks = {}
+      PREFIXES.each do |pfx|
+        pfx_keys = opts[pfx]&.keys&.select { |k| opts[pfx][k] } || []
+        pfx_keys.each do |k|
+          checks[k] = pfx # TODO: Support filters connected to multiple prefixes
+        end
+        # TODO: warn if pfx != :all && param_keys.length == 1
+      end
+      NON_PREFIXED.each do |k|
+        checks[k] = nil
+      end
+
+      all_results = {}
+      param_keys.each do |pk|
+        check_results = all_results[pk] = {}
+        run_check = ->(check, &blk) { exec_check(check_results, check, checks, options: opts, &blk) }
+
+        exec_check(check_results, :type) { coerce_type(params, pk, opts) } || next
+
+        run_check[:specified] { params.key?(pk) || 'must be specified' } || next
+        run_check[:present] { params[pk].present? || 'must be present' } || next
+
+        # Set Default
+        if params[pk].nil? && !opts[:default].nil?
+          params[pk] ||= opts[:default].respond_to?(:call) ? opts[:default].call : opts[:default]
+          next # We can assume that the default value is allowed
+        end
+
+        # Apply Transform
+        params[pk] = opts[:transform].to_proc.call(params[pk]) if params.include?(pk) && opts[:transform]
+
+        next if params[pk].nil?
+
+        run_check[:pattern] do |pattern|
+          return true if params[pk].to_s.match?(pattern)
+
+          "must match pattern: #{pattern.inspect}"
+        end
+
+        run_check[:in] do |one_of|
+          next true if one_of.include?(params[pk])
+
+          if one_of.is_a?(Range)
+            "must be between: #{one_of.begin}..#{one_of.end}"
+          else
+            "must be one of: #{one_of.to_a.join(', ')}"
+          end
+        end
+
+        # 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
+        end
+
+        # Nested 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) }
+              end
+            else
+              raise "items: validator can only be used with Arrays"
+            end
+          end
+        end
+      end
+
+      final_errors = {}
+      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)
+          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?
+          end
+        else
+          counts = check_pass_count(check, all_results)
+          field_key = param_keys.join(', ')
+          string_prefixes = {
+            onep: 'One or more of',
+            onem: 'At most one of',
+            one: 'Exactly one of',
+          }
+
+          if (counts[:passed] != 1 && check_prefix == :one) ||
+            (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}")
+          end
+        end
+      end
+
+      @errors = merge_error_hashes(@errors, final_errors)
+      final_errors
+    end
+
+    alias p parameter
+
+    protected
+
+    def check_pass_count(check, all_results)
+      counts = { passed: 0, failed: 0, skipped: 0 }
+      all_results.each do |_field, field_results|
+        result = field_results[check]
+        key = if result.nil?
+                :skipped
+              elsif result.present?
+                :failed
+              else
+                :passed
+              end
+        counts[key] += 1
+      end
+      counts
+    end
+
+    def exec_check(state, check, checks_to_run = nil, options: nil, &blk)
+      return true if checks_to_run && !checks_to_run[check] && !NON_PREFIXED.include?(check)
+
+      # TODO: Support Running checks of the same type for different prefixes
+
+      check_prefixes = NON_PREFIXED.include?(check) ? [nil] : Array(checks_to_run&.[](check))
+      return true unless check_prefixes.present?
+
+      check_prefixes.each do |check_prefix|
+        initial_errors = @errors
+        @errors = []
+        prefix_options = (check_prefix.nil? ? options : options&.[](check_prefix)) || {}
+        args = trim_arguments(blk, [prefix_options[check]])
+
+        result = yield(*args)
+        result = "failed validation #{check}" if result == false
+
+        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
+      end
+
+      !state[check].present?
+    end
+
+    def coerce_type(params, key, opts)
+      value = params[key]
+      return nil if value.nil? || !opts[:type].present?
+
+      types = Array(opts[:type])
+      types.each do |t|
+        params[key] = coerce_single_type(value, t, opts)
+        return true
+      rescue ArgumentError, TypeError => err
+      end
+
+      "'#{value}' could not be cast to a #{types.join(' or a ')}"
+    end
+
+    def coerce_single_type(param, type, options)
+      return param if (param.is_a?(type) rescue false)
+
+      if (param.is_a?(Array) && type != Array) || ((param.is_a?(Hash) || param.is_a?(ActionController::Parameters)) && type != Hash)
+        raise ArgumentError
+      end
+      return param if (param.is_a?(ActionController::Parameters) && type == Hash rescue false)
+
+      # Primitives
+      return Integer(param) if type == Integer
+      return Float(param) if type == Float
+      return Float(param) if type == Numeric
+      return String(param) if type == String
+
+      # Date/Time
+      if TIME_TYPES.include? type
+        if options[:format].present?
+          return type.strptime(param, options[:format])
+        else
+          return type.parse(param)
+        end
+      end
+
+      # Arrays/Hashes
+      raise ArgumentError if (type == Array || type == Hash) && !param.respond_to?(:split)
+      return Array(param.split(options[:delimiter] || ',')) if type == Array
+      return Hash[param.split(options[:delimiter] || ',').map { |c| c.split(options[:separator] || ':') }] if type == Hash
+
+      # Booleans
+      if [TrueClass, FalseClass, :boolean, :bool].include?(type)
+        return false if /^(false|f|no|n|0)$/i === param.to_s
+        return true if /^(true|t|yes|y|1)$/i === param.to_s
+
+        raise ArgumentError
+      end
+
+      # BigDecimals
+      if type == BigDecimal
+        param = param.delete('$,').strip.to_f if param.is_a?(String)
+        return BigDecimal(param, (options[:precision] || DEFAULT_PRECISION))
+      end
+      nil
+    end
+
+    def normalize_opts(*args, **kwargs, &blk)
+      # Stage 1 - Convert args to kwargs
+      args, norm = convert_positional_args(args, kwargs)
+      if blk.present?
+        type = args.delete(:items) ? :all_items : :all_block
+        set_hash_key(norm, type, blk)
+      end
+      set_hash_key(norm, :type, args.pop(0)) if args.present?
+
+      # Stage 2
+      norm = convert_flags(norm)
+
+      # Stage 3
+      norm = convert_prefixed_keys(norm)
+
+      extra_kwargs = norm.keys - PREFIXES - NON_PREFIXED
+      raise ArgumentError, "Unrecognized postitional arguments: #{args.inspect}" if args.present?
+      raise ArgumentError, "Unrecognized keyword arguments: #{extra_kwargs.inspect}" if extra_kwargs.present?
+
+      norm
+    end
+
+    def convert_positional_args(args, kwargs)
+      dest_hash = { **kwargs }
+      args = args.reject do |arg|
+        next false unless arg.is_a?(Symbol)
+
+        flag, pfx = split_key(arg)
+        next false unless VALID_FLAGS.include?(flag) && (pfx.nil? || PREFIXES.include?(pfx))
+
+        set_hash_key(dest_hash, :"#{pfx || 'all'}_#{flag}", true)
+        true
+      end
+      [args, dest_hash]
+    end
+
+    def convert_flags(h)
+      dest_hash = {}
+      h.each do |k, v|
+        if VALID_FLAGS.include?(k) && normalize_prefix(v)
+          set_hash_key(dest_hash, :"#{normalize_prefix(v)}_#{k}", true)
+        else
+          dest_hash[k] = v
+        end
+      end
+      dest_hash
+    end
+
+    def convert_prefixed_keys(h)
+      dest_hash = {}
+
+      h.each do |k, v|
+        flag, pfx = split_key(k)
+        if !CHECKS.include?(flag)
+          dest_hash[k] = v
+        elsif NON_PREFIXED.include?(flag)
+          # TODO: Raise warning if pfx
+          dest_hash[k] = v
+        elsif normalize_prefix(flag)
+          dest_hash[flag] = merge_hashes(dest_hash[normalize_prefix(flag)] || {}, v)
+        elsif pfx.nil? || PREFIXES.include?(pfx)
+          pfx ||= :all
+          dest_hash[pfx] ||= {}
+          set_hash_key(dest_hash[pfx], flag, v)
+        else
+          dest_hash[k] = v
+        end
+      end
+
+      dest_hash
+    end
+
+    def normalize_prefix(prefix)
+      prefix = PREFIX_ALIASES[prefix] if PREFIX_ALIASES.include?(prefix)
+      return nil unless PREFIXES.include?(prefix)
+
+      prefix
+    end
+
+    def split_key(key)
+      skey = key.to_s
+      ALL_PREFIXES.each do |pfx|
+        spfx = pfx.to_s
+        next unless skey.starts_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)
+      end
+      h1
+    end
+
+    def set_hash_key(h, k, v)
+      k = k.to_sym
+      # TODO: warn if h[k].present?
+      h[k] = v
+    end
+
+    def trim_arguments(blk, args)
+      return args if blk.arity.negative?
+      args[0..(blk.arity.abs - 1)]
+    end
+  end
+end