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

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

Direct Known Subclasses

Engine, OpenMapping, Ratings, 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 



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

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 



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

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

#[]=(key, value) ⇒ Object 



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

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) 


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

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

#check_duplicates(key) ⇒ Object 



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

def check_duplicates(key)
  warning("has multiple %p entries, keeping last entry", key) if self[key]
end

#deep_verify ⇒ Object 



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

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

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



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

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) 


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

def empty?
  @mapping.empty?
end

#include?(key) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#inspect ⇒ Object 



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

def inspect
  @mapping.inspect
end

#mapped_key(key) ⇒ Object 



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

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 



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

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

#set_warnings(key) ⇒ Object 



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

def set_warnings(key)
  if subnode_for(key)
    check_duplicates(key)
  elsif key == "languages"
    warning("analysis by language not available via CLI. Use engines configuration instead.")
  else
    warning("unexpected key %p, dropping", key)
  end
end

#subnode_for(key) ⇒ Object 



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

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

#verify ⇒ Object 



130
131
132
133
134
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 130

def verify
  verify_errors
  verify_required
  verify_errors
end

#verify_errors ⇒ Object 



149
150
151
152
153
154
155
156
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 149

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 



136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 136

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 



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

def visit_key_value(visitor, key, value)
  node = subnode_for(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
56
57
 
# File 'lib/cc/yaml/nodes/mapping.rb', line 52

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

#with_value!(value) ⇒ Object 



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

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