Class: CC::Yaml::Nodes::Mapping

Inherits:
Node
  • Object
show all
Defined in:
lib/cc/yaml/nodes/mapping.rb

Direct Known Subclasses

Engine, OpenMapping, Root

Instance Attribute Summary collapse

Attributes inherited from Node

#parent

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Node

#dup, #error, #errors, #errors?, has_default?, #initialize, #method_missing, #nested_warning, #respond_to_missing?, #to_json, #to_s, #visit_child, #visit_scalar, #visit_sequence, #visit_unexpected, #warning, #warnings, #warnings?, #with_value

Constructor Details

This class inherits a constructor from CC::Yaml::Nodes::Node

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class CC::Yaml::Nodes::Node

Instance Attribute Details

#mapping ⇒ Object (readonly) Also known as: __getobj__

Returns the value of attribute mapping.



40
41
42
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 40

def mapping
  @mapping
end

Class Method Details

.aliases ⇒ Object 



12
13
14
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 12

def self.aliases
  @aliases ||= superclass.respond_to?(:aliases) ? superclass.aliases.dup : {}
end

.define_map_accessor(key) ⇒ Object 



30
31
32
33
34
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 30

def self.define_map_accessor(key)
  define_method(key)       { | | self[key]       } unless method_defined? key
  define_method("#{key}=") { |v| self[key] = v   } unless method_defined? "#{key}="
  define_method("#{key}?") { | | !!self[key]     } unless method_defined? "#{key}?"
end

.map(*list) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 16

def self.map(*list)
  options = Hash === list.last ? list.pop : {}
  list.each do |key|
    required     << key.to_s if options[:required]
    define_map_accessor(key)
    case options[:to]
    when Symbol then aliases[key.to_s] = options[:to].to_s
    when Module then mapping[key.to_s] = options[:to]
    when nil    then mapping[key.to_s] = Nodes[key]
    else raise ArgumentError, 'unexpected value for to: %p' % options[:to]
    end
  end
end

.mapping ⇒ Object 



4
5
6
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 4

def self.mapping
  @mapping ||= superclass.respond_to?(:mapping) ? superclass.mapping.dup : {}
end

.required ⇒ Object 



8
9
10
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 8

def self.required
  @required ||= superclass.respond_to?(:required) ? superclass.required.dup : []
end

.subnode_for(key) ⇒ Object 



36
37
38
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 36

def self.subnode_for(key)
  mapping[aliases.fetch(key.to_s, key.to_s)]
end

Instance Method Details

#==(other) ⇒ Object 



106
107
108
109
110
111
112
113
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 106

def ==(other)
  other = other.mapping if other.is_a? Mapping
  if other.respond_to? :to_hash and other.to_hash.size == @mapping.size
    other.to_hash.all? { |k, v| include?(k) and self[k] == v }
  else
    false
  end
end

#[](key) ⇒ Object 



76
77
78
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 76

def [](key)
  @mapping[mapped_key(key)]
end

#[]=(key, value) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 64

def []=(key, value)
  if mapped_key = mapped_key(key)
    unless value.is_a? Node
      node  = subnode_for(mapped_key)
      value = node if Parser::Ruby.new(value).parse(node)
    end
    @mapping[mapped_key] = value
  else
    warning("unexpected key %p, dropping", key)
  end
end

#accept_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 93

def accept_key?(key)
  self.class.mapping.include? key
end

#deep_verify ⇒ Object 



143
144
145
146
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 143

def deep_verify
  @mapping.each_value(&:deep_verify)
  super
end

#each_scalar(type = nil, &block) ⇒ Object 



159
160
161
162
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 159

def each_scalar(type = nil, &block)
  return enum_for(:each_scalar, type) unless block
  @mapping.each_value { |v| v.each_scalar(type, &block) }
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


84
85
86
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 84

def empty?
  @mapping.empty?
end

#include?(key) ⇒ Boolean

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 80

def include?(key)
  @mapping.include? mapped_key(key)
end

#inspect ⇒ Object 



102
103
104
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 102

def inspect
  @mapping.inspect
end

#mapped_key(key) ⇒ Object 



88
89
90
91
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 88

def mapped_key(key)
  key = self.class.aliases.fetch(key.to_s, key.to_s)
  key if accept_key?(key)
end

#nested_warnings(*prefix) ⇒ Object 



148
149
150
151
152
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 148

def nested_warnings(*prefix)
  @mapping.inject(super) do |list, (key, value)|
    list = value.nested_warnings(*prefix, key) + list
  end
end

#prepare ⇒ Object 



43
44
45
46
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 43

def prepare
  @mapping = {}
  super
end

#subnode_for(key) ⇒ Object 



97
98
99
100
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 97

def subnode_for(key)
  type = self.class.subnode_for(key)
  type.new(self) if type
end

#verify ⇒ Object 



115
116
117
118
119
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 115

def verify
  verify_errors
  verify_required
  verify_errors
end

#verify_errors ⇒ Object 



134
135
136
137
138
139
140
141
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 134

def verify_errors
  @mapping.delete_if do |key, value|
    if value.errors?
      warning "dropping %p section: %s", key, value.errors.join(', ')
      true
    end
  end
end

#verify_required ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 121

def verify_required
  self.class.required.each do |key|
    next if @mapping.include? key
    type = self.class.subnode_for(key)
    if type.has_default?
      warning "missing key %p, defaulting to %p", key, type.default
      @mapping[key] = type.new(self)
    else
      error "missing key %p", key
    end
  end
end

#visit_key_value(visitor, key, value) ⇒ Object 



57
58
59
60
61
62
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 57

def visit_key_value(visitor, key, value)
  return warning("unexpected key %p, dropping", key) unless node = subnode_for(key)
  warning("has multiple %p entries, keeping last entry", key) if self[key]
  self[key] = node
  visitor.accept(node, value)
end

#visit_mapping(visitor, value) ⇒ Object 



48
49
50
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 48

def visit_mapping(visitor, value)
  visitor.apply_mapping(self, value)
end

#visit_pair(visitor, key, value) ⇒ Object 



52
53
54
55
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 52

def visit_pair(visitor, key, value)
  key = visitor.generate_key(self, key)
  visit_key_value(visitor, key, value)
end

#with_value!(value) ⇒ Object 



154
155
156
157
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 154

def with_value!(value)
  value = value.mapping while value.is_a? Mapping
  value.each { |key, value| self[key] = value }
end