Class: Nori::XMLUtilityNode

Inherits:
Object
  • Object
show all
Defined in:
lib/nori/xml_utility_node.rb

Overview

This is a slighly modified version of the XMLUtilityNode from merb.devjavu.com/projects/merb/ticket/95 ([email protected])

John Nunemaker: It’s mainly just adding vowels, as I ht cd wth n vwls :) This represents the hard part of the work, all I did was change the underlying parser.

Constant Summary collapse

XS_TIME =

Simple xs:time Regexp. Valid xs:time formats 13:20:00 1:20 PM 13:20:30.5555 1:20 PM and 30.5555 seconds 13:20:00-05:00 1:20 PM, US Eastern Standard Time 13:20:00+02:00 1:20 PM, Central European Standard Time 13:20:00Z 1:20 PM, Coordinated Universal Time (UTC) 13:20:30.5555Z 1:20 PM and 30.5555 seconds, Coordinated Universal Time (UTC) 00:00:00 midnight 24:00:00 midnight

/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/
XS_DATE =

Simple xs:date Regexp. Valid xs:date formats 2004-04-12 April 12, 2004 -0045-01-01 January 1, 45 BC 12004-04-12 April 12, 12004 2004-04-12-05:00 April 12, 2004, US Eastern Standard Time, which is 5 hours behind Coordinated Universal Time (UTC) 2004-04-12+02:00 April 12, 2004, Central European Summer Time, which is 2 hours ahead of Coordinated Universal Time (UTC) 2004-04-12Z April 12, 2004, Coordinated Universal Time (UTC)

/^-?\d{4}-\d{2}-\d{2}(?:Z|[+-]\d{2}:?\d{2})?$/
XS_DATE_TIME =

Simple xs:dateTime Regexp. Valid xs:dateTime formats 2004-04-12T13:20:00 1:20 pm on April 12, 2004 2004-04-12T13:20:15.5 1:20 pm and 15.5 seconds on April 12, 2004 2004-04-12T13:20:00-05:00 1:20 pm on April 12, 2004, US Eastern Standard Time 2004-04-12T13:20:00+02:00 1:20 pm on April 12, 2004, Central European Summer Time 2004-04-12T13:20:15.5-05:00 1:20 pm and 15.5 seconds on April 12, 2004, US Eastern Standard Time 2004-04-12T13:20:00Z 1:20 pm on April 12, 2004, Coordinated Universal Time (UTC) 2004-04-12T13:20:15.5Z 1:20 pm and 15.5 seconds on April 12, 2004, Coordinated Universal Time (UTC)

/^-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options, name, attributes = {}) ⇒ XMLUtilityNode

Returns a new instance of XMLUtilityNode.



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/nori/xml_utility_node.rb', line 86

def initialize(options, name, attributes = {})
  @options = options
  @name = Nori.hash_key(name, options)

  if converter = options[:convert_attributes_to]
    intermediate = attributes.map {|k, v| converter.call(k, v) }.flatten
    attributes = Hash[*intermediate]
  end

  # leave the type alone if we don't know what it is
  @type = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]

  @nil_element = false
  attributes.keys.each do |key|
    if result = /^((.*):)?nil$/.match(key)
      @nil_element = attributes.delete(key) == "true"
      attributes.delete("xmlns:#{result[2]}") if result[1]
    end
    attributes.delete(key) if @options[:delete_namespace_attributes] && key[/^(xmlns|xsi)/]
  end
  @attributes = undasherize_keys(attributes)
  @children = []
  @text = false
end

Instance Attribute Details

#attributes ⇒ Object

Returns the value of attribute attributes.



111
112
113
 
# File 'lib/nori/xml_utility_node.rb', line 111

def attributes
  @attributes
end

#children ⇒ Object

Returns the value of attribute children.



111
112
113
 
# File 'lib/nori/xml_utility_node.rb', line 111

def children
  @children
end

#name ⇒ Object

Returns the value of attribute name.



111
112
113
 
# File 'lib/nori/xml_utility_node.rb', line 111

def name
  @name
end

#type ⇒ Object

Returns the value of attribute type.



111
112
113
 
# File 'lib/nori/xml_utility_node.rb', line 111

def type
  @type
end

Class Method Details

.available_typecasts ⇒ Object 



64
65
66
 
# File 'lib/nori/xml_utility_node.rb', line 64

def self.available_typecasts
  @@available_typecasts
end

.available_typecasts=(obj) ⇒ Object 



68
69
70
 
# File 'lib/nori/xml_utility_node.rb', line 68

def self.available_typecasts=(obj)
  @@available_typecasts = obj
