Added a method so you can know whether an element is empty

lib/crack/xml.rb

@@ -13,7 +13,7 @@
 # This represents the hard part of the work, all I did was change the
 # underlying parser.
 class REXMLUtilityNode #:nodoc:
-  attr_accessor :name, :attributes, :children, :type
+  attr_accessor :name, :attributes, :children, :type, :empty_node
 
   def self.typecasts
     @@typecasts
@@ -62,13 +62,22 @@ def initialize(name, normalized_attributes = {})
     @attributes   = undasherize_keys(attributes)
     @children     = []
     @text         = false
+    @empty_node   = false
   end
 
   def add_node(node)
     @text = true if node.is_a? String
     @children << node
   end
 
+  def emptyze!(obj,value)
+    # Monkeypatch to allow empty_node? in the hash values
+    obj.class.instance_eval do 
+      define_method(:empty_node?) { @_empty_node }
+    end
+    obj.instance_eval { @_empty_node = value }
+  end
+
   def to_hash
     if @type == "file"
       f = StringIO.new((@children.first || '').unpack('m').first)
@@ -84,6 +93,7 @@ class << f
       t = typecast_value( unnormalize_xml_entities( inner_html ) )
       t.class.send(:attr_accessor, :attributes)
       t.attributes = attributes
+      emptyze!(t,false)
       return { name => t }
     else
       #change repeating groups into an array
@@ -114,6 +124,8 @@ class << f
         out = out.empty? ? nil : out
       end
 
+      emptyze!(out,@empty_node)
+
       if @type && out.nil?
         { name => typecast_value(out) }
       else
@@ -189,6 +201,7 @@ class XML
     def self.parse(xml)
       stack = []
       parser = REXML::Parsers::BaseParser.new(xml)
+      inner_elements = [0]
 
       while true
         event = parser.pull
@@ -199,10 +212,15 @@ def self.parse(xml)
           # do nothing
         when :start_element
           stack.push REXMLUtilityNode.new(event[1], event[2])
+          inner_elements[-1] += 1
+          inner_elements << 0
         when :end_element
           if stack.size > 1
             temp = stack.pop
+            temp.empty_node = true if inner_elements.pop == 0
             stack.last.add_node(temp)
+          else
+            stack.last.empty_node = true if inner_elements.pop == 0
           end
         when :text, :cdata
           stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
@@ -211,4 +229,4 @@ def self.parse(xml)
       stack.length > 0 ? stack.pop.to_hash : {}
     end
   end
-end
+end

test/xml_test.rb

@@ -68,6 +68,32 @@ class XmlTest < Test::Unit::TestCase
 
     Crack::XML.parse(xml).should == hash
   end
+
+  context "Using empty_node? method in the output hash" do
+    setup do 
+      @data1 = Crack::XML.parse("<a h='s' />")
+      @data2 = Crack::XML.parse("<a><h>s</h></a>")
+      @data3 = Crack::XML.parse("<a><b><c></c></b></a>")
+    end
+
+    should "allow us to differenciate an empty tag with attributes from inner tags with text nodes" do    
+      @data1.should == @data2
+      @data1["a"].empty_node?.should_not == @data2["a"].empty_node?    
+    end
+
+    should "be done by monkeypatching the hash keys with a method called empty_node? that tells whether the given node was empty" do
+      @data3["a"].methods.should include(:empty_node?)
+      @data3["a"].empty_node?.should == false
+      @data3["a"]["b"].empty_node?.should == false
+      @data3["a"]["b"]["c"].empty_node?.should == true
+    end
+
+    should "be false in text nodes" do
+      @data2["a"]["h"].empty_node?.should == false
+    end
+
+  end
+
 
   context "Parsing xml with text and attributes" do
     setup do
@@ -486,4 +512,4 @@ class XmlTest < Test::Unit::TestCase
   should "handle an xml string containing a single space" do
     Crack::XML.parse(' ').should == {}
   end
-end
+end