class Dry::Types::Schema::Key

def call_safe(input, &block)
  type.call_safe(input, &block)
end

def call_unsafe(input)
  type.call_unsafe(input)
end

def decorate?(response)
  response.is_a?(Type)
end

def initialize(type, name, required: Undefined, **options)
  required = Undefined.default(required) do
    type.meta.fetch(:required) { !type.meta.fetch(:omittable, false) }
  end
  unless name.is_a?(::Symbol)
    raise ArgumentError, "Schemas can only contain symbol keys, #{name.inspect} given"
  end
  super(type, name, required: required, **options)
  @name = name
end

def lax
  __new__(type.lax).required(false)
end

def maybe
  __new__(type.maybe)
end

def meta(data = Undefined)
  if Undefined.equal?(data) || !data.key?(:omittable)
    super
  else
    self.class.warn(
      "Using meta for making schema keys is deprecated, " \
      "please use .omittable or .required(false) instead" \
      "\n" + Core::Deprecations::STACK.()
    )
    super.required(!data[:omittable])
  end
end

def omittable
  required(false)
end

def optional
  __new__(type.optional)
end

def required(required = Undefined)
  if Undefined.equal?(required)
    options.fetch(:required)
  else
    with(required: required)
  end
end

def required?
  options.fetch(:required)
end

def to_ast(meta: true)
  [
    :key,
    [
      name,
      required,
      type.to_ast(meta: meta)
    ]
  ]
end

def try(input, &block)
  type.try(input, &block)
end