Class: Dry::Types::Schema::Key Private

Inherits:
Object
  • Object
show all
Includes:
Builder, Decorator, Printable, Type
Defined in:
lib/dry/types/schema/key.rb,
lib/dry/types/extensions/maybe.rb

This class is part of a private API. You should avoid using this class if possible, as it may be removed or be changed in the future.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(type, name, required: Undefined, **options) ⇒ Key

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of Key.



26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/dry/types/schema/key.rb', line 26

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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Dry::Types::Decorator

Instance Attribute Details

#name ⇒ Symbol (readonly)

Returns:

  • (Symbol) 


23
24
25
 
# File 'lib/dry/types/schema/key.rb', line 23

def name
  @name
end

#options ⇒ Hash (readonly) Originally defined in module Options

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

#type ⇒ Type (readonly) Originally defined in module Decorator

Returns:

Instance Method Details

#&(other) ⇒ Intersection, Intersection::Constrained Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Compose two types into an Intersection type

Parameters:

Returns:

#>(other) ⇒ Implication, Implication::Constrained Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Compose two types into an Implication type

Parameters:

Returns:

#call(input = Undefined) ⇒ Object #call(input = Undefined) {|output| ... } ⇒ Object Also known as: [] Originally defined in module Type

Apply type to a value

Overloads:

  • #call(input = Undefined) ⇒ Object

    Possibly unsafe coercion attempt. If a value doesn't match the type, an exception will be raised.

    Parameters:

    • input (Object) (defaults to: Undefined)

    Returns:

    • (Object)
  • #call(input = Undefined) {|output| ... } ⇒ Object

    When a block is passed, #call will never throw an exception on failed coercion, instead it will call the block.

    Parameters:

    • input (Object) (defaults to: Undefined)

    Yield Parameters:

    • output (Object) —

      Partially coerced value

    Returns:

    • (Object)

#call_safe(input, &block) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



40
41
42
 
# File 'lib/dry/types/schema/key.rb', line 40

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

#call_unsafe(input) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



45
46
47
 
# File 'lib/dry/types/schema/key.rb', line 45

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

#constrained(options) ⇒ Constrained Originally defined in module Builder

Turn a type into a constrained type

Parameters:

Returns:

#constrained? ⇒ Boolean Originally defined in module Decorator

Returns:

  • (Boolean)

#constrained_type ⇒ Class Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Class)

#constructor(constructor = nil, **options, &block) ⇒ Constructor Also known as: append, prepend, >>, << Originally defined in module Builder

Define a constructor for the type

Parameters:

  • constructor (#call, nil) (defaults to: nil)
  • options (Hash)
  • block (#call, nil)

Returns:

#constructor_type ⇒ Class Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Class)

#default(input = Undefined, options = EMPTY_HASH, &block) ⇒ Default Originally defined in module Builder

Turn a type into a type with a default value

Parameters:

  • input (Object) (defaults to: Undefined)
  • block (#call, nil)
  • [Boolean] (Hash) —

    a customizable set of options

Returns:

Raises:

#default? ⇒ Boolean Originally defined in module Decorator

Returns:

  • (Boolean)

#enum(*values) ⇒ Enum Originally defined in module Builder

Define an enum on top of the existing type

Parameters:

Returns:

#fallback(value = Undefined, shared: false, &_fallback) ⇒ Constructor Originally defined in module Builder

Use the given value on type mismatch

Parameters:

  • value (Object) (defaults to: Undefined)
  • fallback (#call, nil)
  • [Boolean] (Hash) —

    a customizable set of options

Returns:

#lax ⇒ Lax

Turn key into a lax type. Lax types are not strict hence such keys are not required

Returns:



99
100
101
 
# File 'lib/dry/types/schema/key.rb', line 99

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

#maybe ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



107
108
109
 
# File 'lib/dry/types/extensions/maybe.rb', line 107

def maybe
  __new__(type.maybe)
end

#meta(data = Undefined) ⇒ Object

See Also:



131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/dry/types/schema/key.rb', line 131

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

#omittable ⇒ Dry::Types::Schema::Key

Make key not required

Returns:



90
91
92
 
# File 'lib/dry/types/schema/key.rb', line 90

def omittable
  required(false)
end

#optional ⇒ Key

Make wrapped type optional

Returns:



108
109
110
 
# File 'lib/dry/types/schema/key.rb', line 108

def optional
  __new__(type.optional)
end

#required ⇒ Boolean #required(required) ⇒ Dry::Types::Schema::Key

Control whether the key is required

Overloads:



77
78
79
80
81
82
83
 
# File 'lib/dry/types/schema/key.rb', line 77

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

#required? ⇒ Boolean

Whether the key is required in schema input

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/dry/types/schema/key.rb', line 61

def required?
  options.fetch(:required)
end

#respond_to_missing?(meth, include_private = false) ⇒ Boolean Originally defined in module Decorator

Parameters:

  • meth (Symbol)
  • include_private (Boolean) (defaults to: false)

Returns:

  • (Boolean)

#to_ast(meta: true) ⇒ Array

Dump to internal AST representation

Returns:



117
118
119
120
121
122
123
124
125
126
 
# File 'lib/dry/types/schema/key.rb', line 117

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

#to_proc ⇒ Proc Originally defined in module Decorator

Wrap the type with a proc

Returns:

  • (Proc)

#to_s ⇒ String Also known as: inspect Originally defined in module Printable

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (String)

#try(input, &block) ⇒ Object

See Also:



52
53
54
 
# File 'lib/dry/types/schema/key.rb', line 52

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

#valid?(input = Undefined) ⇒ Boolean Also known as: === Originally defined in module Type

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Whether a value is a valid member of the type

Returns:

  • (Boolean)

#with(**new_options) ⇒ Type Originally defined in module Options

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • new_options (Hash)

Returns:

#|(other) ⇒ Sum, Sum::Constrained Originally defined in module Builder

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Compose two types into a Sum type

Parameters:

Returns: