smacks-apricoteatsgorilla 0.4.5 → 0.4.6

data/README.rdoc

@@ -1,10 +1,8 @@
 = Apricot eats Gorilla
 
-Apricot eats Gorilla is a SOAP communication helper.
-
-It translates between SOAP messages (XML) and Ruby Hashes while offering some
-helpful methods for working with SOAP webservices. Apricot eats Gorilla was
-initially based on CobraVsMongoose but uses Hpricot instead of REXML.
+Apricot eats Gorilla is a SOAP communication helper. It translates between
+SOAP messages (XML) and Ruby Hashes and comes with some additional helpers
+for working with SOAP services.
 
 == Install
 
@@ -14,84 +12,41 @@ initially based on CobraVsMongoose but uses Hpricot instead of REXML.
 
   hpricot 0.6.164 (also available for JRuby)
 
-== How to use
-
-=== xml_to_hash(xml, root_node = nil)
-
-Converts a given XML String into a Ruby Hash. Starts parsing at root node by
-default. The optional root_node parameter can be used to specify a custom root
-node to start parsing at using an XPath expression (Hpricot search). The root
-node itself won't be included in the Hash. Converts tag names from CamelCase/
-lowerCamelCase to snake_case and into Symbols by default.
+== Translate an XML String into a Ruby Hash
 
   xml = '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
     <soap:Body>
       <ns2:authenticateResponse xmlns:ns2="http://v1_0.ws.example.com/">
         <return>
-          <authValue>
-            <token>secret</token>
-            <client>example</client>
-          </authValue>
+          <apricot>
+            <eats>Gorilla</eats>
+          </apricot>
         </return>
       </ns2:authenticateResponse>
     </soap:Body>
   </soap:Envelope>'
 
   ApricotEatsGorilla[xml, "//return"]
-  # => { :auth_value => { :token => "secret", :client => "example" } }
-
-=== hash_to_xml(hash)
+  # => { :apricot => { :eats => "Gorilla" } }
 
-Converts a given Ruby Hash into an XML String. Converts Hash keys from snake_case
-to lowerCamelCase by default.
+== Translate a Ruby Hash into an XML String
 
-  hash = { :apricot => { :eats => { :lots_of => "Gorillas" } } }
+  hash = { :apricot => { :eats => "Gorilla" } }
 
   ApricotEatsGorilla[hash]
-  # => "<apricot><eats><lotsOf>Gorillas</lotsOf></eats></apricot>"
+  # => "<apricot><eats>Gorilla</eats></apricot>"
 
-=== soap_envelope(namespaces = {})
+== Build a SOAP request envelope
 
-Builds a SOAP request envelope and includes the content from a given block
-into the envelope body. Accepts a Hash (namespace => namespace_uri) of additional
-namespaces to set.
-
-  ApricotEatsGorilla.soap_envelope { "<authenticate>me</authenticate>" }
+  ApricotEatsGorilla.soap_envelope { "<apricot><eats>Gorilla</eats></apricot>" }
 
   # => '<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
   # =>    <env:Body>
-  # =>      <authenticate>me</authenticate>
+  # =>      <apricot><eats>Gorilla</eats></apricot>
   # =>    </env:Body>
   # =>  </env:Envelope>'
 
-== Changing defaults
-
-There are several options for changing the default behavior. Options can be
-set using a setup block or by setting one option at a time.
-
-  ApricotEatsGorilla.setup do |s|
-    s.disable_tag_names_to_lower_camel_case = true
-    s.disable_hash_keys_to_snake_case = true
-    s.disable_hash_keys_to_symbol = true
-  end
-
-=== Disable conversion of tag names to lowerCamelCase
-
-By default XML tags created by hash_to_xml are converted from snake_case to
-lowerCamelCase. Disable by setting disable_tag_names_to_lower_camel_case to true.
-
-  ApricotEatsGorilla.disable_tag_names_to_lower_camel_case = true
-
-=== Disable conversion of Hash keys to snake_case
-
-By default Hash keys created by xml_to_hash are converted from lowerCamelCase/
-CamelCase to snake_case. Disable by setting disable_hash_keys_to_snake_case to true.
-
-  ApricotEatsGorilla.disable_hash_keys_to_snake_case = true
-
-=== Disable conversion of Hash keys to Symbols
-
-By default Hash keys created by xml_to_hash are converted to Symbols.
-Disable by setting disable_hash_keys_to_symbol to true.
+== Read more
 
