cobravsmongoose 0.0.1

data/CHANGES

@@ -0,0 +1,2 @@
+== 0.0.1 (2006-04-16)
+* Initial release.

data/COPYING

@@ -0,0 +1,21 @@
+== Licence (MIT)
+
+Copyright (c) 2006 Paul Battley <pbattley@gmail.com>
+
+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

@@ -0,0 +1,14 @@
+== Cobra vs Mongoose
+
+Cobra vs Mongoose translates XML to and from Ruby Hash objects, following the BadgerFish convention (http://badgerfish.ning.com/).
+
+== Licence
+
+This code is free to use under the terms of the MIT licence. If you'd like to
+negotiate a different licence for a specific use, just contact me -- I'll
+almost certainly permit it.
+
+== Contact
+
+Comments are welcome. Send an email to pbattley@gmail.com.
+

data/lib/cobravsmongoose.rb

@@ -0,0 +1,153 @@
+require 'rexml/document'
+require 'cgi'
+
+#
+# CobraVsMongoose translates between XML documents and Ruby hashes according to the 
+# rules of the BadgerFish convention (see http://badgerfish.ning.com/).
+#
+class CobraVsMongoose
+
+  class ParseError < RuntimeError
+  end
+  
+  class << self
+
+    #
+    # Returns a Hash corresponding to the data structure of the given XML string.
+    #
+    # E.g.
+    #  xml = '<alice><bob>charlie</bob><bob>david</bob></alice>'
+    #  CobraVsMongoose.xml_to_hash(xml)
+    #  # => { "alice" => { "bob" => [{ "$" => "charlie" }, { "$" => "david" }] } }
+    #
+    def xml_to_hash(xml)
+      doc = REXML::Document.new(xml)
+      return xml_node_to_hash(doc.root_node)
+    end
+  
+    #
+    # Returns an XML string corresponding to the data structure of the given Hash.
+    #
+    # E.g.
+    #  hash = { "alice" => { "$" => "bob", "@charlie" => "david" } }
+    #  CobraVsMongoose.hash_to_xml(hash)
+    #  # => "<alice charlie='david'>bob</alice>"
+    #
+    # Note that, due to the fact that Ruby's hashes do not preserve ordering, the 
+    # order of XML elements is undefined. For a predictable order, see the 
+    # sort_keys class attribute.
+    #
+    def hash_to_xml(hash)
+      return nested_data_to_xml(hash.keys.first, hash.values.first)
+    end
+    
+    #
+    # The sort_keys class attribute is useful for testing, when a predictable order 
+    # is required in the generated XML. By setting CobraVsMongoose.sort_keys to true,
+    # hash-derived elements within a scope will be sorted by their element name, whilst
+    # attributes on an element will be sorted according to their name.
+    #
+    attr_accessor :sort_keys
+  
+  private
+
+    def xml_node_to_hash(node, parent_namespaces={}) #:nodoc
+      this_node = {}
+      namespaces = parent_namespaces.dup
+      node.attributes.each do |name, value|
+        case name
+        when 'xmlns'
+          (namespaces['@xmlns'] ||= {})['$'] = value
+        when /^xmlns:(.*)/
+          (namespaces['@xmlns'] ||= {})[$1] = value
+        else
+          this_node["@#{name}"] = value
+        end
+      end
+      node.each_child do |child|
+        case child.node_type
+        when :element
+          key, value = child.expanded_name, xml_node_to_hash(child, namespaces)
+        when :text
+          key, value = '$', unescape(child.to_s).strip
+          next if value.empty?
+        end
+        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
+      return this_node.merge(namespaces)
+    end
+    
+    def nested_data_to_xml(name, item, known_namespaces=[]) #:nodoc:
+      case item
+      when Hash
+        attributes = {}
+        children = {}
+        namespaces = known_namespaces.dup
+        opt_order(item).each do |key, value|
+          value = item[key]
+          case key
+          when '@xmlns'
+            value.each do |ns_name, ns_value|
+              full_ns_name = 'xmlns' << ((ns_name == '$') ? '' : ':' << ns_name)
+              unless known_namespaces.include?(full_ns_name)
+                namespaces << full_ns_name 
+                attributes[full_ns_name] = ns_value
+              end
+            end
+          when /^@(.*)/
+            attributes[$1] = value
+          else
+            children[key] = value
+          end
+        end
+        return make_tag(name, attributes) do
+          opt_order(children).map { |tag, value|
+            case tag
+            when '$'
+              escape(value)
+            else
+              nested_data_to_xml(tag, value, namespaces)
+            end
+          }.join
+        end
+      when Array
+        return item.map{ |subitem| nested_data_to_xml(name, subitem, known_namespaces) }.join
+      else
+        raise ParseError, "unparseable type: #{item.class}"
+      end
+    end
+    
+    def make_tag(name, attributes={}) #:nodoc:
+      attr_string = ' ' << opt_order(attributes).map{ |k, v| "#{k}='#{escape(v)}'"  }.join(' ')
+      attr_string = '' if attr_string == ' '
+      body = yield
+      if body && !body.empty?
+        return "<#{name}#{attr_string}>" << body << "</#{name}>"
+      else
+        return "<#{name}#{attr_string} />"
+      end
+      return result
+    end
+    
+    def escape(str) #:nodoc:
+      return CGI.escapeHTML(str)
+    end
+    
+    def unescape(str) #:nodoc:
+      return CGI.unescapeHTML(str)
+    end
+    
+    def opt_order(hash)
+      return sort_keys ? hash.sort_by{ |kv| kv.first } : hash 
+    end
+    
+  end
+end

data/test/all.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__)+'/*_test.rb'].each do |test|
+  require test
+end

