omg-peanuts 1.0 → 2.0.0

data/README.rdoc

@@ -1,4 +1,6 @@
 === Introduction
+*This is currently undergoing some rewrite. 2.x branch will introduce minor api incompatibilities.*
+
 Peanuts is an library that allows for bidirectional mapping between Ruby objects and XML.
 
 Released under the MIT license.
@@ -9,6 +11,10 @@ Released under the MIT license.
 - Pluggable backends to work with different XML APIs (REXML implemented so far).
 
 === Installation
+Stable branch 1.x available from Gemcutter
+  gem install peanuts --source http://gemcutter.org
+
+Development branch 2.x available from Github. buggy/broken/missing docs
   gem install omg-peanuts --source http://gems.github.com
 
 === Usage
@@ -96,9 +102,4 @@ Please report via Github issue tracking.
 * 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/lib/peanuts/mapper.rb

@@ -0,0 +1,110 @@
+require 'enumerator'
+
+module Peanuts
+  class Mapper
+    include Enumerable
+
+    attr_reader :root, :namespaces, :nscontext, :container
+    attr_accessor :schema
+
+    def initialize
+      @mappings, @footprints = [], {}
+      @namespaces = Hash.new do |h, k|
+        nscontext && nscontext[k] || raise(IndexError)
+      end
+    end
+
+    def root=(root)
+      raise 'root already defined' if @root
+      raise 'root in nested scopes not supported' if nested?
+      @root = root
+    end
+
+    def set_context(container, nscontext)
+      @container, @nscontext = container, nscontext
+    end
+
+    def nested?
+      !!container
+    end
+
+    def each(&block)
+      @mappings.each(&block)
+    end
+
+    def <<(mapping)
+      fp = MappingFootprint.new(mapping)
+      raise "mapping already defined for #{fp}" if @footprints.include?(fp)
+      @mappings << (@footprints[fp] = mapping)
+    end
+
+    def parse(nut, reader)
+      rdfp = ReaderFootprint.new(reader)
+      reader.each do
+        m = @footprints[rdfp]
+        m.from_xml(nut, reader) if m
+      end
+      nut
+    end
+
+    def build(nut, writer)
+      if @root
+        @root.to_xml(writer) do
+          _save(nut, writer)
+        end
+      else
+        _save(nut, writer)
+      end
+      writer.result
+    end
+
+    def clear(nut)
+      @mappings.each {|m| m.clear(nut) }
+    end
+
+    private
+    def _save(nut, writer)
+      @mappings.each {|m| m.to_xml(nut, writer) }
+    end
+
+    class Footprint
+      def ==(other)
+        self.equal?(other) || other && node_type == other.node_type && name == other.name && ns == other.ns
+      end
+
+      alias eql? ==
+
+      def hash
+        node_type.hash ^ name.hash ^ ns.hash
+      end
+
+      def to_s
+        "#{node_type}(#{name}, #{ns})"
+      end
+    end
+
+    class MappingFootprint < Footprint
+      extend Forwardable
+
+      def initialize(mapping)
+        @mapping = mapping
+      end
+
+      def_delegator :@mapping, :node_type
+      def_delegator :@mapping, :xmlname, :name
+      def_delegator :@mapping, :xmlns, :ns
+    end
+
+    class ReaderFootprint < Footprint
+      extend Forwardable
+
+      def initialize(reader)
+        @reader = reader
+      end
+
+      def_delegator :@reader, :node_type
+      def_delegator :@reader, :local_name, :name
+      def_delegator :@reader, :namespace_uri, :ns
+    end
+  end
+end

data/lib/peanuts/mappings.rb

@@ -1,26 +1,36 @@
-require 'enumerator'
-require 'peanuts/backend'
+require 'forwardable'
 require 'peanuts/converters'
 
 module Peanuts
