pipa-xmlnuts 0.0.2 → 0.0.5

data/lib/xmlnuts/backend.rb

@@ -0,0 +1,38 @@
+require 'monitor'
+
+module XmlNuts
+  module XmlBackend
+    extend MonitorMixin
+
+    autoload :REXMLBackend, 'xmlnuts/rexml'
+
+    def self.default
+      synchronize do
+        unless defined? @@default
+          @@default = REXMLBackend.new
+          def self.default #:nodoc:
+            @@default
+          end
+          @@default
+        end
+      end
+    end
+
+    def self.default=(backend)
+      @@default = backend
+    end
+
+    def self.current
+      Thread.current[:xmlnuts_xml_backend] || default
+    end
+
+    def self.current=(backend)
+      Thread.current[:xmlnuts_xml_backend] = backend
+    end
+
+    private
+    def backend #:doc:
+      XmlBackend.current
+    end
+  end
+end

data/lib/xmlnuts/converters.rb

@@ -1,5 +1,7 @@
+require 'time'
+
 module XmlNuts
-  module Converters
+  module Converter
     def self.lookup(type)
       lookup!(type)
     rescue ArgumentError
@@ -22,7 +24,7 @@ module XmlNuts
       lookup!(type).new(options)
     end
 
-    class Convert_string #:nodoc:
+    class Convert_string
       def initialize(options)
         @whitespace = options[:whitespace] || :trim
       end
@@ -41,7 +43,7 @@ module XmlNuts
       end
     end
 
-    class Convert_boolean < Convert_string #:nodoc:
+    class Convert_boolean < Convert_string
       def initialize(options)
         super
         @format = options[:format] || :truefalse
@@ -68,7 +70,7 @@ module XmlNuts
       end
     end
 
-    class Convert_integer < Convert_string #:nodoc:
+    class Convert_integer < Convert_string
       def initialize(options)
         super
       end
@@ -82,7 +84,7 @@ module XmlNuts
       end
     end
 
-    class Convert_datetime < Convert_string #:nodoc:
+    class Convert_datetime < Convert_string
       def initialize(options)
         super
         @fraction_digits = options[:fraction_digits] || 0
@@ -92,19 +94,19 @@ module XmlNuts
         time && time.xmlschema(@fraction_digits)
       end
 
-      def self.from_xml(string)
+      def from_xml(string)
         string && Time.parse(super(string, options))
       end
     end
 
-    class Convert_list #:nodoc:
+    class Convert_list
       def initialize(options)
         @item_type = options[:item_type] || :string
-        @item_converter = Converters.create!(@item_type, options)
+        @item_converter = Converter.create!(@item_type, options)
       end
 
       def to_xml(array)
-        array.map {|x| @item_converter.to_xml(x) } * ' '
+        array && array.map {|x| @item_converter.to_xml(x) } * ' '
       end
 
       def from_xml(string)

data/lib/xmlnuts/mappings.rb

@@ -1,137 +1,138 @@
-module XmlNuts
-  class Mapping
-    attr_reader :name, :xmlname, :type, :options, :converter
-
-    def initialize(name, type, options)
-      @name, @xmlname, @type, @options = name.to_sym, (options.delete(:xmlname) || name).to_s, type, options
-      @setter = :"#{name}="
-      @converter = Converters.create(type, options)
-    end
+require 'enumerator'
+require 'xmlnuts/backend'
+require 'xmlnuts/converters'
 
-    def to_xml(nut, node)
-      setxml(node, toxml(get(nut)))
-    end
+module XmlNuts
+  module Mappings
+    class Mapping
+      attr_reader :xmlname, :xmlns, :options
 
-    def from_xml(nut, node)
-      set(nut, froxml(getxml(node)))
+      def initialize(xmlname, options)
+        @xmlname, @xmlns, @options = xmlname.to_s, options.delete(:xmlns), options
+      end
     end
 
-    private
-    def get(nut) #:doc:
-      nut.send(name)
+    class Root < Mapping
+      def initialize(xmlname, options = {})
+        super
+      end
     end
 
