class Dry::Schema::Processor

def call(input)
  Result.new(input, message_compiler: message_compiler) do |result|
    steps.call(result)
  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
  steps[:key_coercer].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
  steps[:rule_applier]
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
  steps[:value_coercer].type_schema
end