-  module Mappings
-    class Mapping
-      attr_reader :xmlname, :xmlns, :options
+  class Mapping
+    attr_reader :xmlname, :xmlns, :prefix, :options
+
+    def initialize(xmlname, options)
+      @xmlname, @xmlns, @prefix, @options = xmlname.to_s, options.delete(:xmlns), options.delete(:prefix), options
+    end
+
+    def node_type
+      self.class.node_type
+    end
 
-      def initialize(xmlname, options)
-        @xmlname, @xmlns, @options = xmlname.to_s, options.delete(:xmlns), options
+    class << self
+      def node_type(node_type = nil)
+        @node_type = node_type if node_type
+        @node_type
       end
     end
+  end
 
+  module Mappings
     class Root < Mapping
-      def initialize(xmlname, options = {})
-        super
+      node_type :element
+
+      def to_xml(writer, &block)
+        writer.write(node_type, xmlname, xmlns, prefix, &block)
       end
     end
 
     class MemberMapping < Mapping
-      include XmlBackend
-
       attr_reader :name, :type, :converter
 
       def initialize(name, type, options)
@@ -43,7 +53,11 @@ module Peanuts
       end
 
       def from_xml(nut, node)
-        set(nut, getxml(node))
+        set(nut, getxml2(node, get(nut)))
+      end
+
+      def clear(nut)
+        set(nut, nil)
       end
 
       private
@@ -63,54 +77,60 @@ module Peanuts
         @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)
+      def getxml2(node, acc)
+        getxml(node)
       end
 
-      def value(node)
-        backend.value(node)
+      def parse(events)
+        type.send(:_restore, events)
       end
 
-      def parse(node)
-        type.parse_node(type.new, node)
-      end
-
-      def build(node, nut, dest_node)
-        nut && type.build_node(nut, dest_node)
+      def build(nut, writer)
+        type.send(:_save, nut, writer)
       end
     end
 
     class ElementValue < MemberMapping
+      node_type :element
+
       private
       def getxml(node)
-        each_element(node) {|e| return froxml(value(e)) }
+        froxml(node.value)
       end
 
-      def setxml(node, value)
-        add_element(node, toxml(value))
+      def setxml(writer, value)
+        writer.write(node_type, xmlname, xmlns, prefix) do |w|
+          w.value = toxml(value)
+        end
       end
     end
 
     class Element < MemberMapping
+      node_type :element
+
       private
       def getxml(node)
-        each_element(node) {|e| return parse(e) }
+        parse(node)
       end
 
-      def setxml(node, value)
-        build(node, value, add_element(node))
+      def setxml(writer, value)
+        writer.write(node_type, xmlname, xmlns, prefix) do |w|
+          build(value, w)
+        end
       end
     end
 
     class Attribute < MemberMapping
+      node_type :attribute
+
+      def initialize(name, type, options)
+        super
+        raise ArgumentError, 'a namespaced attribute must have namespace prefix' if xmlns && !prefix
+      end
+
       private
       def getxml(node)
-        froxml(backend.attribute(node, xmlname, xmlns))
+        froxml(node.value)
       end
 
       def setxml(node, value)
@@ -119,31 +139,24 @@ module Peanuts
     end
 
     class ElementValues < MemberMapping
-      private
-      def each_value(node)
-        each_element(node) {|x| yield froxml(value(x)) }
-      end
+      node_type :element
 
-      def getxml(node)
-        enum_for(:each_value, node).to_a
+      private
+      def getxml2(node, acc)
+        (acc || []) << froxml(node.value)
       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
+      node_type :element
 
-      def getxml(node)
-        enum_for(:each_object, node)
+      private
+      def getxml2(node, acc)
+        (acc || []) << parse(node)
       end
 
       def setxml(node, elements)

data/lib/peanuts/nuts.rb

@@ -1,4 +1,6 @@
 require 'peanuts/mappings'
+require 'peanuts/mapper'
+require 'peanuts/xml/reader'
 
 module Peanuts #:nodoc:
   # See also +ClassMethods+
@@ -8,9 +10,19 @@ module Peanuts #:nodoc:
 
   # See also +PeaNuts+.
   module ClassMethods