-    def set(nut, value) #:doc:
-      nut.send(@setter, value)
-    end
+    class MemberMapping < Mapping
+      include XmlBackend
+
+      attr_reader :name, :type, :converter
+
+      def initialize(name, type, options)
+        super(options.delete(:xmlname) || name, options)
+        case type
+        when Array
+          raise ArgumentError, "invalid value for type: #{type}" if type.length != 1
+          options[:item_type] = type.first
+          @converter = Converter.create!(:list, options)
+        when Class
+          options[:object_type] = type
+        else
+          @converter = Converter.create!(type, options)
+        end
+        @name, @setter, @type = name.to_sym, :"#{name}=", type
+      end
 
-    def toxml(value) #:doc:
-      value
-    end
+      def to_xml(nut, node)
+        setxml(node, get(nut))
+      end
 
-    def froxml(text) #:doc:
-      text
-    end
-  end
+      def from_xml(nut, node)
+        set(nut, getxml(node))
+      end
 
-  class PrimitiveMapping < Mapping
-    def initialize(name, type, options)
-      if type.is_a?(Array)
-        raise ArgumentError, "invalid value for type: #{type}" if type.length != 1
-        type, options[:item_type] = :list, type.first
+      private
+      def get(nut)
+        nut.send(@name)
       end
-      super
-      raise ArgumentError, "converter absent for type #{type.inspect}" unless converter
-    end
 
-    private
-    def toxml(value) #:doc:
-      converter.to_xml(value)
-    end
+      def set(nut, value)
+        nut.send(@setter, value)
+      end
 
-    def froxml(text) #:doc:
-      converter.from_xml(text)
-    end
-  end
+      def toxml(value)
+        @converter ? @converter.to_xml(value) : value
+      end
 
-  class ElementMapping < PrimitiveMapping
-    private
-    def getxml(node) #:doc:
-      (e = node.elements[xmlname]) && e.text
+      def froxml(text)
+        @converter ? @converter.from_xml(text) : text
+      end
     end
 
-    def setxml(node, value) #:doc:
-      (node.elements[xmlname] ||= REXML::Element.new(xmlname)).text = value
-    end
-  end
+    module NestedMixin #:nodoc:
+      private
+      def parse(node)
+        backend.each_element_with_value(node, xmlname, xmlns) {|el, txt| return type.parse_node(type.new, el) }
+        nil
+      end
 
-  class AttributeMapping < PrimitiveMapping
-    private
-    def getxml(node) #:doc:
-      node.attributes[xmlname]
+      def build(node, nut)
+        nut && type.build_node(nut, backend.add_element(node, xmlname, xmlns, nil))
+      end
     end
 
-    def setxml(node, value) #:doc:
-      node.add_attribute(xmlname, value)
-    end
-  end
+    module ElementsMixin #:nodoc:
+      private
+      def getxml(node)
+        node && backend.enum_for(:each_element_with_value, node, xmlname, xmlns).map {|el, v| froxml(v) }
+      end
 
-  module NestedMany
-    private
-    def toxml(nested_nuts) #:doc:
-      nested_nuts && nested_nuts.map {|x| super(x) }
-    end
+      def setxml(node, values)
+        values.each {|x| toxml(node, x) } if values
+      end
 
-    def froxml(nested_nodes) #:doc:
-      nested_nodes && nested_nodes.map {|x| super(x) }
+      def toxml(value, node)
+        super(value)
+      end
     end
-  end
 
-  class ElementsMapping < PrimitiveMapping
-    include NestedMany
+    class ElementValue < MemberMapping
+      private
+      def getxml(node)
+        backend.each_element_with_value(node, xmlname, xmlns) {|e, v| return froxml(v) }
+        nil
+      end
 
-    private
-    def getxml(node) #:doc:
-      (e = node.get_elements(xmlname)) && e.map {|x| x.text }
+      def setxml(node, value)
+        backend.add_element(node, xmlname, xmlns, toxml(value))
+      end
     end
 
-    def setxml(node, values) #:doc:
-      values.each {|x| node.add_element(xmlname).text = x } if values
-    end
-  end
+    class Element < MemberMapping
+      include NestedMixin
 
-  class NestedMapping < Mapping
-    private
-    def toxml(nested_nut) #:doc:
-      type.build_node(nested_nut, Element.new(xmlname))
+      private
+      alias getxml parse
+      alias setxml build
     end
 
-    def froxml(nested_node) #:doc:
-      type.parse_node(type.new, nested_node)
-    end
-  end
+    class Attribute < MemberMapping
+      private
+      def getxml(node)
+        froxml(backend.attribute(node, xmlname, xmlns))
+      end
 