data/test/hash_to_xml_test.rb

@@ -0,0 +1,38 @@
+$: << File.dirname(__FILE__) + '/../lib/'
+require 'cobravsmongoose'
+require 'test/unit'
+begin
+  require 'test/unit/xml' 
+rescue 
+  puts 'You need to install Test::Unit::XML (http://testunitxml.rubyforge.org/) for this test.'
+end
+require File.dirname(__FILE__) + '/test_data'
+
+class HashToXMLTest < Test::Unit::TestCase
+  
+  COBRA_VS_MONGOOSE_TEST_DATA.each do |name, data|
+    method = ("test_data_" << name.to_s << "_hash_to_xml").to_sym
+    define_method(method) do
+      assert_hash_to_xml(name)
+    end
+  end
+  
+  def test_data_loaded
+    assert !COBRA_VS_MONGOOSE_TEST_DATA.empty?
+    assert methods.grep(/^test_/).length > COBRA_VS_MONGOOSE_TEST_DATA.keys.length
+  end
+  
+  def assert_hash_to_xml(name)
+    CobraVsMongoose.sort_keys = true
+    source, expected = COBRA_VS_MONGOOSE_TEST_DATA[name]
+    assert_not_nil(expected)
+    assert_not_nil(source)
+    actual = CobraVsMongoose.hash_to_xml(source)
+    if (expected == actual)
+      assert true
+    else
+      assert_xml_equal(expected, actual)
+    end
+  end
+  
+end

data/test/test_data.rb

@@ -0,0 +1,100 @@
+COBRA_VS_MONGOOSE_TEST_DATA = {
+  :text_content => [
+    { 'alice' => { '$' => 'bob' } },
+    '<alice>bob</alice>'
+  ],
+  :nested_elements => [
+    { 
+      "alice" => { 
+        "bob" => { "$" => "charlie" }, 
+        "david" => { "$" => "edgar"} 
+      } 
+    },
+    '<alice><bob>charlie</bob><david>edgar</david></alice>'
+  ],
+  :multiple_elements => [
+    { 
+      "alice" => { 
+        "bob" => [
+          { "$" => "charlie" }, 
+          { "$" => "david" }
+        ] 
+      } 
+    },
+    '<alice><bob>charlie</bob><bob>david</bob></alice>'
+  ],
+  :attributes => [
+    { 
+      "alice" => { 
+        "$" => "bob", 
+        "@charlie" => "david" 
+      } 
+    },
+    '<alice charlie="david">bob</alice>'
+  ],
+  :namespace_uri => [
+    { 
+      "alice" => { 
+        "$" => "bob", 
+        "@xmlns" => { 
+          "$" => "http://some-namespace"
+        } 
+      } 
+    },
+    '<alice xmlns="http://some-namespace">bob</alice>'
+  ],
+  :other_namespaces => [
+    { 
+      "alice" => { 
+        "$" => "bob", 
+        "@xmlns" => { 
+          "$" => "http://some-namespace", 
+          "charlie" => "http://some-other-namespace" 
+        } 
+      } 
+    },
+    '<alice xmlns="http://some-namespace" xmlns:charlie="http://some-other-namespace">bob</alice>'
+  ],
+  :namespace_prefixes => [
+    { 
+      "alice" => { 
+        "bob" => { 
+          "$" => "david" , 
+          "@xmlns" => {
+            "charlie" => "http://some-other-namespace" , 
+            "$" => "http://some-namespace"
+          } 
+        }, 
+        "charlie:edgar" => {
+          "$" => "frank", 
+          "@xmlns" => {
+            "charlie" => "http://some-other-namespace", 
+            "$" => "http://some-namespace"
+          } 
+        }, 
+        "@xmlns" => { 
+          "charlie" => "http://some-other-namespace", 
+          "$" => "http:\/\/some-namespace"
+        } 
+      } 
+    },
+    '<alice xmlns="http://some-namespace" xmlns:charlie="http://some-other-namespace"> 
+    <bob>david</bob> <charlie:edgar>frank</charlie:edgar> </alice>'
+  ],
+  :attribute_escaping => [
+    {"a" => {"@attribute" => "foo & bar", "$" => "string"}},
+    "<a attribute='foo &amp; bar'>string</a>"
+  ],
+  :string_escaping => [
+    {"a" => {"$" => "foo & bar"}},
+    "<a>foo &amp; bar</a>"
+  ],
+  :empty_element => [
+    {"a" => {}},
+    "<a />"
+  ],
+  :empty_element_with_attributes => [
+    {"a" => {"@foo" => "bar"}},
+    "<a foo='bar' />"
+  ]
+}

data/test/xml_to_hash_test.rb

@@ -0,0 +1,27 @@
+$: << File.dirname(__FILE__) + '/../lib/'
+require 'cobravsmongoose'
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_data'
+
+class XMLToHashTest < Test::Unit::TestCase
+  
+  COBRA_VS_MONGOOSE_TEST_DATA.each do |name, data|
+    method = ("test_data_" << name.to_s << "_xml_to_hash").to_sym
+    define_method(method) do
+      assert_xml_to_hash(name)
+    end
+  end
+  
+  def test_data_loaded
+    assert !COBRA_VS_MONGOOSE_TEST_DATA.empty?
+    assert methods.grep(/^test_/).length > COBRA_VS_MONGOOSE_TEST_DATA.keys.length
+  end
+    
+  def assert_xml_to_hash(name)
+    expected, source = COBRA_VS_MONGOOSE_TEST_DATA[name]
+    assert_not_nil(expected)
+    assert_not_nil(source)
+    assert_equal(expected, CobraVsMongoose.xml_to_hash(source))
+  end
+  
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: cobravsmongoose
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-04-16 00:00:00 +01:00
+summary: Translates XML to and from Ruby Hash objects, following the BadgerFish convention.
+require_paths: 
+- lib
+email: pbattley@gmail.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Paul Battley
+files: 
+- lib/cobravsmongoose.rb
+- test/all.rb
+- test/hash_to_xml_test.rb
+- test/test_data.rb
+- test/xml_to_hash_test.rb
+- README
+- CHANGES
+- COPYING
+test_files: 
+- test/all.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- COPYING
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+