lib/datacaster/predefined.rb in datacaster-3.1.1 vs lib/datacaster/predefined.rb in datacaster-3.1.2

@@ -102,10 +102,56 @@
 
     def transform_to_value(value)
       transform { value }
     end
 
+    # min_amount: has_relation(:min_amount, :>, :max_amount)
+
+    def relate(left, op, right, error_key: nil)
+      error_keys = ['.relate', 'datacaster.errors.relate']
+      additional_vars = {}
+
+      {left: left, op: op, right: right}.each do |k, v|
+        if [String, Symbol, Integer].any? { |c| v.is_a?(c) }
+          additional_vars[k] = v
+        elsif !Datacaster.instance?(v)
+          raise RuntimeError, "expected #{k} to be String, Symbol, Integer or Datacaster::Base, but got #{v.inspect}", caller
+        end
+      end
+
+      if op.is_a?(Integer)
+        raise RuntimeError, "expected op to be String, Symbol or Datacaster::Base, but got #{op.inspect}", caller
+      end
+
+      if [left, op, right].none? { |x| Datacaster.instance?(x) }
+        error_keys.unshift(".#{left}.#{op}.#{right}")
+      end
+      error_keys.unshift(error_key) if error_key
+
+      left = pick(left) unless Datacaster.instance?(left)
+      right = pick(right) unless Datacaster.instance?(right)
+      op_caster = op
+      unless Datacaster.instance?(op_caster)
+        op_caster = check { |(l, r)| l.respond_to?(op) && l.public_send(op, r) }
+      end
+
+      cast do |value|
+        left_result = left.(value)
+        next left_result unless left_result.valid?
+        i18n_var!(:left, left_result.value) unless additional_vars.key?(:left)
+
+        right_result = right.(value)
+        next right_result unless right_result.valid?
+        i18n_var!(:right, right_result.value) unless additional_vars.key?(:right)
+
+        result = op_caster.([left_result.value, right_result.value])
+        next Datacaster.ErrorResult([I18nValues::Key.new(error_keys)]) unless result.valid?
+
+        Datacaster.ValidResult(value)
+      end.i18n_vars(additional_vars)
+    end
+
     def remove
       transform { Datacaster.absent }
     end
 
     def pass
@@ -203,14 +249,20 @@
 
     # 'hash' would be a bad method name, because it would override built in Object#hash
     def hash_value(error_key = nil)
       error_keys = ['.hash_value', 'datacaster.errors.hash_value']
       error_keys.unshift(error_key) if error_key
-      check(error_key) { |x| x.is_a?(Hash) }
+      check { |x| x.is_a?(Hash) }.i18n_key(*error_keys)
     end
 
     def hash_with_symbolized_keys(error_key = nil)
       hash_value(error_key) & transform { |x| x.symbolize_keys }
+    end
+
+    def included_in(*values, error_key: nil)
+      error_keys = ['.included_in', 'datacaster.errors.included_in']
+      error_keys.unshift(error_key) if error_key
+      check { |x| values.include?(x) }.i18n_key(*error_keys, reference: values.map(&:to_s).join(', '))
     end
 
     def integer(error_key = nil)
       error_keys = ['.integer', 'datacaster.errors.integer']
       error_keys.unshift(error_key) if error_key