-    include XmlBackend
     include Mappings
 
+    def self.extended(other)
+      other.instance_eval do
+        @mappings = Mapper.new
+      end
+    end
+
+    #    mappings -> Mapper
+    #
+    # Returns all mappings defined on a class.
+    attr_reader :mappings
+
     #    namespaces(hash) -> Hash
     #    namespaces       -> Hash
     #
@@ -20,13 +32,12 @@ module Peanuts #:nodoc:
     # 
     # === Example:
     #    class Cat
-    #      include PeaNuts
+    #      include Peanuts
     #      namespaces :lol => 'urn:lol', ...
     #      ...
     #    end
     def namespaces(mappings = nil)
-      @namespaces ||= {}
-      mappings ? @namespaces.update(mappings) : @namespaces
+      mappings ? @mappings.namespaces.update(mappings) : @mappings.namespaces
     end
 
     #    root(xmlname[, :xmlns => ...]) -> Mappings::Root
@@ -47,8 +58,8 @@ module Peanuts #:nodoc:
     #      ...
     #    end
     def root(xmlname = nil, options = {})
-      @root = Root.new(xmlname, prepare_options(options)) if xmlname
-      @root ||= Root.new('root')
+      @mappings.root = Root.new(xmlname, prepare_options(options)) if xmlname
+      @mappings.root
     end
 
     #    element(name, [type[, options]])   -> Mappings::Element or Mappings::ElementValue
@@ -71,9 +82,10 @@ module Peanuts #:nodoc:
     #      ...
     #    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
+      prepare_args(type, options, block) do |type, options|
+        define_accessor name
+        (@mappings << (type.is_a?(Class) ? Element : ElementValue).new(name, type, options)).last
+      end
     end
 
     #    elements(name, [type[, options]])   -> Mappings::Element or Mappings::ElementValue
@@ -96,9 +108,10 @@ module Peanuts #:nodoc:
     #      ...
     #    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
+      prepare_args(type, options, block) do |type, options|
+        define_accessor name
+        (@mappings << (type.is_a?(Class) ? Elements : ElementValues).new(name, type, options)).last
+      end
     end
 
     #    attribute(name, [type[, options]]) -> Mappings::Attribute or Mappings::AttributeValue
@@ -120,18 +133,27 @@ module Peanuts #:nodoc:
     #    end
     def attribute(name, type = :string, options = {})
       define_accessor name
-      mappings << Attribute.new(name, type, prepare_options(options))
+      @mappings << Attribute.new(name, type, prepare_options({:xmlns => nil}.merge(options)))
     end
 
-    #    mappings -> Array
-    #
-    # Returns all mappings defined on a class.
-    def mappings
-      @mappings ||= []
+    def schema(schema = nil)
+      @mappings.schema = schema if schema
+      @mappings.schema
+    end
+
+    def restore(reader)
+      e = reader.find_element
+      e && _restore(e)
     end
 
-    def parse(source, options = {})
-      backend.parse(source, options) {|node| parse_node(new, node) }
+    def restore_from(source_or_type = nil, source = nil, options = {})
+      _source_or_dest(source_or_type, source) do |source_type, source|
+        restore(XML::Reader.new(source, source_type, options))
+      end
+    end
+
+    def save(nut, writer)
+      _save(nut, writer)
     end
 
     def build(nut, result = :string, options = {})
@@ -147,28 +169,48 @@ module Peanuts #:nodoc:
       node
     end
 
-    def parse_node(nut, node) #:nodoc:
-      callem(:from_xml, nut, node)
-      nut
+    def parse_events(nut, events) #:nodoc:
+      @mappings.parse(nut, events)
+    end
+
+    def _source_or_dest(a, b)
+      a, b = :string, a unless a.is_a?(Symbol)
+      yield a, b
     end
 
     private