-  class NestedOneMapping < NestedMapping
-    private
-    def getxml(node) #:doc:
-      node.elements[xmlname]
+      def setxml(node, value)
+        backend.set_attribute(node, xmlname, xmlns, toxml(value))
+      end
     end
 
-    def setxml(node, nested_node) #:doc:
-      node.elements << nested_node if nested_node
+    class ElementValues < MemberMapping
+      include ElementsMixin
     end
-  end
 
-  class NestedManyMapping < NestedMapping
-    include NestedMany
-
-    private
-    def getxml(node) #:doc:
-      node.get_elements(xmlname)
-    end
+    class Elements < MemberMapping
+      include NestedMixin
+      include ElementsMixin
 
-    def setxml(node, nested_nodes) #:doc:
-      nested_nodes.each {|x| node.add_element(x) }
+      private
+      alias froxml parse
+      alias toxml build
     end
   end
 end

data/lib/xmlnuts/nuts.rb

@@ -1,72 +1,211 @@
-require 'rexml/document'
-require 'time'
-require 'xmlnuts/converters'
 require 'xmlnuts/mappings'
 
 module XmlNuts #:nodoc:
+  # See also +ClassMethods+
   module Nut
+    include XmlBackend
+
     def self.included(other) #:nodoc:
       other.extend(ClassMethods)
     end
 
+    # See also Nut
     module ClassMethods
+      include XmlBackend
+      include Mappings
+
+      #    namespaces(hash) -> Hash
+      #    namespaces       -> Hash
+      #
+      # Updates and returns class-level prefix mappings.
+      # When given a hash of mappings merges it over current.
+      # When called withot arguments simply returns current mappings.
+      # 
+      # === Example:
+      #    class Cat
+      #      include XmlNuts::Nut
+      #      namespaces :lol => 'urn:lol', ...
+      #      ...
+      #    end
+      def namespaces(mappings = nil)
+        @namespaces ||= {}
+        mappings ? @namespaces.update(mappings) : @namespaces
+      end
+
+      #    root(xmlname[, :xmlns => ...]) -> Mappings::Root
+      #    root                           -> Mappings::Root
+      #
+      # Defines element name.
+      # TODO: moar details
+      #
+      # === Arguments
+      # +xmlname+:: Element name
+      # +options+:: +:xmlns+ => Element namespace
+      #
+      # === Example:
+      #    class Cat
+      #      include XmlNuts::Nut
+      #      ...
+      #      root :kitteh, :xmlns => 'urn:lol'
+      #      ...
+      #    end
+      def root(xmlname = nil, options = {})
+        @root = Root.new(xmlname, prepare_options(options)) if xmlname
+        @root ||= Root.new('root')
+      end
+
+      #    element(name, [type[, options]]) -> Mappings::Element or Mappings::ElementValue
+      #
+      # Defines single-element mapping.
+      #
+      # === Arguments
+      # +name+::    Accessor name
+      # +type+::    Element type. +:string+ assumed if omitted (see +Converter+).
+      # +options+:: +:xmlname+, +:xmlns+, converter options (see +Converter+).
+      #
+      # === Example:
+      #    class Cat
+      #      include XmlNuts::Nut
+      #      ...
+      #      element :name, :string, :whitespace => :collapse
+      #      element :cheeseburger, Cheeseburger, :xmlname => :cheezburger
+      #      ...
+      #    end
       def element(name, type = :string, options = {})
-        mappings << (type.is_a?(Class) ? NestedOneMapping : ElementMapping).new(name, type, options)
-        attr_accessor name
+        define_accessor name
+        (mappings << (type.is_a?(Class) ? Element : ElementValue).new(name, type, prepare_options(options))).last
       end
 
+      #    elements(name, [type[, options]]) -> Mappings::Element or Mappings::ElementValue
+      #
+      # Defines multiple elements mapping.
+      #
+      # === Arguments
+      # +name+::    Accessor name
+      # +type+::    Element type. +:string+ assumed if omitted (see +Converter+).
+      # +options+:: +:xmlname+, +:xmlns+, converter options (see +Converter+).
+      #
+      # === Example:
+      #    class RichCat
+      #      include XmlNuts::Nut
+      #      ...
+      #      elements :ration, :string, :whitespace => :collapse
+      #      elements :cheeseburgers, Cheeseburger, :xmlname => :cheezburgers
+      #      ...
+      #    end
       def elements(name, type = :string, options = {})
