class Dry::Schema::Processor

def <<(step)
  steps << step
  self
end

def call(input)
  Result.new(input, message_compiler: message_compiler) do |result|
    steps.each do |step|
      output = step.(result)
      result.replace(output) if output.is_a?(::Hash)
    end
  end
end

def config
  @config ||= rule_applier.config
end

def define(&block)
  @definition ||= DSL.new(
    processor_type: self, parent: superclass.definition, **config, &block
  )
  self
end

def filter_rules?
  @filter_rules_predicate ||= schema_dsl.filter_rules?
end

def filter_schema
  @filter_schema ||= schema_dsl.filter_schema
end

def inspect
  <<~STR.strip
    #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.map { |k, v| [k, v.to_s] }.to_h}>
  STR
end

def key_map
  @key_map ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
end

def message_compiler
  rule_applier.message_compiler
end

def new(options = nil, &block)
  if options || block
    processor = super
    yield(processor) if block
    processor
  elsif definition
    definition.call
  else
    raise ArgumentError, 'Cannot create a schema without a definition'
  end
end

def rule_applier
  @rule_applier ||= steps.last
end

def rules
  rule_applier.rules
end

def to_ast
  rule_applier.to_ast
end

def to_proc
  ->(input) { call(input) }
end

def type_schema
  @type_schema ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
end