Proper nested records uniqueness validation

Test pass: test_create_duplicate_for_persisted_target_should_fail

app/models/validations/nested_uniqueness.rb

@@ -0,0 +1,104 @@
+module Validations::NestedUniqueness
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :nested_uniqueness_options, instance_writer: false, default: {}
+    class_attribute :nested_uniqueness_duplicates, instance_writer: false, default: {}
+  end
+
+  module ClassMethods
+    def validates_nested_uniqueness_for(*attr_names)
+      options = {scope: nil}
+      options.update(attr_names.extract_options!)
+      options.assert_valid_keys(:scope)
+
+      if association_name = attr_names.shift
+        if attr_names.empty?
+          raise ArgumentError, "No unique attributes given for name `#{association_name}'."
+        else
+          options[:attributes] = attr_names
+
+          nested_uniqueness_options = self.nested_uniqueness_options.dup
+          nested_uniqueness_options[association_name.to_sym] = options
+          self.nested_uniqueness_options = nested_uniqueness_options
+
+          before_validation :before_validation_nested_uniqueness
+          after_validation :after_validation_nested_uniqueness
+
+          reflection = reflect_on_association(association_name)
+          reflection.klass.class_eval <<-eoruby, __FILE__, __LINE__ + 1
+            validate do
+              if #{reflection.inverse_of.name}
+                   .nested_uniqueness_duplicates[:#{reflection.name}].include?(self)
+                errors.add(:base, :duplicated_record) 
+              end
+            end
+          eoruby
+        end
+      end
+    end
+  end
+
+  private
+
+  def before_validation_nested_uniqueness
+    nested_uniqueness_options.each do |association_name, options|
+      collection = send(association_name)
+      was_loaded = collection.loaded?
+      records = collection.target.select(&:changed?)
+
+      preserved_records = records.reject(&:marked_for_destruction?)
+      scope = options[:scope]&.map { |attr| [attr, preserved_records.map(&attr).uniq] }.to_h
+
+      seen = {}
+      nested_uniqueness_duplicates[association_name] = []
+      collection.where(scope).scoping do
+        collection.reject(&:marked_for_destruction?).each do |r|
+          key = options[:attributes].map { |attr| r.send(attr) }
+          if seen[key]
+            nested_uniqueness_duplicates[association_name] << (r.changed? ? r : seen[key])
+          else
+            seen[key] = r
+          end
+        end
+      end
+      unless was_loaded
+        collection.proxy_association.reset
+        records.each { |r| collection.proxy_association.add_to_target(r) }
+      end
+    end
+  end
+
+  def after_validation_nested_uniqueness
+    nested_uniqueness_duplicates.clear
+  end
+
+  #def before_validation_nested_uniqueness do
+  #  was_loaded = targets.loaded?
+  #  records = targets.target.select(&:changed?)
+  #  dates = records.reject(&:marked_for_destruction?).map(&:effective_from).uniq
+  #  seen = {}
+  #  @duplicated_records = []
+  #  targets.where(effective_from: dates).scoping do
+  #    targets.reject(&:marked_for_destruction?).each do |t|
+  #      key = [t.effective_from, t.quantity_id, t.item_type, t.item_id, t.scope]
+  #      if seen[key]
+  #        @duplicated_records << (t.changed? ? t : seen[key])
+  #      else
+  #        seen[key] = t
+  #      end
+  #    end
+  #  end
+  #  unless was_loaded
+  #    targets.proxy_association.reset
+  #    records.each { |t| targets.proxy_association.add_to_target(t) }
+  #  end
+  #end
+
+  #def after_validation_nested_uniqueness do
+  #  @duplicated_records = nil
+  #end
+  #def validate_nested_targets_uniqueness(record)
+  #  record.errors.add(:base, :duplicated_target) if @duplicated_records.include?(record)
+  #end
+end