-        mappings << (type.is_a?(Class) ? NestedManyMapping : ElementsMapping).new(name, type, options)
-        attr_accessor name
+        define_accessor name
+        (mappings << (type.is_a?(Class) ? Elements : ElementValues).new(name, type, prepare_options(options))).last
       end
 
+      #    attribute(name, [type[, options]]) -> Mappings::Attribute or Mappings::AttributeValue
+      #
+      # Defines attribute mapping.
+      #
+      # === Arguments
+      # +name+::    Accessor name
+      # +type+::    Element type. +:string+ assumed if omitted (see +Converter+).
+      # +options+:: +:xmlname+, +:xmlns+, converter options (see +Converter+).
+      #
+      # === Example:
+      #    class Cat
+      #      include XmlNuts::Nut
+      #      ...
+      #      element :name, :string, :whitespace => :collapse
+      #      element :cheeseburger, Cheeseburger, :xmlname => :cheezburger
+      #      ...
+      #    end
       def attribute(name, type = :string, options = {})
-        mappings << AttributeMapping.new(name, type, options)
-        attr_accessor name
+        define_accessor name
+        mappings << Attribute.new(name, type, prepare_options(options))
       end
 
+      #    mappings -> Array
+      #
+      # Returns all previously defined XmlNuts mappings on a class.
       def mappings
         @mappings ||= []
       end
 
-      def build(nut, destination = nil)
-        case destination
-        when nil
-          destination = REXML::Document.new
-          e = destination.add_element('root')
-          build_node(nut, e)
-        when REXML::Node
-          build_node(nut, destination)
-        end
-        destination
+      def parse(source, options = {})
+        backend.parse(source, options) {|node| new.parse_node(node) }
       end
 
-      def parse(source)
-        case source
-        when nil
-          nil
-        when REXML::Node
-          parse_node(new, source)
-        when String
-          doc = REXML::Document.new(source)
-          (root = doc.root) ? parse_node(new, root) : nil
-        end
-      end
-
-      def build_node(nut, node)
+      def build_node(nut, node) #:nodoc:
+        backend.add_namespaces(node, namespaces)
         callem(:to_xml, nut, node)
         node
       end
 
-      def parse_node(nut, node)
-        callem(:from_xml ,nut, node)
+      def parse_node(nut, node) #:nodoc:
+        callem(:from_xml, nut, node)
         nut
       end
 
       private
-      def callem(method, nut, node)
-        mappings.each {|m| m.send(method, nut, node) }
+      def prepare_options(options)
+        ns = options[:xmlns]
+        if ns.is_a?(Symbol)
+          raise ArgumentError, "undefined prefix: #{ns}" unless options[:xmlns] = namespaces[ns]
+        end
+        options
       end
+
+      def define_accessor(name)
+        if method_defined?(name) || method_defined?("#{name}=")
+          raise ArgumentError, "#{name}: name already defined or reserved"
+        end
+        attr_accessor name
+      end
+
+      def callem(method, *args)
+        mappings.each {|m| m.send(method, *args) }
+      end
+    end
+
+    def parse(source, options = {})
+      backend.parse(source, options) {|node| parse_node(node) }
+    end
+
+    #    build([options])              -> root element or string
+    #    build([options])              -> root element or string
+    #    build(destination[, options]) -> destination
+    #
+    # Defines attribute mapping.
+    #
+    # === Arguments
+    # +destination+:: Can be given a symbol a backend-specific object,
+    #                 an instance of String or IO classes.
+    # - +:string+   -> will return an XML string.
+    # - +:document+ -> will return a backend specific document object.
+    # - +:object+   -> will return a backend specific object. New document will be created.
+    # - an instance of +String+:    the contents of the string will be replaced with
+    #                the generated XML.
+    # - an instance of +IO+: the IO will be written to.
+    # +options+::     Backend-specific options
+    #
+    # === Example:
+    #    cat = Cat.new
+    #    cat.name = 'Pussy'
+    #    puts cat.build
+    #    ...
+    #    doc = REXML::Document.new
+    #    cat.build(doc)
+    #    puts doc.to_s
+    def build(result = :string, options = {})
+      options, result = result, :string if result.is_a?(Hash)
+      root = self.class.root
+      options[:xmlname] ||= root.xmlname
+      options[:xmlns_prefix] = self.class.namespaces.invert[options[:xmlns] ||= root.xmlns]
+      backend.build(result, options) {|node| build_node(node) }
+    end
+
+    def parse_node(node) #:nodoc:
+      self.class.parse_node(self, node)
+    end
+
+    def build_node(node) #:nodoc:
+      self.class.build_node(self, node)
     end
   end
 end

