peanuts 1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Igor Gunko
+
+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.rdoc

@@ -0,0 +1,104 @@
+=== Introduction
+Peanuts is an library that allows for bidirectional mapping between Ruby objects and XML.
+
+Released under the MIT license.
+
+=== Features
+- Type awareness (extensible).
+- XML namespaces support.
+- Pluggable backends to work with different XML APIs (REXML implemented so far).
+
+=== Installation
+  gem install omg-peanuts --source http://gems.github.com
+
+=== Usage
+Please see an example below.
+See also +Peanuts+, +Peanuts::ClassMethods+
+
+=== TODO
+- Inheritance
+- Mixins
+- More mappings?
+- More types?
+
+=== Docs
+http://rdoc.info/projects/omg/peanuts
+
+=== Bugs & such
+Please report via Github issue tracking.
+
+=== Example
+    class Cheezburger
+      include Peanuts
+
+      attribute :weight, :integer
+    end
+
+    class Cat
+      include Peanuts
+
+      namespaces :lol => 'urn:x-lol', :kthnx => 'urn:x-lol:kthnx'
+
+      root 'kitteh', :xmlns => :lol
+
+      attribute :has_tail, :boolean, :xmlname => 'has-tail', :xmlns => 'urn:x-lol:kthnx'
+      attribute :ears, :integer
+
+      element :ration, [:string], :xmlname => :eats, :xmlns => :kthnx
+      element :name, :string, :xmlns => 'urn:x-lol:kthnx'
+      elements :paws, :string, :xmlname => :paw
+
+      element :friends, :xmlname => :pals do # anonymous class definition follows within block
+        elements :names, :string, :xmlname => :friend, :xmlname => :pal
+      end
+
+      element :cheezburger, Cheezburger
+    end
+
+    xml_fragment = <<-EOS
+        <kitteh xmlns='urn:x-lol' xmlns:kthnx='urn:x-lol:kthnx' ears=' 2 ' kthnx:has-tail=' yes  '>
+          <name xmlns='urn:x-lol:kthnx'>
+              Silly
+              Tom
+          </name>
+          <kthnx:eats>
+            tigers
+            lions
+          </kthnx:eats>
+          <pals>
+            <pal>Chrissy</pal>
+            <pal>Missy</pal>
+            <pal>Sissy</pal>
+          </pals>
+          <paw>  one</paw>
+          <paw> two </paw>
+          <paw>three</paw>
+          <paw>four</paw>
+          <cheezburger weight='2' />
+        </kitteh>
+    EOS
+    cat = Cat.parse(xml_fragment)
+
+    assert_equal 'Silly Tom', cat.name
+    assert_equal %w(tigers lions), cat.ration
+    assert_equal ['Chrissy', 'Missy', 'Sissy'], cat.friends.names
+    assert_equal 2, cat.ears
+    assert_equal true, cat.has_tail
+    assert_equal %w(one two three four), cat.paws
+    assert_kind_of Cheezburger, cat.cheezburger
+    assert_equal 2, cat.cheezburger.weight
+    ...
+    puts cat.build
+
+
+=== See also
+* http://github.com/omg/threadpool -- Thread pool implementation
+* http://github.com/omg/statelogic -- A simple state machine for ActiveRecord
+
+
+
+Free hint: If you liek mudkipz^W^Wfeel like generous today you can tip me at http://tipjoy.com/u/pisuka
+
+
+Copyright (c) 2009 Igor Gunko, released under the MIT license
+

data/Rakefile

@@ -0,0 +1,26 @@
+$KCODE = 'u'
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+Rake::GemPackageTask.new(Gem::Specification.load('peanuts.gemspec')) do |p|
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "Peanuts Documentation"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/omg-peanuts.rb

@@ -0,0 +1 @@
+require 'peanuts'

data/lib/peanuts.rb

@@ -0,0 +1 @@
+require 'peanuts/nuts'

data/lib/peanuts/backend.rb

@@ -0,0 +1,38 @@
+require 'monitor'
+
+module Peanuts
+  module XmlBackend
+    extend MonitorMixin
+
+    autoload :REXMLBackend, 'peanuts/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[XmlBackend.name] || default
+    end
+
+    def self.current=(backend)
+      Thread.current[XmlBackend.name] = backend
+    end
+
+    private
+    def backend #:doc:
+      XmlBackend.current
+    end
+  end
+end

data/lib/peanuts/converters.rb