end

.typecasts ⇒ Object 



56
57
58
 
# File 'lib/nori/xml_utility_node.rb', line 56

def self.typecasts
  @@typecasts
end

.typecasts=(obj) ⇒ Object 



60
61
62
 
# File 'lib/nori/xml_utility_node.rb', line 60

def self.typecasts=(obj)
  @@typecasts = obj
end

Instance Method Details

#add_node(node) ⇒ Object 



125
126
127
128
 
# File 'lib/nori/xml_utility_node.rb', line 125

def add_node(node)
  @text = true if node.is_a? String
  @children << node
end

#advanced_typecasting(value) ⇒ Object 



214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/nori/xml_utility_node.rb', line 214

def advanced_typecasting(value)
  split = value.split
  return value if split.size > 1

  case split.first
    when "true"       then true
    when "false"      then false
    when XS_DATE_TIME then try_to_convert(value) {|x| DateTime.parse(x)}
    when XS_DATE      then try_to_convert(value) {|x| Date.parse(x)}
    when XS_TIME      then try_to_convert(value) {|x| Time.parse(x)}
    else                   value
  end
end

#inner_html ⇒ Object

Get the inner_html of the REXML node.



237
238
239
 
# File 'lib/nori/xml_utility_node.rb', line 237

def inner_html
  @children.join
end

#prefixed_attribute_name(attribute) ⇒ Object 



120
121
122
123
 
# File 'lib/nori/xml_utility_node.rb', line 120

def prefixed_attribute_name(attribute)
  return attribute unless @options[:convert_tags_to].respond_to? :call
  @options[:convert_tags_to].call(attribute)
end

#prefixed_attributes ⇒ Object 



113
114
115
116
117
118
 
# File 'lib/nori/xml_utility_node.rb', line 113

def prefixed_attributes
  attributes.inject({}) do |memo, (key, value)|
    memo[prefixed_attribute_name("@#{key}")] = value
    memo
  end
end

#to_hash ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/nori/xml_utility_node.rb', line 130

def to_hash
  if @type == "file"
    f = StringIOFile.new((@children.first || '').unpack('m').first)
    f.original_filename = attributes['name'] || 'untitled'
    f.content_type = attributes['content_type'] || 'application/octet-stream'
    return { name => f }
  end

  if @text
    t = typecast_value(inner_html)
    t = advanced_typecasting(t) if t.is_a?(String) && @options[:advanced_typecasting]

    if t.is_a?(String)
      t = StringWithAttributes.new(t)
      t.attributes = attributes
    end

    return { name => t }
  else
    #change repeating groups into an array
    groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }

    out = nil
    if @type == "array"
      out = []
      groups.each do |k, v|
        if v.size == 1
          out << v.first.to_hash.entries.first.last
        else
          out << v.map{|e| e.to_hash[k]}
        end
      end
      out = out.flatten

    else # If Hash
      out = {}
      groups.each do |k,v|
        if v.size == 1
          out.merge!(v.first)
        else
          out.merge!( k => v.map{|e| e.to_hash[k]})
        end
      end
      out.merge! prefixed_attributes unless attributes.empty?
      out = out.empty? ? @options[:empty_tag_value] : out
    end

    if @type && out.nil?
      { name => typecast_value(out) }
    else
      { name => out }
    end
  end
end

#to_html ⇒ String Also known as: to_s

Converts the node into a readable HTML node.

Returns:

  • (String) —

    The HTML node in text form.



244
245
246
247
 
# File 'lib/nori/xml_utility_node.rb', line 244

def to_html
  attributes.merge!(:type => @type ) if @type
  "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
end

#typecast_value(value) ⇒ Integer, ...

Note:

If self does not have a “type” key, or if it’s not one of the options specified above, the raw value will be returned.

Typecasts a value based upon its type. For instance, if node has #type == “integer”, #=> 12]}

Parameters:

  • value (String) —

    The value that is being typecast.

Returns:

  • (Integer, TrueClass, FalseClass, Time, Date, Object) —

    The result of typecasting value.



208
209
210
211
212
 
# File 'lib/nori/xml_utility_node.rb', line 208

def typecast_value(value)
  return value unless @type
  proc = self.class.typecasts[@type]
  proc.nil? ? value : proc.call(value)
end

#undasherize_keys(params) ⇒ Object

Take keys of the form foo-bar and convert them to foo_bar



229
230
231
232
233
234
 
# File 'lib/nori/xml_utility_node.rb', line 229

def undasherize_keys(params)
  params.keys.each do |key, value|
    params[key.tr("-", "_")] = params.delete(key)
  end
  params
end