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) 00:00:00 midnight 24:00:00 midnight

/^\d{2}:\d{2}:\d{2}[Z\.\-\+]?\d*:?\d*$/
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*:?\d*$/
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)

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

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.



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

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.



109
110
111
 
# File 'lib/nori/xml_utility_node.rb', line 109

def attributes
  @attributes
end

#children ⇒ Object

Returns the value of attribute children.



109
110
111
 
# File 'lib/nori/xml_utility_node.rb', line 109

def children
  @children
end

#name ⇒ Object

Returns the value of attribute name.



109
110
111
 
# File 'lib/nori/xml_utility_node.rb', line 109

def name
  @name
end

#type ⇒ Object

Returns the value of attribute type.



109
110
111
 
# File 'lib/nori/xml_utility_node.rb', line 109

def type
  @type
end

Class Method Details

.available_typecasts ⇒ Object 



62
63
64
 
# File 'lib/nori/xml_utility_node.rb', line 62

def self.available_typecasts
  @@available_typecasts
end

.available_typecasts=(obj) ⇒ Object 



66
67
68
 
# File 'lib/nori/xml_utility_node.rb', line 66

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

.typecasts ⇒ Object 



54
55
56
 
# File 'lib/nori/xml_utility_node.rb', line 54

def self.typecasts
  @@typecasts
end

.typecasts=(obj) ⇒ Object 



58
59
60
 
# File 'lib/nori/xml_utility_node.rb', line 58

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

Instance Method Details

#add_node(node) ⇒ Object 



123
124
125
126
 
# File 'lib/nori/xml_utility_node.rb', line 123

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

#advanced_typecasting(value) ⇒ Object 



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

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.



235
236
237
 
# File 'lib/nori/xml_utility_node.rb', line 235

def inner_html
  @children.join
end

#prefixed_attribute_name(attribute) ⇒ Object 



118
119
120
121
 
# File 'lib/nori/xml_utility_node.rb', line 118

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 



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

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

#to_hash ⇒ Object 



128
129
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
 
# File 'lib/nori/xml_utility_node.rb', line 128

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? ? nil : 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.



242
243
244
245
 
# File 'lib/nori/xml_utility_node.rb', line 242

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.



206
207
208
209
210
 
# File 'lib/nori/xml_utility_node.rb', line 206

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



227
228
229
230
231
232
 
# File 'lib/nori/xml_utility_node.rb', line 227

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