@@ -0,0 +1,224 @@
+module Peanuts
+  autoload :Time, 'time'
+  autoload :BigDecimal, 'bigdecimal'
+
+  # === Currently supported types:
+  # string::      see +Convert_string+
+  # boolean::     see +Convert_boolean+, +Convert_yesno+
+  # numeric::     see +Convert_integer+, +Convert_decimal+, +Convert_float+
+  # date & time:: see +Convert_datetime+
+  # lists::       see +Convert_list+
+  module Converter
+    def self.lookup(type)
+      lookup!(type)
+    rescue ArgumentError
+      nil
+    end
+
+    def self.lookup!(type)
+      const_get("Convert_#{type}")
+    rescue NameError
+      raise ArgumentError, "converter not found for #{type}"
+    end
+
+    def self.create(type, options)
+      create!(type, options)
+    rescue ArgumentError
+      nil
+    end
+
+    def self.create!(type, options)
+      lookup!(type).new(options)
+    end
+
+    # Who could have thought... a string.
+    # 
+    # Specifier:: <tt>:string</tt>
+    #
+    # ==== Options:
+    # [<tt>:whitespace => :collapse</tt>]
+    #   Whitespace handling behavior.
+    #   [<tt>:trim</tt>] Trim whitespace from both ends.
+    #   [<tt>:collapse</tt>] Collapse consecutive whitespace + trim as well.
+    #   [<tt>:preserve</tt>] Keep'em all.
+    class Convert_string
+      def initialize(options)
+        @whitespace = options[:whitespace] || :collapse
+      end
+
+      def to_xml(string)
+        string
+      end
+
+      def from_xml(string)
+        return nil unless string
+        string = case @whitespace
+        when :trim then string.gsub(/\A\s*|\s*\Z/, '')
+        when :preserve then string
+        when :collapse then string.gsub(/\s+/, ' ').gsub(/\A\s*|\s*\Z|\s*(?=\s)/, '')
+        end
+      end
+    end
+
+    # An XSD boolean.
+    #
+    # Specifier:: <tt>:boolean</tt>
+    #
+    # ==== Options:
+    # [<tt>:format => :true_false</tt>]
+    #   Format variation.
+    #   [<tt>:true_false</tt>] <tt>true/false</tt>
+    #   [<tt>:yes_no</tt>] <tt>yes/no</tt>
+    #   [<tt>:numeric</tt>] <tt>0/1</tt>
+    #   In addition supports all options of +Convert_string+.
+    #
+    # See also +Convert_yesno+.
+    class Convert_boolean < Convert_string
+      def initialize(options)
+        super
+        @format = options[:format] || :truefalse
+        raise ArgumentError, "unrecognized format #{@format}" unless [:truefalse, :yesno, :numeric].include?(@format)
+      end
+
+      def to_xml(flag)
+        return nil if flag.nil?
+        string = case @format
+        when :true_false then flag ? 'true' : 'false'
+        when :yes_no then flag ? 'yes' : 'no'
+        when :numeric then flag ? '0' : '1'
+        end
+        super(string)
+      end
+
+      def from_xml(string)
+        case string = super(string)
+        when nil then nil
+        when '1', 'true', 'yes' then true
+        when '0', 'false', 'no' then false
+        else
+          raise ArgumentError, "invalid value for boolean: #{string.inspect}"
+        end
+      end
+    end
+
+    # The same as +Convert_boolean+ but with the <tt>:yes_no</tt> default format.
+    #
+    # Specifier:: <tt>:yesno</tt>
+    class Convert_yesno < Convert_boolean
+      def initialize(options)
+        options[:format] ||= :yes_no
+        super
+      end
+    end
+
+    # An integer.
+    #
+    # Specifier:: <tt>:integer</tt>
+    # 
+    # ==== Options
+    # Accepts all options of +Convert_string+.
+    class Convert_integer < Convert_string
+      def initialize(options)
+        super
+      end
+
+      def to_xml(int)
+        super(int.to_s)
+      end
+
+      def from_xml(string)
+        (string = super(string)) && Integer(string)
+      end
+    end
+
+    # A decimal.
+    #
+    # Specifier:: <tt>:decimal</tt>
+    # Ruby type:: +BigDecimal+
+    # 
+    # ==== Options
+    # Accepts all options of +Convert_string+.
+    class Convert_decimal < Convert_string
+      def initialize(options)
+        super
+      end
+
+      def to_xml(int)
+        super(int && int.to_s('F'))
+      end
+
+      def from_xml(string)
+        (string = super(string)) && BigDecimal.new(string)
+      end
+    end
+
+    # A float.
+    #
+    # Specifier:: <tt>:float</tt>
+    #
+    # ==== Options
+    # [<tt>:precision</tt>] Floating point precision.
+    #
+    # In addition accepts all options of +Convert_string+.
+    class Convert_float < Convert_string
+      def initialize(options)
+        super
+        @precision = options[:precision]
+        @format = @precision ? "%f.#{@precision}" : '%f'
+      end
+
+      def to_xml(int)
+        super(int && sprintf(@format, int))
+      end
+
+      def from_xml(string)
+        (string = super(string)) && string.to_f
+      end
+    end
+
+    # An XSD datetime.
+    #
+    # Specifier:: <tt>:datetime</tt>
+    # Ruby type:: +Time+
+    # 
+    # ==== Options
+    # Accepts all options of +Convert_string+.
+    class Convert_datetime < Convert_string
+      def initialize(options)
+        super
+        @fraction_digits = options[:fraction_digits] || 0
+      end
+
+      def to_xml(time)
+        super(time && time.xmlschema(@fraction_digits))
+      end
+
+      def from_xml(string)
+        (string = super(string)) && Time.parse(string)
+      end
+    end
+
+    # An XSD whitespace-separated list.
+    #
+    # Specifier::             <tt>:list, :item_type => <em>simple type specifier</em></tt>
+    # Alternative specifier:: <tt>[<em>simple type specifier</em>]</tt>
+    # Ruby type::             +Array+ of <tt><em>simple type</em></tt>
+    #
+    # ==== Options
+    # All options will be passed to the underlying type converter.
+    class Convert_list
+      def initialize(options)
+        @item_type = options[:item_type] || :string
+        @item_converter = Converter.create!(@item_type, options)
+      end
+
+      def to_xml(items)
+        items && items.map {|x| @item_converter.to_xml(x) } * ' '
+      end
+
+      def from_xml(string)
+        string && string.split.map! {|x| @item_converter.from_xml(x)}
+      end
+    end
+  end
+end