-    def prepare_args(type, options, &block)
-      if block_given?
-        options = type if type.is_a?(Hash)
+    def _restore(events)
+      nut = new
+      @mappings.parse(nut, events)
+      nut
+    end
+
+    def _save(nut, events)
+      @mappings.build(nut, events)
+    end
+
+    def prepare_args(type, options, blk)
+      if blk
+        options = prepare_options(type) if type.is_a?(Hash)
         type = Class.new
-        type.class_eval do
-          include Peanuts
-          class_eval(&block)
+        yield(type, options).tap do |m|
+          type.instance_eval do
+            include Peanuts
+            mappings.set_context(m, namespaces)
+            instance_eval(&blk)
+          end
         end
+      else
+        options = prepare_options(options)
+        yield type, options
       end
-      return type, prepare_options(options)
     end
 
     def prepare_options(options)
-      ns = options[:xmlns]
+      ns = options.fetch(:xmlns) {|k| options[k] = root && root.xmlns || @mappings.container && @mappings.container.xmlns }
       if ns.is_a?(Symbol)
         raise ArgumentError, "undefined prefix: #{ns}" unless options[:xmlns] = namespaces[ns]
+        options[:prefix] = ns
       end
       options
     end
@@ -179,16 +221,16 @@ module Peanuts #:nodoc:
       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
 
+  def save(writer)
+    self.class.save(self, writer)
+  end
+
   #    build([options])              -> root element or string
   #    build([options])              -> root element or string
   #    build(destination[, options]) -> destination
@@ -213,7 +255,9 @@ module Peanuts #:nodoc:
   #    doc = REXML::Document.new
   #    cat.build(doc)
   #    puts doc.to_s
-  def build(result = :string, options = {})
-    self.class.build(self, result, options)
+  def save_to(dest_or_type = :string, dest = nil, options = {})
+    self.class._source_or_dest(dest_or_type, dest) do |dest_type, dest|
+      save(XML::Writer.new(dest, dest_type, options))
+    end
   end
 end

data/lib/peanuts/xml/libxml.rb