data/lib/xmlnuts/rexml.rb

@@ -0,0 +1,94 @@
+require 'rexml/document'
+require 'xmlnuts/backend'
+
+class XmlNuts::XmlBackend::REXMLBackend #:nodoc:
+  def parse(source, options)
+    case source
+    when nil
+      return nil
+    when REXML::Document
+      node = source.root
+    when REXML::Node
+      node = source
+    when String, IO
+      node = REXML::Document.new(source).root
+    else
+      raise ArgumentError, 'invalid destination'
+    end
+    node && yield(node)
+  end
+
+  def build(result, options)
+    case result
+    when :string, :document, :object, String, IO
+      doc = REXML::Document.new
+    when REXML::Document
+      doc = result
+    when REXML::Node
+      node, doc = result, result.document
+    else
+      raise ArgumentError, 'invalid destination'
+    end
+    node ||= doc.root
+    unless node
+      name, ns, prefix = options[:xmlname], options[:xmlns], options[:xmlns_prefix]
+      name, ns = "#{prefix}:#{name}", nil if prefix
+      node = add_element(doc, name, ns, nil)
+    end
+
+    yield node
+
+    case result
+    when :string
+      doc.to_s
+    when String
+      result.replace(doc.to_s)
+    when IO
+      doc.write(result)
+      result
+    when REXML::Document, :document
+      doc
+    when REXML::Node, :object
+      node
+    end
+  end
+
+  def add_namespaces(context, namespaces)
+    namespaces.each {|prefix, uri| context.add_namespace(prefix.to_s, uri) }
+  end
+
+  def each_element_with_value(context, name, ns)
+    ns = context.namespace unless ns
+    REXML::XPath.each(context, "ns:#{name}", 'ns' => ns) {|el| yield el, el.text }
+  end
+
+  def attribute(context, name, ns)
+    name, ns = to_prefixed_name(context, name, ns, true)
+    context.attributes[name]
+  end
+
+  def set_attribute(context, name, ns, text)
+    name, ns = to_prefixed_name(context, name, ns, true)
+    context.add_attribute(name, text)
+  end
+
+  def add_element(context, name, ns, text)
+    name, ns = to_prefixed_name(context, name, ns, false)
+    elem = context.add_element(name)
+    elem.add_namespace(ns) if ns
+    elem.text = text if text
+    elem
+  end
+
+  private
+  def to_prefixed_name(context, name, ns, prefix_required)
+    if ns
+      if prefix = context.namespaces.invert[ns]
+        name, ns = "#{prefix}:#{name}", nil
+      else
+        raise ArgumentError, "no prefix defined for #{ns}" if prefix_required
+      end
+    end
+    return name, ns
+  end
+end

data/lib/xmlnuts.rb

@@ -1 +1,48 @@
 require 'xmlnuts/nuts'
+
+#class Cheezburger
+#  include XmlNuts::Nut
+#
+#  attribute :weight, :integer
+#end
+#
+#class Pet
+#  include XmlNuts::Nut
+#
+#  namespaces :pipi => 'a', :piz => 'b'
+#
+#  root 'anus', :xmlns => :piz
+#
+#  element :eats, [:string], :xmlname => :ration, :xmlns => 'a'
+#  element :species, :string, :whitespace => :collapse
+#  elements :paws, :string, :xmlname => :paw
+#
+#  attribute :has_tail, :boolean, :xmlname => 'has-tail', :xmlns => 'b'
+#  attribute :height, :integer
+#
+#  element :cheezburger, Cheezburger
+#end
+#
+#xml_fragment = <<-EOS
+#        <mypet xmlns='lol' xmlns:pizda="b" height=' 12 ' pizda:has-tail=' yes  '>
+#          <species>
+#silly
+#              mouse
+#          </species>
+#          <pi:ration xmlns:pi="a">
+#            tigers
+#            lions
+#          </pi:ration>
+#          <paw>  one</paw>
+#          <paw> two </paw>
+#          <paw>three</paw>
+#          <paw>four</paw>
+#          <cheezburger weight='2'>
+#          </cheezburger>
+#          <cub age='4'>
+#          </cub>
+#        </mypet>
+#EOS
+#pet = Pet.parse(xml_fragment)
+#
+#puts pet.build