data/lib/peanuts/mappings.rb

@@ -0,0 +1,154 @@
+require 'enumerator'
+require 'peanuts/backend'
+require 'peanuts/converters'
+
+module Peanuts
+  module Mappings
+    class Mapping
+      attr_reader :xmlname, :xmlns, :options
+
+      def initialize(xmlname, options)
+        @xmlname, @xmlns, @options = xmlname.to_s, options.delete(:xmlns), options
+      end
+    end
+
+    class Root < Mapping
+      def initialize(xmlname, options = {})
+        super
+      end
+    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 to_xml(nut, node)
+        setxml(node, get(nut))
+      end
+
+      def from_xml(nut, node)
+        set(nut, getxml(node))
+      end
+
+      private
+      def get(nut)
+        nut.send(@name)
+      end
+
+      def set(nut, value)
+        nut.send(@setter, value)
+      end
+
+      def toxml(value)
+        @converter ? @converter.to_xml(value) : value
+      end
+
+      def froxml(text)
+        @converter ? @converter.from_xml(text) : text
+      end
+
+      def each_element(node, &block)
+        node && backend.each_element(node, xmlname, xmlns, &block)
+        nil
+      end
+
+      def add_element(node, value = nil)
+        backend.add_element(node, xmlname, xmlns, value)
+      end
+
+      def value(node)
+        backend.value(node)
+      end
+
+      def parse(node)
+        type.parse_node(type.new, node)
+      end
+
+      def build(node, nut, dest_node)
+        nut && type.build_node(nut, dest_node)
+      end
+    end
+
+    class ElementValue < MemberMapping
+      private
+      def getxml(node)
+        each_element(node) {|e| return froxml(value(e)) }
+      end
+
+      def setxml(node, value)
+        add_element(node, toxml(value))
+      end
+    end
+
+    class Element < MemberMapping
+      private
+      def getxml(node)
+        each_element(node) {|e| return parse(e) }
+      end
+
+      def setxml(node, value)
+        build(node, value, add_element(node))
+      end
+    end
+
+    class Attribute < MemberMapping
+      private
+      def getxml(node)
+        froxml(backend.attribute(node, xmlname, xmlns))
+      end
+
+      def setxml(node, value)
+        backend.set_attribute(node, xmlname, xmlns, toxml(value))
+      end
+    end
+
+    class ElementValues < MemberMapping
+      private
+      def each_value(node)
+        each_element(node) {|x| yield froxml(value(x)) }
+      end
+
+      def getxml(node)
+        enum_for(:each_value, node).to_a
+      end
+
+      def setxml(node, values)
+        unless node
+          raise 'fuck'
+        end
+        values.each {|v| add_element(node, toxml(v)) } if values
+      end
+    end
+
+    class Elements < MemberMapping
+      private
+      def each_object(node)
+        each_element(node) {|e| yield parse(e) }
+      end
+
+      def getxml(node)
+        enum_for(:each_object, node)
+      end
+
+      def setxml(node, elements)
+        elements.each {|e| build(node, e, add_element(node)) } if elements
+      end
+    end
+  end
+end

data/lib/peanuts/nuts.rb

@@ -0,0 +1,219 @@
+require 'peanuts/mappings'
+
+module Peanuts #:nodoc:
+  # See also +ClassMethods+
+  def self.included(other) #:nodoc:
+    other.extend(ClassMethods)
+  end
+
+  # See also +PeaNuts+.
+  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 PeaNuts
+    #      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+] <tt>:xmlns => <tt> Element namespace
+    #
+    # === Example:
+    #    class Cat
+    #      include Peanuts
+    #      ...
+    #      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
+    #    element(name[, options]) { block } -> Mappings::Element
+    #
+    # Defines single-element mapping.
+    #
+    # === Arguments
+    # [+name+]    Accessor name
+    # [+type+]    Element type. <tt>:string</tt> assumed if omitted (see +Converter+).
+    # [+options+] <tt>:xmlname</tt>, <tt>:xmlns</tt>, converter options (see +Converter+).
+    # [+block+]   An anonymous class definition.
+    #
+    # === Example:
+    #    class Cat
+    #      include Peanuts
+    #      ...
+    #      element :name, :string, :whitespace => :collapse
+    #      element :cheeseburger, Cheeseburger, :xmlname => :cheezburger
+    #      ...
+    #    end
+    def element(name, type = :string, options = {}, &block)
+      type, options = prepare_args(type, options, &block)
+      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
+    #    elements(name[, options]) { block } -> Mappings::Element
+    #
+    # Defines multiple elements mapping.
+    #
+    # === Arguments
+    # [+name+]    Accessor name
+    # [+type+]    Element type. <tt>:string</tt> assumed if omitted (see +Converter+).
+    # [+options+] <tt>:xmlname</tt>, <tt>:xmlns</tt>, converter options (see +Converter+).
+    # [+block+]   An anonymous class definition.
+    #
+    # === Example:
+    #    class RichCat
+    #      include Peanuts
+    #      ...
+    #      elements :ration, :string, :whitespace => :collapse
+    #      elements :cheeseburgers, Cheeseburger, :xmlname => :cheezburger
+    #      ...
+    #    end
+    def elements(name, type = :string, options = {}, &block)
+      type, options = prepare_args(type, options, &block)
+      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. <tt>:string</tt> assumed if omitted (see +Converter+).
+    # [+options+] <tt>:xmlname</tt>, <tt>:xmlns</tt>, converter options (see +Converter+).
+    #
+    # === Example:
+    #    class Cat
+    #      include Peanuts
+    #      ...
+    #      element :name, :string, :whitespace => :collapse
+    #      element :cheeseburger, Cheeseburger, :xmlname => :cheezburger
+    #      ...
+    #    end
+    def attribute(name, type = :string, options = {})
+      define_accessor name
+      mappings << Attribute.new(name, type, prepare_options(options))
+    end
+
+    #    mappings -> Array
+    #
+    # Returns all mappings defined on a class.
+    def mappings
+      @mappings ||= []
+    end
+
+    def parse(source, options = {})
+      backend.parse(source, options) {|node| parse_node(new, node) }
+    end
+
+    def build(nut, result = :string, options = {})
+      options, result = result, :string if result.is_a?(Hash)
+      options[:xmlname] ||= root.xmlname
+      options[:xmlns_prefix] = namespaces.invert[options[:xmlns] ||= root.xmlns]
+      backend.build(result, options) {|node| build_node(nut, node) }
+    end
+
+    def build_node(nut, node) #:nodoc:
+      backend.add_namespaces(node, namespaces)
+      callem(:to_xml, nut, node)
+      node
+    end
+
+    def parse_node(nut, node) #:nodoc:
+      callem(:from_xml, nut, node)
+      nut
+    end
+
+    private
+    def prepare_args(type, options, &block)
+      if block_given?
+        options = type if type.is_a?(Hash)
+        type = Class.new
+        type.class_eval do
+          include Peanuts
+          class_eval(&block)
+        end
+      end
+      return type, prepare_options(options)
+    end
+
+    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.
+  #   [<tt>:string</tt>]   will return an XML string.
+  #   [<tt>:document</tt>] will return a backend specific document object.
+  #   [<tt>:object</tt>]   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 = {})
+    self.class.build(self, result, options)
+  end
+end

