contracts_at_paths.rb

require 'dry/validation'

# enter two numbers, to guess the rule (their sum must be even)

class EvenContract < Dry::Validation::Contract
  params do
    required(:arg1).filled(:integer)
    required(:arg2).filled(:integer)
  end
  
  rule(:arg1, :arg2) do
    key(:arg2).failure('is not suitable') unless (values[:arg1] + values[:arg2]).even?
  end
end

input = { arg1: "1", arg2: "2" }

EvenContract.new.call(input).errors.to_h # => {:arg2=>["is not suitable"]}

# How would we be able to process this input only using dry-validation, and without re-writing the rules?
guesses_input = { guess1: { arg1: "1", arg2: "2" }, guess2: { arg1: "2", arg2: "4" } }

# With the code spike here https://gist.github.com/ianwhite/a32fcd439020ea07ed1fe3243152274f
# we can do this: (this is ct working code)

guesses_contract = ComposableContract.compose do
  contract EvenContract, path: :guess1
  contract EvenContract, path: :guess2
end

result = guesses_contract.call(guesses_input)  #<ComposableContract::ResultSet:0x00007f9fb97a17e0 @success=false, @message_set=nil, @results=[#<ComposableContract::ResultAtPath result=#<Dry::Validation::Result{:arg1=>1, :arg2=>2} errors={:arg2=>["is not suitable"]}> path=[:guess1]>, #<ComposableContract::ResultAtPath result=#<Dry::Validation::Result{:arg1=>2, :arg2=>4} errors={}> path=[:guess2]>], @values=#<Dry::Validation::Values data={:guess1=>{:arg1=>1, :arg2=>2}, :guess2=>{:arg1=>2, :arg2=>4}}>>

result.success? # => false
result.values # => #<Dry::Validation::Values data={:guess1=>{:arg1=>1, :arg2=>2}, :guess2=>{:arg1=>2, :arg2=>4}}>
result.errors # => #<Dry::Validation::MessageSet messages=[#<Dry::Validation::Message text="is not suitable" path=[:guess1, :arg2] meta={}>] options={}>
result.errors.to_h # => {:guess1=>{:arg2=>["is not suitable"]}}

pasteable_in_irb_example.rb

# this file can be pasted into irb if dry-validation is available
# the example above is at the bottom of the file

require 'dry/validation'