data/test/parsing_test.rb

@@ -10,30 +10,35 @@ class Cheezburger
   attribute :weight, :integer
 end
 
-class Pet
+class Cat
   include XmlNuts::Nut
 
-  element :eats, [:string], :xmlname => :ration
-  element :species, :string, :whitespace => :collapse
+  namespaces :lol => 'urn:lol', :p => 'b'
+
+  root 'kitteh', :xmlns => 'lol'
+
+  element :eats, [:string], :xmlname => :ration, :xmlns => :lol
+  element :friend, :string, :whitespace => :collapse, :xmlns => 'c'
   elements :paws, :string, :xmlname => :paw
 
-  attribute :has_tail, :boolean, :xmlname => 'has-tail'
+  attribute :has_tail, :boolean, :xmlname => 'has-tail', :xmlns => 'b'
   attribute :height, :integer
 
   element :cheezburger, Cheezburger
 end
 
 class ParsingTest < Test::Unit::TestCase
-  context "Old McDonald's pet" do
-    setup do
-      @xml_fragment = <<-EOS
-        <mypet height=' 12 ' has-tail=' yes  '>
-          <species>   silly
+  def setup
+    @xml_fragment = <<-EOS
+        <mypet xmlns='lol' xmlns:aa='urn:lol' xmlns:bb='b' height=' 12 ' bb:has-tail=' yes  '>
+          <friend xmlns='c'>
+silly
               mouse
-          </species>
-          <ration>  tigers
-                    lions
-          </ration>
+          </friend>
+          <aa:ration>
+            tigers
+            lions
+          </aa:ration>
           <paw>  one</paw>
           <paw> two </paw>
           <paw>three</paw>
@@ -43,43 +48,45 @@ class ParsingTest < Test::Unit::TestCase
           <cub age='4'>
           </cub>
         </mypet>
-      EOS
-      @pet = Pet.parse(@xml_fragment)
-    end
+    EOS
+    @cat = Cat.parse(@xml_fragment)
+  end
 
-    should 'be a silly mouse' do
-      assert_equal 'silly mouse', @pet.species
+  context "A cat" do
+    should 'be a friend of a silly mouse' do
+      assert_equal 'silly mouse', @cat.friend
     end
 
     should 'eat tigers and lions' do
-      assert_equal ['tigers', 'lions'], @pet.eats
+      assert_equal ['tigers', 'lions'], @cat.eats
     end
 
     should 'be 12 meters tall' do
-      assert_equal 12, @pet.height
+      assert_equal 12, @cat.height
     end
 
     should 'have tail' do
-      assert_equal true, @pet.has_tail
+      assert_equal true, @cat.has_tail
     end
 
     should 'have four paws' do
-      assert_not_nil @pet.paws
-      assert_equal 4, @pet.paws.length
-      assert_equal %w(one two three four), @pet.paws
+      assert_not_nil @cat.paws
+      assert_equal 4, @cat.paws.length
+      assert_equal %w(one two three four), @cat.paws
+    end
+
+    should 'has cheezburger' do
+      assert_kind_of Cheezburger, @cat.cheezburger
+    end
+  end
+
+  context 'A cheezburger' do
+    setup do
+      @burger = @cat.cheezburger
     end
 
-    context 'should has cheezburger' do
-      setup do
-        assert_not_nil @burger = @pet.cheezburger
-        assert_kind_of Cheezburger, @pet.cheezburger
-      end
-
-      context 'that' do
-        should 'weigh 2 kg' do
-          assert_equal 2, @burger.weight
-        end
-      end
+    should 'weigh 2 kg' do
+      assert_equal 2, @burger.weight
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pipa-xmlnuts
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors: 
 - Igor Gunko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-14 00:00:00 -08:00
+date: 2008-12-16 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -29,6 +29,8 @@ files:
 - lib/xmlnuts/nuts.rb
 - lib/xmlnuts/mappings.rb
 - lib/xmlnuts/converters.rb
+- lib/xmlnuts/backend.rb
+- lib/xmlnuts/rexml.rb
 has_rdoc: true
 homepage: http://github.com/pipa/xmlnuts
 post_install_message: