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

Attributes included from Decorator

#type

Attributes included from Options

#options

Instance Method Summary collapse

Methods included from Printable

#to_s

Methods included from Builder

#&, #>, #constrained, #constrained_type, #constructor, #constructor_type, #default, #enum, #fallback, #|

Methods included from Decorator

#constrained?, #default?, #respond_to_missing?, #to_proc

Methods included from Options

#with

Methods included from Type

#call, #valid?

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

Instance Method Details

#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

#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

#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

#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