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

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

Constant Summary collapse

INCOMPATIBLE_KEYS_WARNING = 
"Use either a languages key or an engines key, but not both. They are mutually exclusive.".freeze

Instance Attribute Summary collapse

Attributes inherited from Node

#parent

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Node

#as_json, #dup, #error, #errors, #errors?, has_default?, #initialize, #method_missing, #nested_warning, #respond_to_missing?, #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.



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

def mapping
  @mapping
end

Class Method Details

.aliases ⇒ Object 



14
15
16
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 14

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

.define_map_accessor(key) ⇒ Object 



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

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 



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

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 



6
7
8
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 6

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

.prefix_scalar(key = nil, *types) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 42

def self.prefix_scalar(key = nil, *types)
  @prefix_scalar ||= superclass.respond_to?(:prefix_scalar) ? superclass.prefix_scalar : nil
  if key
    @prefix_scalar = key.to_s
    define_method(:visit_scalar) do |visitor, type, value, _implicit = true|
      return super(visitor, type, value, _implicit = true) if types.any? && !types.include?(type)
      visit_key_value(visitor, key, value)
    end
  end
  @prefix_scalar
end

.required ⇒ Object 



10
11
12
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 10

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

.subnode_for_key(key) ⇒ Object 



38
39
40
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 38

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

Instance Method Details

#==(other) ⇒ Object 



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

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 



95
96
97
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 95

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

#[]=(key, value) ⇒ Object 



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

def []=(key, value)
  if mapped_key = mapped_key(key)
    @mapping[mapped_key] = value
  else
    warning("unexpected key %p, dropping", key)
  end
end

#accept_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


112
113
114
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 112

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

#deep_verify ⇒ Object 



162
163
164
165
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 162

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

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



178
179
180
181
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 178

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) 


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

def empty?
  @mapping.empty?
end

#include?(key) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#inspect ⇒ Object 



121
122
123
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 121

def inspect
  @mapping.inspect
end

#mapped_key(key) ⇒ Object 



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

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 



167
168
169
170
171
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 167

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

#prepare ⇒ Object 



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

def prepare
  @mapping = {}
  super
end

#set_warnings(visitor, key, value) ⇒ Object 



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

def set_warnings(visitor, key, value)
  if subnode_for(visitor, key, value)
    check_duplicates(key)
  else
    warning("unexpected key %p, dropping", key)
  end
end

#subnode_for(_visitor, key, _value) ⇒ Object 



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

def subnode_for(_visitor, key, _value)
  type = self.class.subnode_for_key(key)
  type.new(self) if type
end

#verify ⇒ Object 



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

def verify
  verify_errors
  verify_required
  verify_errors
end

#verify_errors ⇒ Object 



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

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

#verify_required ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 140

def verify_required
  self.class.required.each do |key|
    next if @mapping.include? key
    type = self.class.subnode_for_key(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 



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

def visit_key_value(visitor, key, value)
  node = subnode_for(visitor, key, value)
  assign_node_and_visit(node, key, value, visitor)
end

#visit_mapping(visitor, value) ⇒ Object 



62
63
64
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 62

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

#visit_pair(visitor, key, value) ⇒ Object 



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

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

#with_value!(value) ⇒ Object 



173
174
175
176
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 173

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