xml-fu 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*.swp
+.rvmrc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+### 0.1.0
+
+* Initial version. born as a replacement of 
+  [Gyoku](http://www.rubygems.org/gems/gyoku)
+  with corrected assumptions about Array values and
+  no need for meta tags such as:
+  * :order! 
+  * :attributes!

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xml-fu.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012 Ryan Johnson
+Copyright (c) 2010 Daniel Harrington (for logic inspired by Gyoku)
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,291 @@
+# Xml::Fu
+
+Convert Ruby Hashes to XML
+
+A hash is meant to be a structured set of data. So is XML. The two are very similar in that they have 
+the capability of nesting information within a tree structure. With XML you have nodes. With Hashes, you
+have key/value pairs. The value of an XML node is referenced by its parent's name. A hash value is referenced
+by its key. This basic lesson tells the majority of what you need to know about creating XML via Hashes in
+Ruby using the XmlFu gem.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'xml-fu'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xml-fu
+
+
+## Hash Keys
+
+Hash keys are translated into XML nodes (whether it be a document node or attribute node).
+
+
+### Translation
+
+With Ruby, a hash key may be a string or a symbol. XmlFu will convert the symbols into an XML safe name 
+by lower camel-casing them. So :foo\_bar will become "fooBar". You may change the conversion algorithm to your
+liking by setting the XmlFu.symbol\_conversion\_algorithm to a lambda or proc of your liking.
+
+
+#### Built-In Algorithms
+
+* :lower\_camelcase **(default)**
+* :camelcase
+* :none (result of :sym.to\_s)
+* :snake\_case (alias for :none)
+
+```ruby
+# Built-in Algorithm
+XmlFu.symbol_conversion_algorithm(:camelcase)
+
+XmlFu.xml( :foo => "bar" ) #=> "<foo>bar</foo>"
+XmlFu.xml( "foo" => "bar" ) #=> "<foo>bar</foo>"
+# :foo and "foo" both translate to <foo>
+
+# Custom Algorithm
+XmlFu.symbol_conversion_algorithm {|sym| sym.downcase }
+```
+
+### Types of Nodes
+
+Because there are multiple types of XML nodes, there are also multiple types of keys to denote them.
+
+
+#### Self-Closing Nodes (key/)
+
+By default, XmlFu assumes that all XML nodes will contain closing tags. However, if you want to explicitly
+create a self-closing node, use the following syntax when you define the key.
+
+``` ruby
+XmlFu.xml("foo/" => "bar") #=> <foo/>
+```
+
+One thing to take note of this syntax is that XmlFu will ignore ANY value you throw at it if the key syntax
+denotes a self-closing tag. This is because a self-closing tag cannot have any contents (hence the use for
+a self-closing tag).
+
+
+#### Unescaped Content Nodes (key!)
+
+By default, if you pass a pure string as a value, special characters will be escaped to keep the XML compliant.
+If you know that the string is valid XML and can be trusted, you can add the exclamation point to the end of
+the key name to denote that XmlFu should NOT escape special characters in the value.
+
+```ruby
+# Default Functionality (Escaped Characters)
+XmlFu.xml("foo" => "<bar/>") #=> "<foo>&lt;bar/&gt;</foo>"
+
+# Unescaped Characters
+XmlFu.xml("foo!" => "<bar/>") #=> "<foo><bar/></foo>"
+```
+
+
+#### Attribute Node (@key)
+
+Yes, the attributes of an XML node are nodes themselves, so we need a way of defining them. Since XPath syntax 
+uses @ to denote an attribute, so does XmlFu.
+
+``` ruby
+XmlFu.xml(:agent => { 
+  "@id" => "007", 
+  "FirstName" => "James", 
+  "LastName" => "Bond" 
+})
+#=> <agent id="007"><FirstName>James</FirstName><LastName>Bond</LastName></agent>
+```
+
+
+## Hash Values
+
+The value in a key/value pair describes the key/node. Different value types determine the extent of this description.
+
+
+### Simple Values
+
+Simple value types describe the contents of the XML node.
+
+
+#### Strings
+
+``` ruby
+XmlFu.xml( :foo => "bar" ) #=> "<foo>bar</foo>"
+XmlFu.xml( "foo" => "bar" ) #=> "<foo>bar</foo>"
+```
+
+
+#### Numbers
+
+``` ruby
+XmlFu.xml( :foo => 0 ) #=> "<foo>0</foo>"
+XmlFu.xml( :pi => 3.14159 ) #=> "<pi>3.14159</pi>"
+```
+
+
+#### Nil
+
+``` ruby
+XmlFu.xml( :foo => nil ) #=> "<foo xsi:nil=\"true\"/>"
+```
+
+
+### Hashes
+
+Hash are parsed for their translated values prior to returning a XmlFu value.
+
+```ruby
+XmlFu.xml(:foo => {:bar => {:biz => "bang"} })
+#=> "<foo><bar><biz>bang</biz></bar></foo>"
+```
+
+#### Content in Hash (=)
+
+Should you require setting node attributes as well as setting the value of the XML node, you may use the "="
+key in a nested hash to denote explicit content.
+
+```ruby
+XmlFu.xml(:agent => {"@id" => "007", "=" => "James Bond"})
+#=> "<agent id=\"007\">James Bond</agent>"
+```
+
+This key will not get around the self-closing node rule. The only nodes that will be used in this case will be 
+attribute nodes and additional content will be ignored.
+
+```ruby
+XmlFu.xml("foo/" => {"@id" => "123", "=" => "You can't see me."})
+#=> "<foo id=\"123\"/>"
+```
+
+
+### Arrays
+
+Since the value in a key/value pair is (for the most part) used as the contents of a key/node, there are some 
+assumptions that XmlFu makes when dealing with Array values.
+
+* For a typical key, the contents of the array are considered to be nodes to be contained within the <key> node.
+
+
+#### Array of Hashes
+
+``` ruby
+XmlFu.xml( "SecretAgents" => [
+  { "agent/" => { "@id"=>"006", "@name"=>"Alec Trevelyan" } }, 
+  { "agent/" => { "@id"=>"007", "@name"=>"James Bond" } }
+])
+#=> "<SecretAgents><agent name=\"Alec Trevelyan\" id=\"006\"/><agent name=\"James Bond\" id=\"007\"/></SecretAgents>"
+```
+
+
+#### Alternate Array of Hashes (key\*)
+
+There comes a time that you may want to declare the contents of an array as a collection of items denoted by the
+key name. Using the asterisk (also known for multiplication --- hence multiple keys) we denote that we want a
+collection of &lt;key&gt; nodes.
+
+```ruby
+XmlFu.xml( "person*" => ["Bob", "Sheila"] )
+#=> "<person>Bob</person><person>Sheila</person>"
+```
+
+In this case, the value of "person*" is an array of two names. These names are to be the contents of multiple
+&lt;person&gt; nodes and the result is a set of sibling XML nodes with no parent.
+
+How about a more complex example:
+
+```ruby
+XmlFu.xml(
+  "person*" => { 
+    "@foo" => "bar", 
+    "=" => [
+      {"@foo" => "nope", "=" => "Bob"}, 
+      "Sheila"
+    ] 
+  }
+)
+#=> "<person foo=\"nope\">Bob</person><person foo=\"bar\">Sheila</person>"
+```
+
+*This is getting interesting, isn't it?* In this example, we are setting a default "foo" attribute on each of the
+items in the collection of &lt;person&gt; nodes. However, you'll notice that we overwrote the default "foo" with Bob.
+
+
+#### Array of Arrays
+
+Array values are flattened prior to translation, to reduce the need to iterate over nested arrays.
+
+```ruby
+XmlFu.xml(
+  :foo => [
+    [{"a/" => nil}, {"b/" => nil}],
+    {"c/" => nil},
+    [
+      [{"d/" => nil}, {"e/" => nil}],
+      {"f/" => nil}
+    ]
+  ]
+)
+#=> "<foo><a/><b/><c/><d/><e/><f/></foo>"
+```
+
+:foo in this case, is the parent node of it's contents
+
+
+#### Array of Mixed Types
+
+Since with simple values, you cannot infer the value of their node container purely on their value, simple values
+are currently ignored in arrays and only Hashes are translated.
+
+``` ruby
+  "foo" => [
+    {:bar => "biz"},
+    nil, # ignored
+    true, # ignored
+    false, # ignored
+    42, # ignored
+    3.14, # ignored
+    "simple string", # ignored
+    ['another','array','of','values'] # ignored
+  ]
+  #=> "<foo><bar>biz</bar></foo>"
+```
+
+
+### Cheat Sheet
+
+#### Key
+  1. if key denotes self-closing node (key/)
+    * attributes are preserved with Hash values
+    * value and "=" values are ignored
+  2. if key denotes collection (key*) with Array value 
+    * Array is flattened
+    * Only Hash and Simple values are translated
+    * Hashes may override default attributes set by parent
+    * **(applies to Array values only)**
+  3. if key denotes contents (key) with Array value
+    * Array is flattened
+    * Only Hash items in array are translated
+
+#### Value
+  1. if value is Hash:
+    * "@" keys are attributes of the node
+    * "=" key can be used in conjunction with any "@" keys to specify content of node
+  3. if value is simple value:
+    * it is content of <key> node
+    * **unless:** key denotes a self-closing node
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/xml-fu/array.rb

@@ -0,0 +1,98 @@
+require 'builder'
+require 'xml-fu/hash'
+require 'xml-fu/node'
+
+module XmlFu
+
+  # Convert Array to XML String
+  class Array
+
+    # Custom exception class
+    class MissingKeyException < Exception; end
+
+    # Convert Array to XML String of sibling XML nodes
+    # @param [Array] array
+    # @param [Hash] options
+    # @option options [String] :content_type  Either "collection" or "content". (defaults to "content")
+    # @option options [String, Symbol] :key Name of node.
+    # @option options [Hash] :attributes Possible hash of attributes to assign to nodes in array.
+    # @return String
+    def self.to_xml(array, options={})
+      each_with_xml(array, options) do |xml, key, item, attributes|
+        case options[:content_type].to_s
+        when "collection"
+          raise(MissingKeyException, "Key name missing for collection") if key.empty?
+          
+          case 
+          when key[-1,1] == "/"
+            xml << Node.new(key, nil, attributes).to_xml
+          when ::Hash === item
+            xml.tag!(key, attributes) { xml << Hash.to_xml(item,options) }
+          when ::Array === item
+            xml << Array.to_xml(item.flatten,options)
+          else
+            xml << Node.new(key, item, attributes).to_xml
+          end
+        else
+          # Array is content of node rather than collection of node elements
+          case
+          when ::Hash === item   
+            xml << Hash.to_xml(item, options)
+          when ::Array === item  
+            xml << Array.to_xml(item, options)
+          when XmlFu.infer_simple_value_nodes == true
+            xml << infer_node(item, attributes)
+          else
+            # only act on item if it responds to to_xml
+            xml << item.to_xml if item.respond_to?(:to_xml)
+          end
+        end
+      end
+    end#self.to_xml
+
+    # Future Functionality - VERY ALPHA STAGE!!!
+    # @todo Add node inferrance functionality
+    # @note Do not use if you want stable functionality
+    # @param item Simple Value
+    # @param [Hash] attributes Hash of attributes to assign to inferred node.
+    def self.infer_node(item, attributes={})
+      node_name = case item.class
+                  when "TrueClass"
+                  when "FalseClass"
+                    "Boolean"
+                  else
+                    item.class
+                  end
+      Node.new(node_name, item, attributes).to_xml
+    end#self.infer_node
+
+    # Convenience function to iterate over array items as well as
+    # providing a single location for logic
+    # @param [Array] arr Array to iterate over
+    # @param [Hash] opts Hash of options to pass to the iteration
+    def self.each_with_xml(arr, opts={})
+      xml = Builder::XmlMarkup.new
+
+      arr.each do |item|
+        key = opts.fetch(:key, "")
+        item_content = item
+
+        # Attributes reuires duplicate or child elements will 
+        # contain attributes of their siblings.
+        attributes = (opts[:attributes] ? opts[:attributes].dup : {})
+
+        if item.respond_to?(:keys)
+          filtered = Hash.filter(item)
+          attributes = filtered.last
+          item_content = filtered.first
+        end
+
+        yield xml, key, item_content, attributes
+      end
+
+      xml.target!
+    end#self.each_with_xml
+
+  end#Array
+
+end#XmlFu

data/lib/xml-fu/core_ext/string.rb

@@ -0,0 +1,14 @@
+# Redefined parts of the String class to suit our needs in the gem.
+class String
+
+  # Returns the string in camelcase (with first character lowercase)
+  def lower_camelcase
+    self[0].chr.downcase + self.camelcase[1..-1]
+  end#lower_camelcase
+
+  # Returns the string in camelcase (with the first character uppercase)
+  def camelcase
+    self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end#camelcase
+
+end#String

data/lib/xml-fu/hash.rb

@@ -0,0 +1,87 @@
+require 'builder'
+require 'xml-fu/array'
+require 'xml-fu/node'
+
+module XmlFu
+
+  # By definition, a hash is an UNORDERED list of key/value pairs
+  # There's no sense in trying to order the keys.
+  # If order is of concern, use Array.to_xml
+  class Hash
+
+    # Convert Hash to XML String
+    def self.to_xml(hash, options={})
+      each_with_xml hash do |xml, key, value, attributes|
+        # Use symbol conversion algorithm to set tag name
+        tag_name = ( Symbol === key ?
+                     XmlFu::Node.symbol_conversion_algorithm.call(key) :
+                     key.to_s )
+
+        case
+        when tag_name[-1,1] == "/"
+          xml << Node.new(tag_name, nil, attributes).to_xml
+        when ::Array === value
+          if tag_name[-1,1] == '*'
+            options.merge!({
+              :content_type => "collection",
+              :key => tag_name.chop,
+              :attributes => attributes
+            })
+            # Collection is merely a set of sibling nodes
+            xml << Array.to_xml(value.flatten, options)
+          else
+            # Contents will contain a parent node
+            xml.tag!(tag_name, attributes) { xml << Array.to_xml(value, options) }
+          end
+        when ::Hash === value 
+          xml.tag!(tag_name, attributes) { xml << Hash.to_xml(value, options) }
+        else 
+          xml << Node.new(tag_name, value, attributes).to_xml
+        end
+      end
+    end#self.to_xml
+
+
+    # Class method to filter out attributes and content
+    # from a given hash
+    def self.filter(hash)
+      attribs = {}
+      content = hash.dup
+
+      content.keys.select{|k| k =~ /^@/ }.each do |k|
+        attribs[k[1..-1]] = content.delete(k)
+      end
+
+      # Use _content value if defined
+      content = content.delete("=") || content
+
+      return [content, attribs]
+    end#self.filter
+
+  private
+
+    # Provides a convenience function to iterate over the hash
+    # Logic will filter out attribute and content keys from hash values
+    def self.each_with_xml(hash)
+      xml = Builder::XmlMarkup.new
+
+      hash.each do |key,value|
+        node_value = value
+        node_attrs = {}
+
+        # yank the attribute keys into their own hash
+        if value.respond_to?(:keys)
+          filtered = Hash.filter(value)
+          node_attrs = filtered.last
+          node_value = filtered.first
+        end
+
+        yield xml, key, node_value, node_attrs
+      end
+
+      xml.target!
+    end#self.each_with_xml
+
+  end#Hash
+
+end#XmlFu

data/lib/xml-fu/node.rb

@@ -0,0 +1,143 @@
+require 'builder'
+require 'cgi'
+require 'date'
+
+require 'xml-fu/core_ext/string'
+
+module XmlFu
+
+  # Class to contain logic for converting a key/value pair into an XML node
+  class Node
+
+    # Custom exception class
+    class InvalidAttributesException < Exception; end
+
+    # xs:dateTime format.
+    XS_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+    # default set of algorithms to choose from
+    ALGORITHMS = {
+      :lower_camelcase => lambda { |sym| sym.to_s.lower_camelcase },
+      :camelcase => lambda { |sym| sym.to_s.camelcase },
+      :snakecase => lambda { |sym| sym.to_s },
+      :none => lambda { |sym| sym.to_s }
+    }
+
+    # Class method for retrieving global Symbol-to-string conversion algorithm
+    # @return [lambda]
+    def self.symbol_conversion_algorithm
+      @symbol_conversion_algorithm ||= ALGORITHMS[:lower_camelcase]
+    end#self.symbol_conversion_algorithm
+
+    # Class method for setting global Symbol-to-string conversion algorithm
+    # @param [lambda] algorithm Should accept a symbol as an argument and return a string
+    def self.symbol_conversion_algorithm=(algorithm)
+      algorithm = ALGORITHMS[algorithm] unless algorithm.respond_to?(:call)
+      raise(ArgumentError, "Invalid symbol conversion algorithm") unless algorithm
+      @symbol_conversion_algorithm = algorithm
+    end#self.symbol_conversion_algorithm=
+
+    attr_accessor :escape_xml
+    attr_accessor :self_closing
+
+    # Create XmlFu::Node object
+    # @param [String, Symbol] name Name of node
+    # @param value Simple Value or nil
+    # @param [Hash] attributes Optional hash of attributes to apply to XML Node
+    def initialize(name, value, attributes={})
+      @escape_xml = true
+      @self_closing = false
+      self.attributes = attributes
+      self.value = value
+      self.name = name
+    end#initialize
+
+    attr_reader :attributes
+    def attributes=(val)
+      if ::Hash === val
+        @attributes = val
+      else
+        raise(InvalidAttributesException, "Attempted to set attributes to non-hash value")
+      end
+    end
+
+    attr_reader :name
+    def name=(val)
+      use_name = val.dup
+
+      use_name = name_parse_special_characters(use_name)
+
+      # TODO: Add additional logic that Gyoku XmlKey puts in place 
+     
+      # remove ":" if name begins with ":" (i.e. no namespace)
+      use_name = use_name[1..-1] if use_name[0,1] == ":"
+
+      if Symbol === val
+        use_name = self.class.symbol_conversion_algorithm.call(use_name)
+      end
+
+      # Set name to remaining value
+      @name = "#{use_name}"
+    end#name=
+
+    # Converts name into proper XML node name
+    # @param [String, Symbol] val Raw name
+    def name_parse_special_characters(val)
+      use_this = val.dup
+
+      # Will this be a self closing node?
+      if use_this.to_s[-1,1] == '/'
+        @self_closing = true 
+        use_this.chop!
+      end
+
+      # Will this node contain escaped XML?
+      if use_this.to_s[-1,1] == '!'
+        @escape_xml = false
+        use_this.chop!
+      end
+
+      # Ensure that we don't have special characters at end of name
+      while ["!","/","*"].include?(use_this.to_s[-1,1]) do
+        use_this.chop!
+      end
+
+      return use_this
+    end#name_parse_special_characters
+
+    # Custom Setter for @value instance method
+    def value=(val)
+      if DateTime === val || Time === val || Date === val
+        @value = val.strftime XS_DATETIME_FORMAT
+      elsif val.respond_to?(:to_datetime)
+        @value = val.to_datetime
+      elsif val.respond_to?(:call)
+        @value = val.call
+      elsif val.nil?
+        @value = nil
+      else
+        @value = val.to_s
+      end
+    end#value=
+
+    # @return [String, nil]
+    # Value can be nil, else it should return a String value.
+    def value
+      return CGI.escapeHTML(@value) if String === @value && @escape_xml
+      return @value
+    end#value
+
+    # Create XML String from XmlFu::Node object
+    def to_xml
+      xml = Builder::XmlMarkup.new
+      case
+      when @self_closing  then xml.tag!(@name, @attributes)
+      when @value.nil?    then xml.tag!(@name, @attributes.merge!("xsi:nil" => "true"))
+      else                     xml.tag!(@name, @attributes) { xml << self.value }
+      end
+      xml.target!
+    end#to_xml
+
+  end#Node
+
+end#XmlFu

data/lib/xml-fu/version.rb

@@ -0,0 +1,3 @@
+module XmlFu
+  VERSION = "0.1.0"
+end

data/lib/xml-fu.rb

@@ -0,0 +1,53 @@
+#require "xml-fu/version"
+require "xml-fu/hash"
+require "xml-fu/array"
+
+module XmlFu
+  class << self
+    
+    @@infer_simple_value_nodes = false
+
+    # Convert construct into XML
+    def xml(construct, options={})
+      case construct
+      when ::Hash   then Hash.to_xml( construct.dup, options )
+      when ::Array  then Array.to_xml( construct.dup, options )
+      end
+    end#convert
+
+    # @todo Add Nori-like parsing capability to convert XML back into XmlFu-compatible Hash/Array
+    # Parse XML into array of hashes.  If XML used as input contains only sibling nodes, output 
+    # will be array of hashes corresponding to those sibling nodes.
+    #
+    #     <foo/><bar/> => [{"foo/" => ""}, {"bar/" => ""}]
+    #
+    # If XML used as input contains a full document with root node, output will be
+    # an array of one hash (the root node hash)
+    #
+    #     <foo><bar/><baz/></foo> => [{"foo" => [{"bar/" => ""},{"baz/" => ""}] }]
+    def hash(xml, options)
+    end
+
+    def configure
+      yield self
+    end
+
+    # Set configuration option to be used with future releases
+    def infer_simple_value_nodes=(val)
+      @@infer_simple_value_nodes = val
+    end
+
+    # Configuration option to be used with future releases
+    # This option should allow for the inferrance of parent node names of simple value types
+    #
+    # Example:
+    #     1 => <Integer>1</Integer>
+    #     true => <Boolean>true</Boolean>
+    #
+    # This is disabled by default as it is conflicting with working logic.
+    def infer_simple_value_nodes
+      return @@infer_simple_value_nodes
+    end
+
+  end#class<<self
+end#XmlFu

data/spec/lib/array_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe XmlFu::Array do
+
+  describe ".to_xml" do
+    #after do
+    #  XmlFu.infer_simple_value_nodes = false
+    #end
+
+    #it "should infer simple value type nodes with configuration turned on" do
+    #  mixed_hash = {
+    #    "foo" => [
+    #      {:bar => "biz"}, 
+    #      nil, 
+    #      true, 
+    #      false, 
+    #      3.14, 
+    #      "simple string", 
+    #      ["another","array","of","values"]
+    #    ]
+    #  }
+    #  XmlFu.infer_simple_value_nodes = true
+    #  XmlFu.xml(mixed_hash).should_not == "<foo><bar>biz</bar></foo>"
+    #
+    #  XmlFu.infer_simple_value_nodes = false
+    #  XmlFu.xml(mixed_hash).should == "<foo><bar>biz</bar></foo>"
+    #
+    #  XmlFu.infer_simple_value_nodes = false
+    #end
+
+    it "should flatten nested arrays properly" do
+      hash = { 
+        :foo => [
+          [{"a/" => nil}, {"b/" => nil}],
+          {"c/" => nil},
+          [
+            [{"d/" => nil}, {"e/" => nil}],
+            {"f/" => nil}
+          ]
+        ]
+      }
+      expected = "<foo><a/><b/><c/><d/><e/><f/></foo>"
+      XmlFu.xml(hash).should == expected
+    end
+
+    describe "creating siblings with special key character (*)" do
+      it "should create siblings with special key character" do
+        hash = { "person*" => ["Bob", "Sheila"] }
+        XmlFu.xml(hash).should == "<person>Bob</person><person>Sheila</person>"
+      end
+
+      it "should create siblings with mixed attributes" do
+        hash = { 
+          "person*" => { 
+            "@foo" => "bar", 
+            "=" => ["Bob", "Sheila"] 
+          }
+        }
+        XmlFu.xml(hash).should == "<person foo=\"bar\">Bob</person><person foo=\"bar\">Sheila</person>"
+      end
+
+      it "should create siblings with complex mixed attributes" do
+        hash = { 
+          "person*" => { 
+            "@foo" => "bar", 
+            "=" => [
+              {"@foo" => "nope", "=" => "Bob"}, 
+              "Sheila"
+            ] 
+          }
+        }
+        XmlFu.xml(hash).should == "<person foo=\"nope\">Bob</person><person foo=\"bar\">Sheila</person>"
+      end
+    end
+
+  end
+end

data/spec/lib/hash_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe XmlFu::Hash do
+
+  describe ".to_xml" do
+    it "for a simple Hash" do
+      XmlFu::Hash.to_xml(:some => "body").should == "<some>body</some>"
+    end
+
+    it "for a nested Hash" do
+      XmlFu::Hash.to_xml(:foo => {:bar => "biz" }).should == "<foo><bar>biz</bar></foo>"
+    end
+
+    it "for a hash with multiple keys" do
+      XmlFu::Hash.to_xml(:first => "myself", :second => "the world").should include(
+        "<first>myself</first>",
+        "<second>the world</second>"
+      )
+    end
+
+
+    describe "for a hash value with '=' key defined" do
+      it "should ignore '=' for self-closing tag" do
+        hash = {"foo/" => {"@id" => "1", "=" => "PEEKABOO"}}
+        XmlFu.xml(hash).should == "<foo id=\"1\"/>"
+      end
+
+      it "should set additional content using '=' key" do
+        hash = {:foo => {"@id" => "1", "=" => "Hello"}}
+        XmlFu.xml(hash).should == "<foo id=\"1\">Hello</foo>"
+      end
+    end
+
+    describe "with a key that will contain multiple nodes" do
+      describe "when key explicitly denotes value is a collection" do
+        hash = { "foo*" => ["bar", "biz"] }
+        XmlFu::Hash.to_xml(hash).should == "<foo>bar</foo><foo>biz</foo>"
+      end
+
+      describe "when key denotes value contains children" do
+        it "for array consisting entirely of simple values" do
+          XmlFu::Hash.to_xml(:foo => ["bar", "biz"]).should == "<foo></foo>"
+        end
+
+        it "for array containing mix of simple and complex values" do
+          XmlFu::Hash.to_xml(:foo => ["bar", {:biz => "bang"}]).should == "<foo><biz>bang</biz></foo>"
+        end
+
+        it "for array containing complex values" do
+          hash1 = {:foo => "bar"}
+          hash2 = {:bar => "biz"}
+          XmlFu::Hash.to_xml(:lol => [hash1, hash2]).should == "<lol><foo>bar</foo><bar>biz</bar></lol>"
+        end
+
+        it "for array containing nil values" do
+          XmlFu::Hash.to_xml(:foo => [nil, {:bar => "biz"}]).should == "<foo><bar>biz</bar></foo>"
+        end
+      end
+    end
+  end
+end

data/spec/lib/node_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe XmlFu::Node do
+
+  describe "setting instance variables" do
+    it "should correctly remove special characters from a name" do
+      node = XmlFu::Node.new("foo/", "something")
+      node.name.should == "foo"
+
+      node = XmlFu::Node.new("foo*", "something")
+      node.name.should == "foo"
+
+      node = XmlFu::Node.new("foo!", "something")
+      node.name.should == "foo"
+    end
+
+    it "should set self-closing with special name character" do
+      node = XmlFu::Node.new("foo/", "something")
+      node.self_closing.should == true
+    end
+
+    it "should set escape_xml with special name character" do
+      node = XmlFu::Node.new("foo!", "something")
+      node.escape_xml.should == false
+    end
+
+    it "should set attributes with a hash" do
+      node = XmlFu::Node.new("foo", "bar", {:this => "that"})
+      node.attributes.should == {:this => "that"}
+
+      lambda { node.attributes = "foo" }.should raise_error(XmlFu::Node::InvalidAttributesException)
+    end
+
+    it "should be able to set a nil value" do
+      node = XmlFu::Node.new("foo", nil)
+      node.value.should == nil
+    end
+
+    it "should format a Data/Time value to acceptable string value" do
+      formatted_regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/
+
+      node = XmlFu::Node.new("now", Time.now)
+      node.value.should match formatted_regex
+
+      node = XmlFu::Node.new("today", Date.today)
+      node.value.should match formatted_regex
+    end
+
+    it "should properly convert names without proper namespacing" do
+      node = XmlFu::Node.new(":foo", "bar")
+      node.name.should == "foo"
+    end
+
+    it "should properly preserve namespaceds names" do
+      node = XmlFu::Node.new("foo:bar", "biz")
+      node.name.should == "foo:bar"
+    end
+  end
+
+  describe "to_xml" do
+    
+    describe "should return self-closing nil XML node for nil value" do
+
+      it "provided ANY non-blank name" do
+        nil_foo = "<foo xsi:nil=\"true\"/>"
+        node = XmlFu::Node.new("foo", nil)
+        node.to_xml.should == nil_foo
+
+        node = XmlFu::Node.new("foo!", nil)
+        node.to_xml.should == nil_foo
+
+        node = XmlFu::Node.new("foo*", nil)
+        node.to_xml.should == nil_foo
+      end
+
+      it "with additional attributes provided" do
+        node = XmlFu::Node.new("foo", nil, {:this => "that"})
+        node.to_xml.should == "<foo this=\"that\" xsi:nil=\"true\"/>"
+      end
+
+    end
+
+    it "should escape values by default" do
+      node = XmlFu::Node.new("foo", "<bar/>")
+      node.to_xml.should == "<foo>&lt;bar/&gt;</foo>"
+    end
+
+    it "should not escape values when provided with a special name" do
+      node = XmlFu::Node.new("foo!", "<bar/>")
+      node.to_xml.should == "<foo><bar/></foo>"
+    end
+
+    it "should ignore starred key (key*) for simple values" do
+      node = XmlFu::Node.new("foo*", "bar")
+      node.to_xml.should == "<foo>bar</foo>"
+
+      node = XmlFu::Node.new("pi*", 3.14159)
+      node.to_xml.should == "<pi>3.14159</pi>"
+    end
+
+    describe "when name denotes a self-closing XML node" do
+      it "should ignore tag content/value if it isn't a hash" do
+        node = XmlFu::Node.new("foo/", nil)
+        node.to_xml.should == "<foo/>"
+
+        node = XmlFu::Node.new("foo/", "bar")
+        node.to_xml.should == "<foo/>"
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'xml-fu'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end

data/spec/xmlfu_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe XmlFu do
+  describe ".xml" do
+    it "translates a given Hash to XML" do
+      XmlFu.xml( :id => 1 ).should == "<id>1</id>"
+    end
+
+    it "doesn't modify the input hash" do
+      the_hash = {
+        :person => {
+          "@id" => "007",
+          :first_name => "James",
+          :last_name => "Bond"
+        }
+      }
+      original_hash = the_hash.dup
+
+      XmlFu.xml(the_hash)
+      original_hash.should == the_hash
+    end
+
+    it "should return correct value based on nested array of hashes" do
+      hash = {
+        "SecretAgents" => [
+          {"agent/" => {"@id"=>"006", "@name"=>"Alec Trevelyan"}}, 
+          {"agent/" => {"@id"=>"007", "@name"=>"James Bond"}}
+        ]
+      }
+      expected = "<SecretAgents><agent name=\"Alec Trevelyan\" id=\"006\"/><agent name=\"James Bond\" id=\"007\"/></SecretAgents>" 
+      XmlFu.xml(hash).should == expected
+    end
+
+    it "should return correct value for nested collection of hashes" do
+      hash = {
+        "foo*" => [
+          {"@bar" => "biz"},
+          {"@biz" => "bang"}
+        ]
+      }
+      XmlFu.xml(hash).should == "<foo bar=\"biz\"></foo><foo biz=\"bang\"></foo>"
+    end
+
+    it "should ignore nested values for content array" do
+      output = XmlFu.xml("foo/" => [{:bar => "biz"}, {:bar => "biz"}])
+      output.should == "<foo/>"
+    end
+
+    it "should ignore nested keys if they aren't attributes" do
+      output = XmlFu.xml("foo/" => {"bar" => "biz"})
+      output.should == "<foo/>"
+
+      output = XmlFu.xml("foo/" => {"@id" => "0"})
+      output.should == "<foo id=\"0\"/>"
+    end
+
+  end
+
+  describe "configure" do
+    it "yields the XmlFu module" do
+      XmlFu.configure do |xf|
+        xf.should respond_to(:infer_simple_value_nodes)
+      end
+    end
+  end
+
+  it "should set XmlFu Module variable 'infer_simple_value_nodes'" do
+    XmlFu.infer_simple_value_nodes.should == false
+    XmlFu.infer_simple_value_nodes = true
+    XmlFu.infer_simple_value_nodes.should == true
+    XmlFu.infer_simple_value_nodes = false
+    XmlFu.infer_simple_value_nodes.should == false
+  end
+
+end

data/xml-fu.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/xml-fu/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "xml-fu"
+  gem.version       = XmlFu::VERSION
+  gem.authors       = ["Ryan Johnson"]
+  gem.email         = ["rhino.citguy@gmail.com"]
+  gem.homepage      = "http://github.com/CITguy/#{gem.name}"
+  gem.summary       = %q{Simple Hash/Array to XML generation}
+  gem.description   = %q{
+    Inspired by the Gyoku gem for hash to xml conversion, 
+    XmlFu is designed to require no meta tagging for 
+    node attributes and content. (i.e. no :attributes! and no :order!)
+  }
+
+  gem.rubyforge_project = 'xml-fu'
+
+  gem.add_dependency "builder", ">= 2.1.2"
+
+  gem.add_development_dependency "rspec", ">= 2.4.0"
+  gem.add_development_dependency "autotest"
+  gem.add_development_dependency "mocha", "~> 0.9.9"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification 
+name: xml-fu
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id004
+description: "\n    Inspired by the Gyoku gem for hash to xml conversion, \n    XmlFu is designed to require no meta tagging for \n    node attributes and content. (i.e. no :attributes! and no :order!)\n  "
+email: 
+- rhino.citguy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/xml-fu.rb
+- lib/xml-fu/.FuNode.rb.swp
+- lib/xml-fu/array.rb
+- lib/xml-fu/core_ext/string.rb
+- lib/xml-fu/hash.rb
+- lib/xml-fu/node.rb
+- lib/xml-fu/version.rb
+- spec/lib/array_spec.rb
+- spec/lib/hash_spec.rb
+- spec/lib/node_spec.rb
+- spec/spec_helper.rb
+- spec/xmlfu_spec.rb
+- xml-fu.gemspec
+homepage: http://github.com/CITguy/xml-fu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: xml-fu
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simple Hash/Array to XML generation
+test_files: 
+- spec/lib/array_spec.rb
+- spec/lib/hash_spec.rb
+- spec/lib/node_spec.rb
+- spec/spec_helper.rb
+- spec/xmlfu_spec.rb
+has_rdoc: