You are viewing documentation for version 1 of the AWS SDK for Ruby. Version 2 documentation can be found here.

Class: AWS::Core::XML::Frame

Inherits:
Object
  • Object
show all
Defined in:
lib/aws/core/xml/frame.rb

Direct Known Subclasses

RootFrame

Constant Summary

TRANSLATE_DIGITS = 
['0123456789'.freeze, ('X'*10).freeze]
EASY_FORMAT = 
"XXXX-XX-XXTXX:XX:XX.XXXZ".freeze
DATE_PUNCTUATION = 
['-:.TZ'.freeze, (' '*5).freeze]

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(root_frame, parent_frame, element_name, rules) ⇒ Frame

Returns a new instance of Frame



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/aws/core/xml/frame.rb', line 29

def initialize root_frame, parent_frame, element_name, rules

  @root_frame = root_frame
  @parent_frame = parent_frame
  @element_name = element_name
  @rules = rules
  @rules[:children] ||= {}

  @data = {}.merge(rules[:defaults] || {})
  @text = nil

  # initialize values for child frames of special types (e.g.
  # lists, maps, and forced elements)
  known_child_frames.each do |child_frame|
    context = data_context_for(child_frame)
    if child_frame.list?
      context[child_frame.ruby_name] = []
    elsif child_frame.map?
      context[child_frame.ruby_name] = {}
    elsif child_frame.forced?
      context[child_frame.ruby_name] = child_frame.value
    end
  end

end

Instance Attribute Details

#element_name ⇒ Object (readonly)

Returns the value of attribute element_name



57
58
59
 
# File 'lib/aws/core/xml/frame.rb', line 57

def element_name
  @element_name
end

#parent_frame ⇒ Object (readonly)

Returns the value of attribute parent_frame



56
57
58
 
# File 'lib/aws/core/xml/frame.rb', line 56

def parent_frame
  @parent_frame
end

#root_frame ⇒ Object (readonly)

Returns the value of attribute root_frame



55
56
57
 
# File 'lib/aws/core/xml/frame.rb', line 55

def root_frame
  @root_frame
end

#rules ⇒ Object (readonly)

Returns the value of attribute rules



58
59
60
 
# File 'lib/aws/core/xml/frame.rb', line 58

def rules
  @rules
end

Instance Method Details

#add_text(chars) ⇒ Object 



163
164
165
166
 
# File 'lib/aws/core/xml/frame.rb', line 163

def add_text chars
  @text ||= ''
  @text << chars
end

#build_child_frame(element_name) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/aws/core/xml/frame.rb', line 78

def build_child_frame element_name
  # if element_name should be wrapped
  #   build a frame for the wrapper
  #   build a child frame from the wrapper
  # else
  Frame.new(root_frame, self, element_name, rules_for(element_name))
end

#close ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/aws/core/xml/frame.rb', line 105

def close
  # some xml elements should be indexed at the root level
  # The :index rule determines the name of this index
  # and what keys the data should be indexed as (one element
  # can be indexed under multiple keys).  The index value
  # is always the element itself.
  if index = @rules[:index]
    index_keys_for(index) do |key|
      root_frame.add_to_index(index[:name], key, data)
    end
  end
end

#consume_child_frame(child_frame) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/aws/core/xml/frame.rb', line 86

def consume_child_frame child_frame

  child_frame.close

  return if child_frame.ignored?

  ruby_name = child_frame.ruby_name
  value = child_frame.value
  context = data_context_for(child_frame)

  if child_frame.list?
    context[ruby_name] << value
  elsif map = child_frame.map?
    context[ruby_name][child_frame.map_key] = child_frame.map_value
  else
    context[ruby_name] = value
  end
end

#data ⇒ Object 



60
61
62
 
# File 'lib/aws/core/xml/frame.rb', line 60

def data
  ignored? ? parent_frame.data : @data
end

#forced? ⇒ Boolean

Returns:

  • (Boolean) 


192
193
194
 
# File 'lib/aws/core/xml/frame.rb', line 192

def forced?
  @rules[:force]
end

#ignored? ⇒ Boolean

Returns:

  • (Boolean) 


188
189
190
 
# File 'lib/aws/core/xml/frame.rb', line 188

def ignored?
  @rules[:ignore]
end

#index_keys_for(index_opts, &block) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/aws/core/xml/frame.rb', line 118

def index_keys_for index_opts, &block

  # simple (single) key
  if key = index_opts[:key]
    yield(data[key])
    return
  end

  # composite key, joined by ":"
  if parts = index_opts[:keys]
    composite_key = parts.map{|part| data[part] }.join(":")
    yield(composite_key)
    return
  end

  # multiple keys, collected from the given path
  if path = index_opts[:key_path]
    keys_from_path(data, path.dup, &block)
    return
  end

  raise "missing require index rule option, :key, :keys or :key_path"

end

#keys_from_path(data, path, &block) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/aws/core/xml/frame.rb', line 143

def keys_from_path data, path, &block

  step = path.shift
  value = data[step]

  if path.empty?
    yield(value)
    return
  end

  if value.is_a?(Array)
    value.each do |v|
      keys_from_path(v, path.dup, &block)
    end
  else
    keys_from_path(value, path.dup, &block)
  end

end

#known_child_frames ⇒ Object

The list of child frames that have customizations (rules), all other children will be parsed using standard rules



74
75
76
 
# File 'lib/aws/core/xml/frame.rb', line 74

def known_child_frames
  rules[:children].keys.map {|name| build_child_frame(name) }
end

#list? ⇒ Boolean

Returns:

  • (Boolean) 


196
197
198
 
# File 'lib/aws/core/xml/frame.rb', line 196

def list?
  @rules[:list]
end

#map? ⇒ Boolean

Returns:

  • (Boolean) 


200
201
202
 
# File 'lib/aws/core/xml/frame.rb', line 200

def map?
  @rules[:map]
end

#ruby_name ⇒ Object 



64
65
66
 
# File 'lib/aws/core/xml/frame.rb', line 64

def ruby_name
  rules[:rename] || root_frame.inflect(element_name)
end

#rules_for(child_element_name) ⇒ Object 



68
69
70
 
# File 'lib/aws/core/xml/frame.rb', line 68

def rules_for child_element_name
  rules[:children][child_element_name] || {}
end

#value ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/aws/core/xml/frame.rb', line 168

def value
  if !data.empty?
    data[:encoding] == 'base64' ?  Base64.decode64(@text.strip) : data
  elsif @text.nil?
    rules[:type] == :boolean ? false : nil
  else
    case rules[:type]
    when nil, :string then @text
    when :datetime    then datetime_like_value(DateTime, :civil)
    when :time        then datetime_like_value(Time, :utc)
    when :integer     then @text.to_i
    when :float       then @text.to_f
    when :boolean     then @text == 'true'
    when :blob        then Base64.decode64(@text)
    when :symbol      then Core::Inflection.ruby_name(@text).to_sym
    else raise "unhandled type"
    end
  end
end

#wrapped? ⇒ Boolean Also known as: wrapper

Returns:

  • (Boolean) 


204
205
206
 
# File 'lib/aws/core/xml/frame.rb', line 204

def wrapped?
  @rules[:wrap]
end