-  ApricotEatsGorilla.disable_hash_keys_to_symbol = true
+For more detailed information, please take a look at the
+{GitHub Wiki}[http://wiki.github.com/smacks/apricoteatsgorilla].

data/lib/apricoteatsgorilla.rb

@@ -1,245 +1,4 @@
-require "rubygems"
-require "iconv"
-require "hpricot"
+$:.unshift(File.join(File.dirname(__FILE__), "apricoteatsgorilla"))
 
-# Apricot eats Gorilla is a SOAP communication helper.
-# 
-# It translates between SOAP messages (XML) and Ruby Hashes while offering some
-# helpful methods for working with SOAP webservices. Apricot eats Gorilla was
-# initially based on CobraVsMongoose but uses Hpricot instead of REXML.
-class ApricotEatsGorilla
-  class << self # Class methods
-
-    # Flag to enable sorting of Hash keys.
-    attr_accessor :sort_keys
-
-    # Flag to disable conversion of tag names to lowerCamelCase.
-    attr_accessor :disable_tag_names_to_lower_camel_case
-
-    # Flag to disable conversion of Hash keys to snake_case.
-    attr_accessor :disable_hash_keys_to_snake_case
-
-    # Flag to disable conversion of Hash keys to Symbols.
-    attr_accessor :disable_hash_keys_to_symbol
-
-    # Array of XML nodes to add a namespace to.
-    attr_accessor :nodes_to_namespace
-
-    # The namespace for nodes set by nodes_to_namespace.
-    attr_accessor :node_namespace
-
-    # Shortcut method for translating between XML Strings and Ruby Hashes.
-    # Delegates to xml_to_hash in case +source+ is of type String or delegates
-    # to hash_to_xml in case +source+ is of type Hash. Returns nil otherwise.
-    def [](source, root_node = nil)
-      case source
-      when String
-        xml_to_hash(source, root_node)
-      when Hash
-        hash_to_xml(source)
-      else
-        nil
-      end
-    end
-
-    # Yields this class object in case a +block+ was given. Nice way for setting
-    # multiple options at once.
-    def setup
-      yield self if block_given?
-    end
-
-    # Converts a given +xml+ String into a Ruby Hash. Starts parsing at root
-    # node by default. The optional +root_node+ parameter can be used to specify
-    # a custom root node to start parsing at using an XPath (Hpricot search).
-    # The root node itself won't be included in the Hash. Converts tag names
-    # from CamelCase/lowerCamelCase to snake_case and into Symbols by default.
-    #
-    # ==== Examples
-    #
-    #   xml = "<apricot><eats>Gorilla</eats></apricot>"
-    #   ApricotEatsGorilla[xml]
-    #   # => { :eats => "Gorilla" }
-    #
-    #   xml = "<apricot><eats><lotsOf>Gorillas</lotsOf></eats></apricot>"
-    #   ApricotEatsGorilla[xml, "//eats"]
-    #   # => { :lots_of => "Gorillas" }
-    def xml_to_hash(xml, root_node = nil)
-      doc = Hpricot.XML remove_whitespace(xml)
-      root = root_node ? doc.search(root_node) : doc.root
-
-      return nil if root.nil?
-      return xml_node_to_hash(root) unless root.respond_to? :each
-
-      if root.size == 1
-        return root.first.children.to_s if root.first.children.first.kind_of?(Hpricot::Text)
-        xml_node_to_hash(root.first)
-      else
-        root.map do |node|
-          if node.children.first.kind_of?(Hpricot::Text)
-            node.children.to_s
-          else
-            xml_node_to_hash(node)
-          end
-        end
-      end
-    end
-
-    # Converts a given Ruby Hash into an XML String. Converts Hash keys from
-    # snake_case to lowerCamelCase by default.
-    #
-    # ==== Examples
-    #
-    #   hash = { :apricot => { :eats => "Gorilla" } }
-    #   ApricotEatsGorilla[hash]
-    #   # => "<apricot><eats>Gorilla</eats></apricot>"
-    #
-    #   hash = { :apricot => { :eats => [ "Gorillas", "Snakes" ] } }
-    #   ApricotEatsGorilla[hash]
-    #   # => "<apricot><eats>Gorillas</eats><eats>Snakes</eats></apricot>"
-    def hash_to_xml(hash)
-      nested_data_to_xml(hash.keys.first, hash.values.first)
-    end
-
-    # Builds a SOAP request envelope and includes the content from a given +block+
-    # into the envelope body. Accepts a Hash (namespace => namespace_uri) of
-    # additional +namespaces+ to set.
-    #
-    # ==== Examples
-    #
-    #  ApricotEatsGorilla.soap_envelope { "<authenticate>me</authenticate>" }
-    #
-    #  # => '<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
-    #  # =>    <env:Body>
-    #  # =>      <authenticate>me</authenticate>
-    #  # =>    </env:Body>
-    #  # =>  </env:Envelope>'
-    #
-    #  ApricotEatsGorilla.soap_envelope :wsdl => "http://example.com" do
-    #    "<authenticate>me</authenticate>"
-    #  end
-    #
-    #  # => '<env:Envelope
-    #  # =>    xmlns:wsdl="http://example.com"
-    #  # =>    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
-    #  # =>    <env:Body>
-    #  # =>      <authenticate>me</authenticate>
-    #  # =>    </env:Body>
-    #  # =>  </env:Envelope>'
-    def soap_envelope(namespaces = {})
-      namespaces["env"] = "http://schemas.xmlsoap.org/soap/envelope/"
-      tag("env:Envelope", namespaces) do
-        tag("env:Body") do
-          yield if block_given?
-        end
-      end
-    end
-
-    # Converts a given +string+ from CamelCase/lowerCamelCase to snake_case.
-    def to_snake_case(string)
-      string = string.gsub(/[A-Z]+/, '\1_\0').downcase
-      string = string[1, string.length-1] if string[0, 1] == "_"
-      string
-    end
-
-    # Converts a given +string+ from snake_case to lowerCamelCase.
-    def to_lower_camel_case(string)
-      string.to_s.gsub(/_(.)/) { $1.upcase }
-    end
-
-  private
-
-    # Actual implementation for xml_to_hash. Takes and iterates through a given
-    # Hpricot +element+ and returns a Ruby Hash equal to the given content.
-    def xml_node_to_hash(element)
-      this_node = {}
-      element.each_child do |child|
-        # hpricot 0.6.1 returns an empty array, while 0.8 returns nil
-        if child.children.nil? || child.children.empty?
-          key, value = child.name, nil
-        elsif child.children.size == 1 && child.children.first.text?
-          key, value = child.name, map_to_boolean(child.children.first.to_html)
-        else
-          key, value = child.name, xml_node_to_hash(child)
-        end
-
-        key = remove_namespace(key)
-        key = to_snake_case(key) unless disable_hash_keys_to_snake_case
-        key = key.intern unless disable_hash_keys_to_symbol
-        current = this_node[key]
-        case current
-          when Array
-            this_node[key] << value
-          when nil
-            this_node[key] = value
-          else
-            this_node[key] = [current.dup, value]
-        end
-      end
-      this_node
-    end
-
-    # Actual implementation for hash_to_xml. Takes a Hash key +name+ and a
-    # value +item+ and returns an XML String equal to the given content.
-    def nested_data_to_xml(name, item)
-      case item
-      when Array
-        item.map { |subitem| nested_data_to_xml(name, subitem) }.join
-      when Hash
-        tag(name) do
-          opt_order(item).map { |tag, value|
-            case value
-            when Array
-              value.map { |subitem| nested_data_to_xml(tag, subitem) }.join
-            when Hash
-              nested_data_to_xml(tag, value)
-            else
-              tag(tag) { value.to_s } if value.respond_to? :to_s
-            end
-          }.join
-        end
-      else
-        tag(name) { item.to_s } if item.respond_to? :to_s
-      end
-    end
-
-    # Creates an XML tag. Expects a block for tag content. Defaults to an empty
-    # element tag in case no block was supplied.
-    def tag(name, attributes = {})
-      name = to_lower_camel_case(name) unless disable_tag_names_to_lower_camel_case
-      if nodes_to_namespace.kind_of? Array
-        name = "#{node_namespace}:#{name}" if node_namespace && nodes_to_namespace.include?(name)
-      end
-      return "<#{name} />" unless block_given?
-
-      attr = opt_order(attributes).map { |k, v| %Q( xmlns:#{k}="#{v}") }.to_s
-      body = yield || ""
-      "<#{name}#{attr}>" << body << "</#{name}>"
-    end
-
-    # Removes whitespace between tags of a given +xml+ String.
-    def remove_whitespace(xml)
-      xml.gsub(/(>)\s*(<)/, '\1\2')
-    end
-
-    # Removes the namespace from a given XML +tag+.
-    def remove_namespace(tag)
-      tag.sub(/.+:(.+)/, '\1')
-    end
-
-    # Checks to see if a given +string+ matches "true" or "false" and converts
-    # these values to actual Boolean objects. Returns the original String in
-    # case it does not match "true" or "false".
-    def map_to_boolean(string)
-      return true if string == "true"
-      return false if string == "false"
-      Iconv.new("iso-8859-1", "utf-8").iconv(string)
-    end
-
-    # Returns a sorted version of a given +hash+ if sort_keys is enabled.
-    def opt_order(hash)
-      return hash unless sort_keys
-      hash.keys.sort_by { |s| s.to_s }.map { |key| [key, hash[key]] }
-    end
-
-  end
-end
+require "apricoteatsgorilla"
+require "xml_node"

data/lib/apricoteatsgorilla/apricoteatsgorilla.rb

@@ -0,0 +1,222 @@
+require "rubygems"
+require "hpricot"
+require "iconv"
+
+# == Apricot eats Gorilla
+# 
+# Apricot eats Gorilla is a SOAP communication helper. It translates between
+# SOAP messages (XML) and Ruby Hashes and comes with some additional helpers
+# for working with SOAP services.
+class ApricotEatsGorilla
+  class << self
+
+    # Flag to enable sorting of Hash keys.
+    attr_accessor :sort_keys
+
+    # Flag to disable conversion of XML tags names to lowerCamelCase.
+    attr_accessor :disable_tag_names_to_lower_camel_case
+
+    # Flag to disable conversion of Hash keys to snake_case.
+    attr_accessor :disable_hash_keys_to_snake_case
+
+    # Flag to disable conversion of Hash keys to Symbols.
+    attr_accessor :disable_hash_keys_to_symbols
+
+    # Hash of namespaces and XML nodes to apply these namespaces to.
+    attr_accessor :nodes_to_namespace
+
+    # Shortcut method for translating between XML Strings and Ruby Hashes.
+    # Delegates to +xml_to_hash+ in case +source+ is a String or delegates
+    # to +hash_to_xml+ in case +source+ is a Hash. Returns nil otherwise.
+    def [](source, root_node = nil)
+      case source
+      when String
+        xml_to_hash(source, root_node)
+      when Hash
+        hash_to_xml(source)
+      else
+        nil
+      end
+    end
+
+    # Yields this class in case a +block+ was given.
+    def setup
+      yield self if block_given?
+    end
+
+    # Translates a given +xml+ String into a Ruby Hash.
+    # 
+    # Starts parsing at the XML root node by default. Accepts an optional
+    # +root_node+ parameter for defining a custom root node to start parsing
+    # at using an XPath (Hpricot search).
+    #
+    # The root node itself won't be included in the Hash.
+    #
+    # ==== Examples
+    #
+    #   xml = '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+    #       <soap:Body>
+    #         <ns2:authenticateResponse xmlns:ns2="http://v1_0.ws.example.com/">
+    #           <return>
+    #             <apricot>
+    #               <eats>Gorilla</eats>
+    #             </apricot>
+    #           </return>
+    #         </ns2:authenticateResponse>
+    #       </soap:Body>
+    #     </soap:Envelope>'
+    #
+    #   ApricotEatsGorilla.xml_to_hash(xml, "//return")
+    #   # => { :apricot => { :eats => "Gorilla" } }
+    def xml_to_hash(xml, root_node = nil)
+      doc = Hpricot.XML remove_whitespace(xml)
+      root = root_node ? doc.search(root_node) : doc.root
+
+      return nil if root.nil?
+      return xml_node_to_hash(root) unless root.respond_to? :each
+
+      if root.size == 1
+        if root.first.children.first.kind_of?(Hpricot::Text)
+          map_xml_value(root.first.children.to_s)
+        else
+          xml_node_to_hash(root.first)
+        end
+      else
+        root.map do |node|
+          if node.children.first.kind_of?(Hpricot::Text)
+            map_xml_value(node.children.to_s)
+          else
+            xml_node_to_hash(node)
+          end
+        end
+      end
+    end
+
+    # Translates a given Ruby +hash+ into an XML String.
+    #
+    # ==== Examples
+    #
+    #   hash = { :apricot => { :eats => "Gorilla" } }
+    #
+    #   ApricotEatsGorilla.hash_to_xml(hash)
+    #   # => "<apricot><eats>Gorilla</eats></apricot>"
+    def hash_to_xml(hash)
+      nested_data_to_xml(hash.keys.first, hash.values.first)
+    end
+
+    # Builds a SOAP request envelope and includes the content from a given
+    # +block+ into the envelope body. Accepts a Hash of additional +namespaces+
+    # to set.
+    #
+    # ==== Examples
+    #
+    #   ApricotEatsGorilla.soap_envelope do
+    #     "<apricot><eats>Gorilla</eats></apricot>"
+    #   end
+    #
+    #   # => '<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+    #   # =>    <env:Body>
+    #   # =>      <apricot><eats>Gorilla</eats></apricot>
+    #   # =>    </env:Body>
+    #   # =>  </env:Envelope>'
+    def soap_envelope(namespaces = {})
+      namespaces[:env] = "http://schemas.xmlsoap.org/soap/envelope/"
+
+      xml_node("env:Envelope", namespaces) do
+        xml_node("env:Body") { yield if block_given? }
+      end
+    end
+
+  private
+
+    # Iterates through an expected Hpricot +element+ and returns a Ruby Hash
+    # equal to the XML content of the given element.
+    def xml_node_to_hash(element)
+      hash = {}
+      element.each_child do |child|
+        key = XMLNode.new(child.name)
+        key.strip_namespace!
+        key.to_snake_case! unless disable_hash_keys_to_snake_case
+        key = disable_hash_keys_to_symbols ? key.to_s : key.to_sym
+        
+        # hpricot 0.6.1 returns an empty array, while 0.8 returns nil
+        if child.children.nil? || child.children.empty?
+          value = nil
+        elsif child.children.size == 1 && child.children.first.text?
+          value = map_xml_value(child.children.first.to_html)
+        else
+          value = xml_node_to_hash(child)
+        end
+
+        case hash[key]
+        when Array
+          hash[key] << value
+        when nil
+          hash[key] = value
+        else
+          hash[key] = [hash[key].dup, value]
+        end
+      end
+      hash
+    end
+
+    # Expects a Hash +key+ and a Hash +value+. Iterates through the given Hash
+    # +value+ and returns an XML String of the given Hash structure.
+    def nested_data_to_xml(key, value)
+      case value
+      when Array
+        value.map { |subitem| nested_data_to_xml(key, subitem) }.join
+      when Hash
+        xml_node(key) do
+          sort_hash_keys(value).map do |subkey, subvalue|
+            case subvalue
+            when Array
+              subvalue.map { |subitem| nested_data_to_xml(subkey, subitem) }.join
+            when Hash
+              nested_data_to_xml(subkey, subvalue)
+            else
+              xml_node(subkey) { subvalue.to_s } if subvalue.respond_to?(:to_s)
+            end
+          end.join
+        end
+      else
+        xml_node(key) { value.to_s } if value.respond_to?(:to_s)
+      end
+    end
+
+    # Returns an XML tag with a given +name+. Accepts a +block+ for tag content.
+    # Defaults to returning an empty element tag in case no block was given.
+    # Also accepts a Hash of +attributes+ to be added to the XML tag.
+    def xml_node(name, attributes = {})
+      node = XMLNode.new(name.to_s)
+
+      node.to_lower_camel_case! unless disable_tag_names_to_lower_camel_case
+      node.namespace_from_hash!(nodes_to_namespace)
+      node.attributes = sort_hash_keys(attributes)
+      node.body = yield if block_given?
+
+      node.to_tag
+    end
+
+    # Removes whitespace between tags from a given +xml+ String.
+    def remove_whitespace(xml)
+      xml.gsub(/(>)\s*(<)/, '\1\2')
+    end
+
+    # Maps an XML value to a more natural Ruby object. Converts String values
+    # of "true" and "false" to TrueClass and FalseClass. Converts other String
+    # values from "iso-8859-1" to "utf-8".
+    def map_xml_value(value)
+      return true if value == "true"
+      return false if value == "false"
+      Iconv.new("iso-8859-1", "utf-8").iconv(value)
+    end
+
+    # Returns a sorted version of a given +hash+ if +sort_keys+ is enabled.
+    def sort_hash_keys(hash)
+      return hash unless sort_keys
+      hash.keys.sort_by { |key| key.to_s }.map { |key| [ key, hash[key] ] }
+    end
+
+  end
+end

data/lib/apricoteatsgorilla/xml_node.rb

@@ -0,0 +1,75 @@
+# == XMLNode
+#
+# Representation of an XML node.
+class XMLNode < String
+
+  # Hash of attributes.
+  attr_writer :attributes
+
+  # Body content.
+  attr_writer :body
+
+  # Strips the namespace from this node.
+  def strip_namespace!
+    sub!(/.+:(.+)/, '\1')
+  end
+
+  # Converts the name of this node to snake_case.
+  def to_snake_case!
+    self.gsub!(/[A-Z]/, '_\0')
+    self.gsub!(/^_/, '')
+    self.downcase!
+  end
+
+  # Converts the name of this node to lowerCamelCase.
+  def to_lower_camel_case!
+    self.gsub!(/_(.)/) { $1.upcase }
+  end
+
+  # Checks if the name of this node is included in a given Hash of +namespaces+
+  # and sets the namespace for this node in case it was found in the Hash.
+  def namespace_from_hash!(namespaces)
+    return if namespaces.nil? || namespaces.empty?
+
+    namespaces.each do |namespace, nodes|
+      @namespace = namespace if self_included?(nodes)
+    end
+  end
+
+  # Returns this node as a complete XML tag including a +namespace+, +attributes+
+  # and a +body+ in case these values were supplied.
+  def to_tag
+    return "<#{namespace}#{self}#{attributes} />" unless @body
+    "<#{namespace}#{self}#{attributes}>#{body}</#{namespace}#{self}>"
+  end
+
+private
+
+  # Returns +true+ if self as a String or a Symbol is included in a given
+  # +array+. Returns +false+ otherwise.
+  def self_included?(array)
+    array.include?(self.to_s) || array.include?(self.to_sym)
+  end
+
+  # Returns the namespace of this node. Defaults to an empty String in case
+  # no namespace was defined.
+  def namespace
+    return "" if @namespace.nil?
+    "#{@namespace}:"
+  end
+
+  # Returns the attributes of this node. Defaults to an empty String in case
+  # no attributes were defined.
+  def attributes
+    return "" if @attributes.nil?
+    @attributes.map { |key, value| %Q( xmlns:#{key}="#{value}") }
+  end
+
+  # Returns the body of this node. Defaults to an empty String in case no body
+  # was defined.
+  def body
+    return "" if @body.nil?
+    @body
+  end
+
+end

data/test/apricoteatsgorilla/test_hash_to_xml.rb

@@ -8,14 +8,15 @@ class TestHashToXml < Test::Unit::TestCase
         s.sort_keys = true
         s.disable_tag_names_to_lower_camel_case = false
         s.disable_hash_keys_to_snake_case = false
-        s.disable_hash_keys_to_symbol = false
+        s.disable_hash_keys_to_symbols = false
+        s.nodes_to_namespace = nil
       end
     end
 
-    context "with a Hash consisting of a single key-value-pair" do
+    context "with a Hash containing only a single key-value-pair" do
       should "return an XML String containing one node and a value" do
-        hash = { "apricot" => "eats gorilla" }
-        expected = "<apricot>eats gorilla</apricot>"
+        hash = { "apricot" => "eats Gorilla" }
+        expected = "<apricot>eats Gorilla</apricot>"
 
         result = ApricotEatsGorilla.hash_to_xml(hash)
         assert_equal expected, result
@@ -103,6 +104,18 @@ class TestHashToXml < Test::Unit::TestCase
         assert_equal expected, result
       end
     end
+
+    context "with some Hash and nodes to namespace" do
+      setup { ApricotEatsGorilla.nodes_to_namespace = { :wsdl => [ :apricot ] } }
+
+      should "apply the defined namespaces" do
+        hash = { :apricot => { :eats => "Gorilla" } }
+        expected = "<wsdl:apricot><eats>Gorilla</eats></wsdl:apricot>"
+
+        result = ApricotEatsGorilla.hash_to_xml(hash)
+        assert_equal expected, result
+      end
+    end
   end
 
 end

data/test/apricoteatsgorilla/test_shortcut_method.rb

@@ -8,7 +8,8 @@ class TestShortcutMethod < Test::Unit::TestCase
         s.sort_keys = true
         s.disable_tag_names_to_lower_camel_case = false
         s.disable_hash_keys_to_snake_case = false
-        s.disable_hash_keys_to_symbol = false
+        s.disable_hash_keys_to_symbols = false
+        s.nodes_to_namespace = nil
       end
     end
 

data/test/apricoteatsgorilla/test_soap_envelope.rb

@@ -6,9 +6,9 @@ class TestSoapEnvelope < Test::Unit::TestCase
     setup { ApricotEatsGorilla.sort_keys = true }
 
     context "without parameter and block" do
-      should "returns a SOAP envelope without body content" do
+      should "returns a SOAP envelope with an empty element body tag" do
         expected = '<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">' <<
-          '<env:Body></env:Body></env:Envelope>'
+          '<env:Body /></env:Envelope>'
 
         result = ApricotEatsGorilla.soap_envelope
         assert_equal expected, result
@@ -16,7 +16,7 @@ class TestSoapEnvelope < Test::Unit::TestCase
     end
     
     context "with a Hash containing a custom namespace and a block" do
-      should "returns a SOAP envelope with custom namespace and body content" do
+      should "returns a SOAP envelope with a custom namespace and body content" do
         expected = '<env:Envelope ' <<
           'xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" ' <<
           'xmlns:wsdl="http://example.com">' <<

data/test/apricoteatsgorilla/test_xml_node.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), "..", "helper")
+
+class TestXMLNode < Test::Unit::TestCase
+
+  context "strip_namespace!" do
+    should "strip the namespace from the XMLNode" do
+      node = XMLNode.new("wsdl:apricot")
+      node.strip_namespace!
+
+      assert_equal "apricot", node.to_s
+    end
+  end
+
+  context "to_snake_case!" do
+    should "convert the XMLNode from CamelCase to snake_case" do
+      node = XMLNode.new("ApricotEatsGorilla")
+      node.to_snake_case!
+
+      assert_equal "apricot_eats_gorilla", node.to_s
+    end
+
+    should "convert the XMLNode from lowerCamelCase to snake_case" do
+      node = XMLNode.new("apricotEatsGorilla")
+      node.to_snake_case!
+
+      assert_equal "apricot_eats_gorilla", node.to_s
+    end
+  end
+
+  context "namespace_from_hash!" do
+    context "with a Hash containing the name of the XMLNode" do
+      should "set the namespace of the XMLNode" do
+        node = XMLNode.new("apricot")
+        node.namespace_from_hash!(:wsdl => [ :apricot ])
+
+        assert_equal "apricot", node.to_s
+        assert_equal "<wsdl:apricot />", node.to_tag
+      end
+    end
+
+    context "with a Hash that does not contain the name of the XMLNode" do
+      should "not set the namespace of the XMLNode" do
+        node = XMLNode.new("apricot")
+        node.namespace_from_hash!(:wsdl => [ :some_key ])
+
+        assert_equal "<apricot />", node.to_tag
+      end
+    end
+  end
+
+  context "to_tag" do
+    context "with a simple XMLNode" do
+      should "return an empty element tag" do
+        node = XMLNode.new("apricot")
+        assert_equal "<apricot />", node.to_tag
+      end
+    end
+
+    context "with an XMLNode containing a namespace" do
+      should "return a namespaced empty element tag" do
+        node = XMLNode.new("apricot")
+        node.namespace_from_hash!(:wsdl => [ :apricot ])
+
+        assert_equal "<wsdl:apricot />", node.to_tag
+      end
+    end
+
+    context "with an XMLNode containing an attribute" do
+      should "return an empty element tag with an xmlns attribute" do
+        node = XMLNode.new("apricot")
+        node.attributes = { :wsdl => "http://example.com" }
+
+        assert_equal '<apricot xmlns:wsdl="http://example.com" />', node.to_tag
+      end
+    end
+
+    context "with an XMLNode containing a body" do
+      should "return an element with a body" do
+        node = XMLNode.new("apricot")
+        node.body = "eats Gorilla"
+
+        assert_equal '<apricot>eats Gorilla</apricot>', node.to_tag
+      end
+    end
+  end
+
+end

data/test/apricoteatsgorilla/test_xml_to_hash.rb

@@ -8,7 +8,8 @@ class TestXmlToHash < Test::Unit::TestCase
         s.sort_keys = true
         s.disable_tag_names_to_lower_camel_case = false
         s.disable_hash_keys_to_snake_case = false
-        s.disable_hash_keys_to_symbol = false
+        s.disable_hash_keys_to_symbols = false
+        s.nodes_to_namespace = nil
       end
     end
 
@@ -33,6 +34,16 @@ class TestXmlToHash < Test::Unit::TestCase
       end
     end
 
+    context "with XML containing namespaced nodes" do
+      should "remove namespaces from nodes" do
+        xml = "<return><wsdl:apricot><eats>Gorilla</eats></wsdl:apricot></return>"
+        expected = { :apricot => { :eats => "Gorilla" } }
+
+        result = ApricotEatsGorilla.xml_to_hash(xml)
+        assert_equal expected, result
+      end
+    end
+
     context "with XML containing 'true' and 'false' Strings" do
       should "convert these Strings into actual Boolean objects" do
         xml = "<root><yes>true</yes><no>false</no><text>something</text></root>"
@@ -135,7 +146,7 @@ class TestXmlToHash < Test::Unit::TestCase
       end
 
       context "and converting Hash keys to Symbols turned off" do
-        setup { ApricotEatsGorilla.disable_hash_keys_to_symbol = true }
+        setup { ApricotEatsGorilla.disable_hash_keys_to_symbols = true }
 
         should "not convert Hash keys to Symbols" do
           xml = "<contact><name>Jungle Julia</name><address/></contact>"

data/test/test_apricoteatsgorilla.rb

@@ -1,5 +1,7 @@
 $:.unshift(File.join(File.dirname(__FILE__), "apricoteatsgorilla"))
+
 require "test_shortcut_method"
 require "test_xml_to_hash"
 require "test_hash_to_xml"
-require "test_soap_envelope"
+require "test_soap_envelope"
+require "test_xml_node"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: smacks-apricoteatsgorilla
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors: 
 - Daniel Harrington
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.6.164
     version: 
-description: Apricot eats Gorilla is a SOAP communication helper.
+description: SOAP communication helper.
 email: 
 executables: []
 
@@ -33,6 +33,8 @@ extra_rdoc_files:
 files: 
 - README.rdoc
 - lib/apricoteatsgorilla.rb
+- lib/apricoteatsgorilla/apricoteatsgorilla.rb
+- lib/apricoteatsgorilla/xml_node.rb
 has_rdoc: true
 homepage: http://github.com/smacks/apricoteatsgorilla
 post_install_message: 
@@ -59,7 +61,7 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Apricot eats Gorilla is a SOAP communication helper.
+summary: SOAP communication helper.
 test_files: 
 - test/test_apricoteatsgorilla.rb
 - test/helper.rb
@@ -67,3 +69,4 @@ test_files:
 - test/apricoteatsgorilla/test_xml_to_hash.rb
 - test/apricoteatsgorilla/test_shortcut_method.rb
 - test/apricoteatsgorilla/test_soap_envelope.rb
+- test/apricoteatsgorilla/test_xml_node.rb