@@ -0,0 +1,231 @@
+require 'libxml'
+require 'forwardable'
+require 'peanuts/xml/reader'
+
+module Peanuts
+  module XML
+    module LibXML
+      class Writer < Peanuts::XML::Writer
+        def initialize(dest, dest_type, options = {})
+          @dest_type = dest_type
+          @dest = case dest_type
+          when :string
+            dest || ''
+          when :io
+            dest
+          when :document
+            dest || LibXML::XML::Document.new
+          else
+            raise ArgumentError, "unrecognized destination type #{dest_type.inspect}"
+          end
+        end
+
+        def result
+          @dest
+        end
+
+        attr_writer :value
+
+        def clear
+          @node_type = @local_name = @namespace_uri = @prefix = @value = nil
+        end
+
+        def write(node_type, local_name = nil, namespace_uri = nil, prefix = nil)
+          if @node_type
+            mknode
+          else
+            @node = nil
+          end
+
+          @node_type = node_type
+          @local_name, @namespace_uri, @prefix = local_name, namespace_uri, prefix && prefix.to_s
+
+          exparent, @parent = @parent, @node
+
+          yield self
+
+          if @node_type
+            mknode
+          end
+          @node = nil
+
+          if exparent.nil?
+            case @dest_type
+            when :string, :io
+              @dest << @parent.to_s
+            when :document
+              @dest.root = @parent
+            end
+          end
+
+          @parent = exparent
+        end
+
+        private
+        def mknode
+          @node = case @node_type
+          when :element
+            n = ::LibXML::XML::Node.new(@local_name, @value)
+            if @namespace_uri
+              ns = @parent && @parent.namespaces.find_by_href(@namespace_uri)
+              n.namespaces.namespace = ns && ns.prefix == @prefix ? ns : ::LibXML::XML::Namespace.new(n, @prefix, @namespace_uri)
+            end
+            @parent << n if @parent
+            n
+          when :attribute
+            ::LibXML::XML::Attr.new(@parent, @local_name, @value, @namespace_uri)
+          else
+            raise "unsupported node type #{@node_type.inspect}"
+          end
+          clear
+        end
+      end
+
+      class Reader < Peanuts::XML::Reader
+        extend Forwardable
+
+        SCHEMAS = {:xml_schema => :schema, :relax_ng => :relax_ng}
+
+        RD = ::LibXML::XML::Reader
+
+        NODE_TYPES = [
+          nil,
+          :element,
+          :attribute,
+          :text,
+          :cdata,
+          :entity_reference,
+          :entity,
+          :processing_instruction,
+          :comment,
+          :document,
+          :document_type,
+          :document_fragment,
+          :notation,
+          :whitespace,
+          :significant_whitespace,
+          :end_element,
+          :end_entity,
+          :xml_declaration
+        ].freeze
+
+        DEFAULT_PARSER_OPTIONS = {
+          :libxml_encoding => ::LibXML::XML::Encoding::UTF_8,
+          :libxml_options => ::LibXML::XML::Parser::Options::NOENT
+        }
+
+        def initialize(source, source_type, options = {})
+          super()
+          options = options.dup
+          @schema = options.delete(:schema)
+          @reader = case source_type
+          when :string
+            RD.string(source, parser_opt(options))
+          when :io
+            RD.io(source, parser_opt(options))
+          when :uri
+            RD.file(source, parser_opt(options))
+          when :document
+            RD.document(source)
+          else
+            raise ArgumentError, "unrecognized source type #{source_type}"
+          end
+          @reader.send("#{SCHEMAS[schema.type]}_validate", schema.schema) if @schema
+        end
+
+        def close
+          @reader.close
+        end
+
+        def_delegators :@reader, :name, :local_name, :namespace_uri, :depth
+
+        def node_type
+          NODE_TYPES[@reader.node_type]
+        end
+
+        def value
+          case @reader.node_type
+          when RD::TYPE_ELEMENT
+            @reader.read_string
+          else
+            @reader.has_value? ? @reader.value : nil
+          end
+        end
+
+        def each
+          depth = self.depth
+          if read
+            while self.depth > depth
+              yield self
+              break unless next_sibling
+            end
+          end
+        end
+
+        def find_element
+          until @reader.node_type == RD::TYPE_ELEMENT
+            return nil unless read
+          end
+          self
+        end
+
+        private
+        def parser_opt(options)
+          h = DEFAULT_PARSER_OPTIONS.merge(options)
+          h.merge(h.from_namespace!(:libxml))
+        end
+
+        def read
+          case @reader.node_type
+          when RD::TYPE_ATTRIBUTE
+            @reader.move_to_next_attribute > 0 || @reader.read
+          else
+            @reader.move_to_first_attribute > 0 || @reader.read
+          end
+        end
+
+        def next_sibling
+          case @reader.node_type
+          when RD::TYPE_ATTRIBUTE
+            @reader.move_to_next_attribute > 0 || @reader.read
+          else
+            @reader.next > 0
+          end
+        end
+      end
+
+      def self.schema(schema_type, source, source_type = :string)
+        schema_class = case schema_type
+        when :xml_schema
+          ::LibXML::XML::Schema
+        when :relax_ng
+          ::LibXML::XML::RelaxNG
+        else
+          raise ArgumentError, "unrecognized schema type #{schema_type}"
+        end
+        schema = case source_type
+        when :string
+          schema_class.string(source)
+        when :io
+          schema_class.string(source.read)
+        when :uri
+          schema_class.new(source)
+        when :document
+          schema_class.document(source)
+        else
+          raise ArgumentError, "unrecognized source type #{source_type}"
+        end
+
+        Schema.new(schema_type, schema)
+      end
+
+      class Schema
+        attr_reader :type, :handle
+
+        def initialize(type, handle)
+          @type, @handle = type, handle
+        end
+      end
+    end
+  end
+end

data/lib/peanuts/xml/reader.rb