data/lib/peanuts/rexml.rb

@@ -0,0 +1,98 @@
+require 'rexml/document'
+require 'peanuts/backend'
+
+class Peanuts::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 source'
+    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(context, name, ns, &block)
+    ns = context.namespace unless ns
+    REXML::XPath.each(context, "ns:#{name}", 'ns' => ns, &block)
+  end
+
+  def value(node)
+    node.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/test/parsing_test.rb

@@ -0,0 +1,115 @@
+#$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'bigdecimal'
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require 'lib/peanuts'
+
+
+class Cheezburger
+  include Peanuts
+
+  attribute :weight, :float
+  attribute :price, :decimal
+end
+
+class Cat
+  include Peanuts
+
+  namespaces :lol => 'urn:x-lol', :kthnx => 'urn:x-lol:kthnx'
+
+  root 'kitteh', :xmlns => :lol
+
+  attribute :has_tail, :boolean, :xmlname => 'has-tail', :xmlns => 'urn:x-lol:kthnx'
+  attribute :ears, :integer
+
+  element :ration, [:string], :xmlname => :eats, :xmlns => :kthnx
+  element :name, :string, :xmlns => 'urn:x-lol:kthnx'
+  elements :paws, :string, :xmlname => :paw
+
+  element :friends, :xmlname => :pals do
+    elements :names, :string, :xmlname => :pal
+  end
+
+  element :cheezburger, Cheezburger
+  element :moar_cheezburgers do
+    elements :cheezburger, Cheezburger
+  end
+end
+
+class ParsingTest < Test::Unit::TestCase
+  def setup
+    @xml_fragment = <<-EOS
+        <kitteh xmlns='urn:x-lol' xmlns:kthnx='urn:x-lol:kthnx' ears=' 2 ' kthnx:has-tail=' yes  '>
+          <name xmlns='urn:x-lol:kthnx'>
+              Silly
+              Tom
+          </name>
+          <kthnx:eats>
+            tigers
+            lions
+          </kthnx:eats>
+          <pals>
+            <pal>Chrissy</pal>
+            <pal>Missy</pal>
+            <pal>Sissy</pal>
+          </pals>
+          <paw>  one</paw>
+          <paw> two </paw>
+          <paw>three</paw>
+          <paw>four</paw>
+          <cheezburger price='2.05' weight='14.5547' />
+          <moar_cheezburgers>
+            <cheezburger price='19' weight='685.940' />
+            <cheezburger price='7.40' weight='9356.7' />
+          </moar_cheezburgers>
+        </kitteh>
+    EOS
+    @cat = Cat.parse(@xml_fragment)
+  end
+
+  context "A cat" do
+    should 'be named Silly Tom' do
+      assert_equal 'Silly Tom', @cat.name
+    end
+
+    should 'eat tigers and lions' do
+      assert_equal %w(tigers lions), @cat.ration
+    end
+
+    should 'be a friend of Chrissy, Missy & Sissy' do
+      assert_equal ['Chrissy', 'Missy', 'Sissy'], @cat.friends.names
+    end
+
+    should 'have 2 ears' do
+      assert_equal 2, @cat.ears
+    end
+
+    should 'have a tail' do
+      assert @cat.has_tail
+    end
+
+    should 'have four paws' do
+      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
+
+    should 'weigh 14.5547 pounds' do
+      assert_equal 14.5547, @burger.weight
+    end
+
+    should 'cost $2.05' do
+      assert_equal BigDecimal('2.05'), @burger.price
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: peanuts
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Igor Gunko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-21 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.6
+    version: 
+description: "    Peanuts is an XML to Ruby and back again mapping library.\n"
+email: tekmon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- README.rdoc
+- MIT-LICENSE
+- Rakefile
+- lib/peanuts.rb
+- lib/omg-peanuts.rb
+- lib/peanuts/nuts.rb
+- lib/peanuts/mappings.rb
+- lib/peanuts/converters.rb
+- lib/peanuts/backend.rb
+- lib/peanuts/rexml.rb
+has_rdoc: true
+homepage: http://github.com/omg/peanuts
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Making XML <-> Ruby binding easy
+test_files: 
+- test/parsing_test.rb