Use Ruby? Like to parse XML--who doesn't? Using Ruby's XmlSimple library? Don't do that... like, ever, ever..
EVER.
But if you must, take heed of the following advice.
Test #1: What do the Ruby defaults do?
Before we get started, let's define a few snippets of XML to be used in the following examples:
xml1:
<xml>
<head/>
<list>
<item frames='1' id='2'>who</item>
</list>
</xml>
and xml2:
<xml>
<head/>
<list>
<item frames='3' id='1'>asdf</item>
<item frames='1' id='2'>who</item>
</list>
</xml>
Two very simple, well-formed, non-semantic chunks of XML that contain attributes and empty elements
Now let's take a look at XmlSimple in straight up Ruby:
irb#1(main):010:0> pp XmlSimple.xml_in(xml1)
=> {"head"=>[{}], "list"=>[{"item"=>[{"id"=>"2", "content"=>"who",
"frames"=>"1"}]}]}
Ugh, every key returns an array of hashes so you'll
end up doing things like hash["head"].first or hash["item"][2] to
access values. It looks nasty, but it actually makes sense since there's no way to know a
priori whether "list" or "head" contain 1 or many items.
Let's try that with the XmlSimple option of forcearray => false.
irb#1(main):011:0> xo = XmlSimple.xml_in(xml1, "forcearray" => false)
=> {"head"=>{}, "list"=>{"item"=>{"id"=>"2", "content"=>"who",
"frames"=>"1"}}}
A little cleaner, but problematic as we'll see later.
By default <item>'s value ("asdf") is referenced by the key
"content" and all attributes ("id", "frames") become key=>value pairs.
Test #2: Since XmlSimple uses "content" to reference element values, what happens if you have an attribute called "content" ?
xml1a:
<xml>
<head/>
<list>
<item frames='1' id='2' content='nuts'>who</item>
</list>
</xml>
irb#1(main):019:0> pp XmlSimple.xml_in(xml1, "forcearray" => false)
=> {"head"=>{}, "list"=>{"item"=>{"id"=>"2", "content"=>["nuts", "who"],
"frames"=>"1"}}}
By default, both values for the attribute and element named "content" are returned in a single array. There's no way to distinguish between the two.
Test #3: What happens if you have more than one <item>, like in the case of xml2?
irb#1(main):038:0> pp XmlSimple.xml_in(xml2, "forcearray" => false)
=> {"head"=>{}, "list"=>{"item"=>[{"frames"=>"3", "id"=>"1",
"content"=>"asdf"}, {"id"=>"2", "content"=>"who", "frames"=>"1"}]}}
In this example, note that <item> returns an array of two hashes. Like I previously mentioned, there's no way for
XmlSimple to know that an element will have 1 or many items. With
the "forcearray" => false option, a key could return a Hash or an Array
depending on the XML. Not desirable, but you can probably coerce the correct behavior with the right XmlSimple configuration options.
Now, let's take a look at XmlSimple embedded and mixed-in with the Hash class, as it is in Rails.
Test #4: What do the Rails defaults do?
console> pp Hash.from_xml(xml1)
>> {"xml"=>{"head"=>nil, "list"=>{"item"=>"who"}}}
By default, it looks like Hash.from_xml in Rails will eat your attributes. Yikes!
Test #5: Similarly to before, what happens if you have more than one item, like in the case of xml2?
console> pp Hash.from_xml(xml2)
>> {"xml"=>{"head"=>nil, "list"=>{"item"=>["asdf", "who"]}}}
Same as before, the attributes are removed, and "item" references both element values with a single key.
In summary, Ruby's XmlSimple is bork^H^H^H^H surprising to use and in Rails, doubly so. Actually this really shouldn't be surprising since most of these cautions are already mentioned on the XmlSimple homepage. What to use instead of XmlSimple? One powerful alternative is REXML, which comes bundled with Ruby by default.
Pretend we had a new type of XML, HeroXML. How do we tell Rails to use REXML to process it.
0. A snippet of HeroXML:
<HeroXML>
<Hero>
<Name>Clark Kent</Name>
<Title>Superman</Title>
</Hero>
</HeroXML>
1. Add a Mime type to the Rails environment or appropriate initializer config file:
Mime::Type.register_alias "application/hero+xml, :heroxml # Mime::HEROXML
2. Update @@param_parsers in your application controller:
@@param_parsers[Mime::HEROXML] = Proc.new do |rpd|
node = REXML::Document.new(rpd)
{ node.root.name => node.root} # params[:HeroXML] = <REXML document>
end
This instructs Rails to examine all requests with the CONTENT_TYPE of "application/hero+xml" and process the request body with REXML. It'll add a key to the params hash called "HeroXML" and make the root node of the HeroXML document available to your actions for further processing.
3. Be sure to set the correct CONTENT_TYPE in your tests.
4. Optional: If the HTTP_ACCEPT
variable is correctly configured, you may respond to HeroXML enabled remote clients with something
like:
respond_to do |format| {
format.heroxml do # defined by ":heroxml"
## solid code
end
}
The Rails defaults work fine, but if you're processing XML with attributes, you'll need to use something other than XmlSimple.