@@ -0,0 +1,78 @@
+require 'enumerator'
+
+class Hash
+  def from_namespace(ns)
+    rx = /^#{Regexp.quote(ns.to_s)}_(.*)$/
+    inject({}) do |a, p|
+      a[$1.to_sym] = p[1] if p[0].to_s =~ rx
+      a
+    end
+  end
+
+  def from_namespace!(ns)
+    h = from_namespace(ns)
+    h.each_key {|k| delete(:"#{ns}_#{k}") }
+    h
+  end
+end
+
+module Peanuts
+  module XML
+    autoload :LibXML, 'peanuts/xml/libxml'
+
+    def self.default
+      @@default ||= LibXML
+    end
+
+    def self.schema(schema_type, source, source_type = :string)
+      default.schema(schema_type, source, source_type)
+    end
+ 
+    def self.method_missing(method, *args, &block)
+      case method.to_s
+      when /^(.*)_schema_from_(.*)$/
+        XML.schema($1.to_sym, args.first, $2.to_sym)
+      else
+        super
+      end
+    end
+
+    class Reader
+      include Enumerable
+
+      def self.new(*args, &block)
+        cls = self == Reader ? XML.default::Reader : self
+        obj = cls.allocate
+        obj.send(:initialize, *args, &block)
+        obj
+      end
+
+      def self.method_missing(method, *args, &block)
+        case method.to_s
+        when /^from_(.*)$/
+          new(args.first, $1.to_sym, &block)
+        else
+          super
+        end
+      end
+    end
+
+    class Writer
+      def self.new(*args, &block)
+        cls = self == Writer ? XML.default::Writer : self
+        obj = cls.allocate
+        obj.send(:initialize, *args, &block)
+        obj
+      end
+
+      def self.method_missing(method, *args, &block)
+        case method.to_s
+        when /^from_(.*)$/
+          new(args.first, $1.to_sym, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/peanuts/xml.rb

@@ -0,0 +1 @@
+require 'peanuts/xml/reader'

data/lib/peanuts.rb

@@ -1 +1,2 @@
 require 'peanuts/nuts'
+require 'peanuts/xml'

data/test/parsing_test.rb

@@ -21,7 +21,7 @@ class Cat
 
   root 'kitteh', :xmlns => :lol
 
-  attribute :has_tail, :boolean, :xmlname => 'has-tail', :xmlns => 'urn:x-lol:kthnx'
+  attribute :has_tail, :boolean, :xmlname => 'has-tail', :xmlns => :kthnx
   attribute :ears, :integer
 
   element :ration, [:string], :xmlname => :eats, :xmlns => :kthnx
@@ -66,7 +66,7 @@ class ParsingTest < Test::Unit::TestCase
           </moar_cheezburgers>
         </kitteh>
     EOS
-    @cat = Cat.parse(@xml_fragment)
+    @cat = Cat.restore_from(@xml_fragment)
   end
 
   context "A cat" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: omg-peanuts
 version: !ruby/object:Gem::Version 
-  version: "1.0"
+  version: 2.0.0
 platform: ruby
 authors: 
 - Igor Gunko
@@ -9,9 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-21 00:00:00 -07:00
+date: 2009-09-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.3
+    version: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
   type: :development
@@ -40,10 +50,13 @@ files:
 - lib/peanuts/nuts.rb
 - lib/peanuts/mappings.rb
 - lib/peanuts/converters.rb
-- lib/peanuts/backend.rb
-- lib/peanuts/rexml.rb
+- lib/peanuts/mapper.rb
+- lib/peanuts/xml.rb
+- lib/peanuts/xml/reader.rb
+- lib/peanuts/xml/libxml.rb
 has_rdoc: true
 homepage: http://github.com/omg/peanuts
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -66,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Making XML <-> Ruby binding easy

data/lib/peanuts/backend.rb

@@ -1,38 +0,0 @@
-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/rexml.rb

@@ -1,98 +0,0 @@
-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