module ComposableContract
  # this is the interface that we care about, we provide the rest of
  # result's interface where required
  ResultType = Types.Interface(:to_h, :errors)

  # this is our representation of a path, we use Schema::Path to
  # convert where necessary
  PathType = Types::Array.of(Types::Symbol)

  CheckType = Types.Interface(:call)
  ChecksType = Types::Array(CheckType)
  ChecksDictType = Types::Hash.map(Types::Symbol, CheckType)

  def self.compose(&block)
    builder(&block).to_contract
  end

  def self.builder(&block)
    DSL.new(&block)
  end

  def self.included(klass)
    klass.extend ClassInterface
  end

  # if included in a contract, start the composition with the contract
  # result, otherwise start from scratch
  def call(input)
    result = super if method(:call).super_method
    result = composition.call(input, result) if composition
    result
  end

  private

  def composition
    self.class.instance_variable_get(:@composition)
  end

  module ClassInterface
    def compose(&block)
      @composition = ComposableContract.compose(&block)
    end
  end

  # a step contains a contract, optional checks, and optional path
  class Step < Dry::Struct
    attribute :contract, Types.Interface(:call) | Types.Instance(Class)
    attribute :checks, ChecksType
    attribute :path, PathType.optional

    # collaborates to add results of this contract to the result set
    def call(input, result_set)
      return result_set unless checks_pass?(result_set)

      the_input    = path ? input.dig(*path) : input
      the_contract = contract.respond_to?(:call) ? contract : contract.new
      the_result   = the_contract.call(the_input)

      result_set.add_result(the_result, path)
    end

    private

    def checks_pass?(result_set)
      check_evaluator = CheckEvaluator.new(result_set.values)
      checks.all? { |c| check_evaluator.instance_exec(&c) }
    end

    CheckEvaluator = Struct.new(:values)
  end

  # a composition is an ordered list of steps, quacks like a Contract
  # but allows for an initial result to be passed to #call
  class Composition < Dry::Struct
    attribute :steps, Types.Array(Step)

    # note optional extra argument result
    def call(input, result = nil)
      starting_result_set = ResultSet.new(result ? [result] : [])

      steps.each_with_object(starting_result_set) do |step, result_set|
        step.call(input, result_set)
      end.freeze
    end
  end

  # DSL exposes #steps (an ordered list of steps), suitable for a Composition
  class DSL
    # can be passed a 1-arity or zero arity block
    def initialize(&block)
      @steps       = [] # 3-tuples of [contract, path, checks]
      @checks_dict = {}

      block.arity == 1 ? block.call(self) : instance_exec(&block) if block
    end

    # before returning steps, resolve any named checks
    def steps
      @steps.map do |(contract, path, checks)|
        checks = checks.map { |c| c.is_a?(Symbol) ? @checks_dict.fetch(c) : c }
        Step.new(contract: contract, checks: checks, path: path)
      end
    end

    def to_contract
      Composition.new(steps: steps)
    end

    def contract(contract, check: nil, path: nil)
      path = Dry::Schema::Path[path].to_a if path
      path = [*@current_path, *path] if path || @current_path
      checks = [*@current_checks, *check]

      @steps << [contract, path, checks]
    end

    def check(*checks)
      prev_checks = @current_checks
      @current_checks = [*@current_checks, *checks]
      yield
    ensure
      @current_checks = prev_checks
    end

    def path(path)
      prev_path = @current_path
      @current_path = [*@current_path, *Dry::Schema::Path[path].to_a]
      yield
    ensure
      @current_path = prev_path
    end

    def register_check(name, &block)
      @checks_dict = ChecksDictType[@checks_dict.merge(name => block)]
    end
  end

  # quacks like a Dry::Validation::Result, except #add_error.
  # Can be composed of results (#add_result) optionally mounted at paths.
  # its values and errors are merged from all of its results
  class ResultSet
    extend Forwardable

    def initialize(results = [])
      @success     = nil
      @message_set = nil
      @results     = []

      results.each { |r| add_result(r) }
    end

    def add_result(result, path = nil)
      @values  = nil
      @success = nil

      result = ResultType[result]
      result = ResultAtPath[result: result, path: path] if path
      @results << result

      self
    end

    def freeze
      @results.map(&:freeze)
      success?
      message_set.freeze
      values.freeze
      super
    end

    def values
      @values ||= Dry::Validation::Values.new(merge_all_values)
    end

    def_delegators :values, :[], :key?, :to_h

    def errors(new_options = {})
      new_options.empty? ? message_set : collate_all_messages(new_options)
    end

    def error?(key)
      message_set.any? do |msg|
        Dry::Schema::Path[msg.path].include?(Dry::Schema::Path[key])
      end
    end

    def base_error?(key)
      message_set.any? do |msg|
        key_path = Dry::Schema::Path[key]
        err_path = Dry::Schema::Path[msg.path]

        return false unless key_path.same_root?(err_path)

        key_path == err_path
      end
    end

    def success?
      return @success unless @success.nil?

      @success = message_set.empty?
    end

    def failure?
      !success?
    end

    private

    def message_set
      # memoize result errors only if underlying results are all frozen
      @message_set || collate_all_messages.tap do |message_set|
        @message_set = message_set unless @results.all?(&:frozen?)
      end
    end

    def collate_all_messages(options = {})
      empty_message_set = Dry::Validation::MessageSet.new([], options)
      @results.each_with_object(empty_message_set) do |result, errors|
        result.errors(options).each { |m| errors.add(m) }
      end
    end

    def merge_all_values
      @results.reduce({}) { |data, result| data.merge(result.to_h) }
    end
  end

  # api private
  class ResultAtPath < Dry::Struct
    attribute :result, ResultType
    attribute :path, PathType

    def to_h
      @to_h ||= hash_at_path
    end

    def errors(new_options = {})
      new_options.empty? ? message_set : errors_at_path(new_options)
    end

    def freeze
      result.freeze
      message_set.freeze
      to_h.freeze
      super
    end

    def add_error(*args)
      result.add_error(*args)
    end

    private

    def message_set
      # memoize result errors only if underlying result is frozen
      @message_set || errors_at_path.tap do |message_set|
        @message_set = message_set unless result.frozen?
      end
    end

    def hash_at_path
      data = path.reverse.reduce({}) { |m, key| { key => m } }
      data.dig(*path).merge!(result.to_h)
      data
    end

    def errors_at_path(options = {})
      empty_message_set = Dry::Validation::MessageSet.new([], options)
      result.errors(options).each_with_object(empty_message_set) do |m, errors|
        errors.add Dry::Validation::Message[m.text, path + m.path, m.meta]
      end
    end
  end
end

###########

class EvenContract < Dry::Validation::Contract
  params do
    required(:arg1).filled(:integer)
    required(:arg2).filled(:integer)
  end
  
  rule(:arg1, :arg2) do
    key(:arg2).failure('is not suitable') unless (values[:arg1] + values[:arg2]).even?
  end
end

input = { arg1: "1", arg2: "2" }

EvenContract.new.call(input).errors.to_h # => {:arg2=>["is not suitable"]}

# How would we be able to process this input only using dry-validation, and without re-writing the rules?
guesses_input = { guess1: { arg1: "1", arg2: "2" }, guess2: { arg1: "2", arg2: "4" } }

# With the code spike here https://gist.github.com/ianwhite/a32fcd439020ea07ed1fe3243152274f
# we can do this: (this is ct working code)

guesses_contract = ComposableContract.compose do
  contract EvenContract, path: :guess1
  contract EvenContract, path: :guess2
end

result = guesses_contract.call(guesses_input)  #<ComposableContract::ResultSet:0x00007f9fb97a17e0 @success=false, @message_set=nil, @results=[#<ComposableContract::ResultAtPath result=#<Dry::Validation::Result{:arg1=>1, :arg2=>2} errors={:arg2=>["is not suitable"]}> path=[:guess1]>, #<ComposableContract::ResultAtPath result=#<Dry::Validation::Result{:arg1=>2, :arg2=>4} errors={}> path=[:guess2]>], @values=#<Dry::Validation::Values data={:guess1=>{:arg1=>1, :arg2=>2}, :guess2=>{:arg1=>2, :arg2=>4}}>>

result.success? # => false
result.values # => #<Dry::Validation::Values data={:guess1=>{:arg1=>1, :arg2=>2}, :guess2=>{:arg1=>2, :arg2=>4}}>
result.errors # => #<Dry::Validation::MessageSet messages=[#<Dry::Validation::Message text="is not suitable" path=[:guess1, :arg2] meta={}>] options={}>
result.errors.to_h # => {:guess1=>{:arg2=>["is not suitable"]}}