Class: Dry::Schema::KeyMap

Inherits:
Object
  • Object
show all
Extended by:
Core::Cache
Includes:
Enumerable
Defined in:
lib/dry/schema/key_map.rb

Overview

Represents a list of keys defined by the DSL

KeyMap objects expose an API for introspecting schema keys and the ability to rebuild an input hash using configured coercer function.

Instances of this class are used as the very first step by the schema processors.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(keys) ⇒ KeyMap

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.

Set key objects



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/dry/schema/key_map.rb', line 53

def initialize(keys)
  @keys = keys.map { |key|
    case key
    when Hash
      root, rest = key.flatten
      Key::Hash[root, members: KeyMap[*rest]]
    when Array
      root, rest = key
      Key::Array[root, member: KeyMap[*rest]]
    when Key
      key
    else
      Key[key]
    end
  }
end

Instance Attribute Details

#keys ⇒ Array<Key> (readonly)

Returns A list of defined key objects.

Returns:

  • (Array<Key>) —

    A list of defined key objects



25
26
27
 
# File 'lib/dry/schema/key_map.rb', line 25

def keys
  @keys
end

Class Method Details

.[](*keys) ⇒ KeyMap

Coerce a list of key specs into a key map

Examples:

KeyMap[:id, :name]
KeyMap[:title, :artist, tags: [:name]]
KeyMap[:title, :artist, [:tags]]

Returns:



37
38
39
 
# File 'lib/dry/schema/key_map.rb', line 37

def self.[](*keys)
  new(keys)
end

.new(*args) ⇒ KeyMap

Build new, or returned a cached instance of a key map

Parameters:

  • args (Array<Symbol>, Array, Hash<Symbol=>Array>)

Returns:



46
47
48
 
# File 'lib/dry/schema/key_map.rb', line 46

def self.new(*args)
  fetch_or_store(*args) { super }
end

Instance Method Details

#+(other) ⇒ KeyMap

Return a new key map merged with the provided one

Parameters:

  • other (KeyMap, Array) —

    Either a key map or an array with key specs

Returns:



120
121
122
 
# File 'lib/dry/schema/key_map.rb', line 120

def +(other)
  self.class.new(keys + other.to_a)
end

#coercible(&coercer) ⇒ KeyMap

Return a new key map that is configured to coerce keys using provided coercer function

Returns:



88
89
90
 
# File 'lib/dry/schema/key_map.rb', line 88

def coercible(&coercer)
  self.class.new(map { |key| key.coercible(&coercer) })
end

#dump ⇒ Array

Dump keys to their spec format

Returns:

  • (Array) 


134
135
136
 
# File 'lib/dry/schema/key_map.rb', line 134

def dump
  keys.map(&:dump)
end

#each(&block) ⇒ Object

Iterate over keys



111
112
113
 
# File 'lib/dry/schema/key_map.rb', line 111

def each(&block)
  keys.each(&block)
end

#inspect ⇒ String

Return a string representation of a key map

Returns:

  • (String) 


127
128
129
 
# File 'lib/dry/schema/key_map.rb', line 127

def inspect
  "#<#{self.class}[#{keys.map(&:dump).map(&:inspect).join(", ")}]>"
end

#stringified ⇒ KeyMap

Return a new key map with stringified keys

A stringified key map is suitable for reading hashes with string keys

Returns:



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

def stringified
  self.class.new(map(&:stringified))
end

#to_dot_notation ⇒ 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. 



104
105
106
 
# File 'lib/dry/schema/key_map.rb', line 104

def to_dot_notation
  @to_dot_notation ||= map(&:to_dot_notation).flatten
end

#write(source, target = EMPTY_HASH.dup) ⇒ Hash

Write a new hash based on the source hash

Parameters:

  • source (Hash) —

    The source hash

  • target (Hash) (defaults to: EMPTY_HASH.dup) —

    The target hash

Returns:

  • (Hash) 


78
79
80
81
 
# File 'lib/dry/schema/key_map.rb', line 78

def write(source, target = EMPTY_HASH.dup)
  each { |key| key.write(source, target) }
  target
end