omg-peanuts 2.0.0 → 2.0.1

data/README.rdoc

@@ -47,18 +47,21 @@ Please report via Github issue tracking.
 
       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
-      element :name, :string, :xmlns => 'urn:x-lol:kthnx'
-      elements :paws, :string, :xmlname => :paw
+      element :name, :xmlns => 'urn:x-lol:kthnx'
+      elements :paws, :xmlname => :paw
 
-      element :friends, :xmlname => :pals do # anonymous class definition follows within block
-        elements :names, :string, :xmlname => :friend, :xmlname => :pal
+      element :friends, :xmlname => :pals do
+        elements :names, :xmlname => :pal
       end
 
       element :cheezburger, Cheezburger
+      element :moar_cheezburgers do
+        elements :cheezburger, Cheezburger
+      end
     end
 
     xml_fragment = <<-EOS
@@ -83,7 +86,7 @@ Please report via Github issue tracking.
           <cheezburger weight='2' />
         </kitteh>
     EOS
-    cat = Cat.parse(xml_fragment)
+    cat = Cat.restore_from(xml_fragment)
 
     assert_equal 'Silly Tom', cat.name
     assert_equal %w(tigers lions), cat.ration
@@ -94,12 +97,13 @@ Please report via Github issue tracking.
     assert_kind_of Cheezburger, cat.cheezburger
     assert_equal 2, cat.cheezburger.weight
     ...
-    puts cat.build
+    puts cat.save_to(:string)
 
 
 === See also
-* http://github.com/omg/threadpool -- Thread pool implementation
+* http://github.com/omg/quack      -- ... here is my handle, here is my spout
 * http://github.com/omg/statelogic -- A simple state machine for ActiveRecord
+* http://github.com/omg/threadpool -- Thread pool implementation
 
 
 Copyright (c) 2009 Igor Gunko, released under the MIT license

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake'
 require 'rake/clean'
 require 'rake/gempackagetask'
 require 'rake/rdoctask'
-require 'rake/testtask'
+require 'spec/rake/spectask'
 
 Rake::GemPackageTask.new(Gem::Specification.load('peanuts.gemspec')) do |p|
   p.need_tar = true
@@ -21,6 +21,9 @@ Rake::RDocTask.new do |rdoc|
   rdoc.options << '--line-numbers' << '--inline-source'
 end
 
-Rake::TestTask.new do |t|
-  t.test_files = FileList['test/**/*.rb']
+desc 'Run specs'
+task :test => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*.rb']
 end

data/lib/peanuts/converters.rb

@@ -83,8 +83,8 @@ module Peanuts
       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 :true_false, :truefalse then flag ? 'true' : 'false'
+        when :yes_no, :yesno then flag ? 'yes' : 'no'
         when :numeric then flag ? '0' : '1'
         end
         super(string)

data/lib/peanuts/mapper.rb

@@ -4,30 +4,21 @@ module Peanuts
   class Mapper
     include Enumerable
 
-    attr_reader :root, :namespaces, :nscontext, :container
+    attr_reader :root, :namespaces, :ns_context, :default_ns
     attr_accessor :schema
 
-    def initialize
+    def initialize(ns_context = nil, default_ns = nil)
+      @ns_context, @default_ns = ns_context, default_ns
       @mappings, @footprints = [], {}
-      @namespaces = Hash.new do |h, k|
-        nscontext && nscontext[k] || raise(IndexError)
-      end
+      @namespaces = ns_context ? Hash.new {|h, k| ns_context[k] || raise(IndexError) } : {}
     end
 
     def root=(root)
       raise 'root already defined' if @root
-      raise 'root in nested scopes not supported' if nested?
+      # TODO 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
@@ -38,24 +29,17 @@ module Peanuts
       @mappings << (@footprints[fp] = mapping)
     end
 
-    def parse(nut, reader)
+    def restore(nut, reader)
       rdfp = ReaderFootprint.new(reader)
       reader.each do
         m = @footprints[rdfp]
-        m.from_xml(nut, reader) if m
+        m.restore(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
+    def save(nut, writer)
+      @root ? @root.save(writer) { _save(nut, writer) } : _save(nut, writer)
     end
 
     def clear(nut)
@@ -64,7 +48,7 @@ module Peanuts
 
     private
     def _save(nut, writer)
-      @mappings.each {|m| m.to_xml(nut, writer) }
+      @mappings.each {|m| m.save(nut, writer) } if nut
     end
 
     class Footprint

data/lib/peanuts/mappings.rb

@@ -25,7 +25,7 @@ module Peanuts
     class Root < Mapping
       node_type :element
 
-      def to_xml(writer, &block)
+      def save(writer, &block)
         writer.write(node_type, xmlname, xmlns, prefix, &block)
       end
     end
@@ -37,7 +37,7 @@ module Peanuts
         super(options.delete(:xmlname) || name, options)
         case type
         when Array
-          raise ArgumentError, "invalid value for type: #{type}" if type.length != 1
+          raise ArgumentError, "invalid value for type: #{type.inspect}" if type.length != 1
           options[:item_type] = type.first
           @converter = Converter.create!(:list, options)
         when Class
@@ -48,12 +48,12 @@ module Peanuts
         @name, @setter, @type = name.to_sym, :"#{name}=", type
       end
 
-      def to_xml(nut, node)
-        setxml(node, get(nut))
+      def save(nut, writer)
+        save_value(writer, get(nut))
       end
 
-      def from_xml(nut, node)
-        set(nut, getxml2(node, get(nut)))
+      def restore(nut, reader)
+        set(nut, restore_value(reader, get(nut)))
       end
 
       def clear(nut)
@@ -69,99 +69,110 @@ module Peanuts
         nut.send(@setter, value)
       end
 
-      def toxml(value)
+      def to_xml(value)
         @converter ? @converter.to_xml(value) : value
       end
 
-      def froxml(text)
+      def from_xml(text)
         @converter ? @converter.from_xml(text) : text
       end
 
-      def getxml2(node, acc)
-        getxml(node)
+      def write(writer, &block)
+        writer.write(node_type, xmlname, xmlns, prefix, &block)
       end
 
-      def parse(events)
+      def restore_object(events)
         type.send(:_restore, events)
       end
 
-      def build(nut, writer)
+      def save_object(nut, writer)
         type.send(:_save, nut, writer)
       end
     end
 
-    class ElementValue < MemberMapping
-      node_type :element
-
+    module SingleMapping
       private
-      def getxml(node)
-        froxml(node.value)
+      def restore_value(reader, acc)
+        read_value(reader)
       end
 
-      def setxml(writer, value)
-        writer.write(node_type, xmlname, xmlns, prefix) do |w|
-          w.value = toxml(value)
-        end
+      def save_value(writer, value)
+        write(writer) {|w| write_value(w, value) }
       end
     end
 
-    class Element < MemberMapping
-      node_type :element
-
-      private
-      def getxml(node)
-        parse(node)
+    module MultiMapping
+      def restore_value(reader, acc)
+        (acc || []) << read_value(reader)
       end
 
-      def setxml(writer, value)
-        writer.write(node_type, xmlname, xmlns, prefix) do |w|
-          build(value, w)
+      def save_value(writer, values)
+        for value in values
+          write(writer) {|w| write_value(w, value) }
         end
       end
     end
 
-    class Attribute < MemberMapping
-      node_type :attribute
+    module ValueMapping
+      private
+      def read_value(reader)
+        from_xml(reader.value)
+      end
 
-      def initialize(name, type, options)
-        super
-        raise ArgumentError, 'a namespaced attribute must have namespace prefix' if xmlns && !prefix
+      def write_value(writer, value)
+        writer.value = to_xml(value)
       end
+    end
 
+    module ObjectMapping
       private
-      def getxml(node)
-        froxml(node.value)
+      def read_value(reader)
+        restore_object(reader)
       end
 
-      def setxml(node, value)
-        backend.set_attribute(node, xmlname, xmlns, toxml(value))
+      def write_value(writer, value)
+        save_object(value, writer)
       end
     end
 
-    class ElementValues < MemberMapping
+    class ElementValue < MemberMapping
+      include SingleMapping
+      include ValueMapping
+
       node_type :element
+    end
 
-      private
-      def getxml2(node, acc)
-        (acc || []) << froxml(node.value)
-      end
+    class Element < MemberMapping
+      include SingleMapping
+      include ObjectMapping
+
+      node_type :element
+    end
 
-      def setxml(node, values)
-        values.each {|v| add_element(node, toxml(v)) } if values
+    class Attribute < MemberMapping
+      include SingleMapping
+      include ValueMapping
+
+      node_type :attribute
+
+      def initialize(name, type, options)
+        super
+        raise ArgumentError, 'a namespaced attribute must have namespace prefix' if xmlns && !prefix
       end
     end
 
-    class Elements < MemberMapping
+    class ElementValues < MemberMapping
+      include MultiMapping
+      include ValueMapping
+
       node_type :element
+    end
 
-      private
-      def getxml2(node, acc)
-        (acc || []) << parse(node)
-      end
+    class Elements < MemberMapping
+      include MultiMapping
+      include ObjectMapping
 
-      def setxml(node, elements)
-        elements.each {|e| build(node, e, add_element(node)) } if elements
-      end
+      node_type :element
     end
   end
 end

data/lib/peanuts/nuts.rb

@@ -1,27 +1,28 @@
 require 'peanuts/mappings'
 require 'peanuts/mapper'
-require 'peanuts/xml/reader'
 
 module Peanuts #:nodoc:
-  # See also +ClassMethods+
   def self.included(other) #:nodoc:
-    other.extend(ClassMethods)
+    init(other)
+  end
+
+  def self.init(cls, ns_context = nil, default_ns = nil, &block) #:nodoc:
+    cls.instance_eval do
+      include InstanceMethods
+      extend ClassMethods
+      @mapper = Mapper.new(ns_context, default_ns)
+      instance_eval(&block) if block_given?
+    end
   end
 
-  # See also +PeaNuts+.
+  # See also +InstanceMethods+.
   module ClassMethods
     include Mappings
 
-    def self.extended(other)
-      other.instance_eval do
-        @mappings = Mapper.new
-      end
-    end
-
-    #    mappings -> Mapper
+    #    mapper -> Mapper
     #
-    # Returns all mappings defined on a class.
-    attr_reader :mappings
+    # Returns the mapper for the class.
+    attr_reader :mapper
 
     #    namespaces(hash) -> Hash
     #    namespaces       -> Hash
@@ -36,8 +37,8 @@ module Peanuts #:nodoc:
     #      namespaces :lol => 'urn:lol', ...
     #      ...
     #    end
-    def namespaces(mappings = nil)
-      mappings ? @mappings.namespaces.update(mappings) : @mappings.namespaces
+    def namespaces(map = nil)
+      map ? mapper.namespaces.update(map) : mapper.namespaces
     end
 
     #    root(xmlname[, :xmlns => ...]) -> Mappings::Root
@@ -58,8 +59,8 @@ module Peanuts #:nodoc:
     #      ...
     #    end
     def root(xmlname = nil, options = {})
-      @mappings.root = Root.new(xmlname, prepare_options(options)) if xmlname
-      @mappings.root
+      mapper.root = Root.new(xmlname, prepare_options(options)) if xmlname
+      mapper.root
     end
 
     #    element(name, [type[, options]])   -> Mappings::Element or Mappings::ElementValue
@@ -81,10 +82,10 @@ module Peanuts #:nodoc:
     #      element :cheeseburger, Cheeseburger, :xmlname => :cheezburger
     #      ...
     #    end
-    def element(name, type = :string, options = {}, &block)
-      prepare_args(type, options, block) do |type, options|
+    def element(name, *args, &block)
+      prepare_args(args, block) do |type, options|
         define_accessor name
-        (@mappings << (type.is_a?(Class) ? Element : ElementValue).new(name, type, options)).last
+        (mapper << (type.is_a?(Class) ? Element : ElementValue).new(name, type, options)).last
       end
     end
 
@@ -107,10 +108,10 @@ module Peanuts #:nodoc:
     #      elements :cheeseburgers, Cheeseburger, :xmlname => :cheezburger
     #      ...
     #    end
-    def elements(name, type = :string, options = {}, &block)
-      prepare_args(type, options, block) do |type, options|
+    def elements(name, *args, &block)
+      prepare_args(args, block) do |type, options|
         define_accessor name
-        (@mappings << (type.is_a?(Class) ? Elements : ElementValues).new(name, type, options)).last
+        (mapper << (type.is_a?(Class) ? Elements : ElementValues).new(name, type, options)).last
       end
     end
 
@@ -131,14 +132,16 @@ module Peanuts #:nodoc:
     #      element :cheeseburger, Cheeseburger, :xmlname => :cheezburger
     #      ...
     #    end
-    def attribute(name, type = :string, options = {})
-      define_accessor name
-      @mappings << Attribute.new(name, type, prepare_options({:xmlns => nil}.merge(options)))
+    def attribute(name, *args)
+      prepare_args(args, nil, :xmlns => nil) do |type, options|
+        define_accessor name
+        mapper << Attribute.new(name, type, options)
+      end
     end
 
     def schema(schema = nil)
-      @mappings.schema = schema if schema
-      @mappings.schema
+      mapper.schema = schema if schema
+      mapper.schema
     end
 
     def restore(reader)
@@ -146,70 +149,49 @@ module Peanuts #:nodoc:
       e && _restore(e)
     end
 
-    def restore_from(source_or_type = nil, source = nil, options = {})
-      _source_or_dest(source_or_type, source) do |source_type, source|
+    def restore_from(*args)
+      _source_or_dest(*args) do |source_type, source, options|
         restore(XML::Reader.new(source, source_type, options))
       end
     end
 
     def save(nut, writer)
       _save(nut, writer)
+      writer.result
     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_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
+    def _source_or_dest(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      type, source = *args
+      type, source = :string, type unless type.is_a?(Symbol)
+      yield type, source, options
     end
 
     private
-    def _restore(events)
-      nut = new
-      @mappings.parse(nut, events)
+    def _restore(reader)
+      mapper.restore(nut = new, reader)
       nut
     end
 
-    def _save(nut, events)
-      @mappings.build(nut, events)
+    def _save(nut, writer)
+      mapper.save(nut, writer)
     end
 
-    def prepare_args(type, options, blk)
-      if blk
-        options = prepare_options(type) if type.is_a?(Hash)
-        type = Class.new
-        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
+    def prepare_args(args, blk, defopt = nil)
+      type, options = *args
+      type, options = (blk ? Class.new : :string), type if type.nil? || type.is_a?(Hash)
+      options ||= {}
+      options = defopt.merge(options) if defopt
+      options = prepare_options(options)
+      m = yield(type, options)
+      Peanuts.init(type, mapper.namespaces, m.xmlns, &blk) if blk
+      m
     end
 
     def prepare_options(options)
-      ns = options.fetch(:xmlns) {|k| options[k] = root && root.xmlns || @mappings.container && @mappings.container.xmlns }
+      ns = options.fetch(:xmlns) {|k| options[k] = root && root.xmlns || mapper.default_ns }
       if ns.is_a?(Symbol)
-        raise ArgumentError, "undefined prefix: #{ns}" unless options[:xmlns] = namespaces[ns]
+        raise ArgumentError, "undefined prefix: #{ns}" unless options[:xmlns] = mapper.namespaces[ns]
         options[:prefix] = ns
       end
       options
@@ -217,47 +199,50 @@ module Peanuts #:nodoc:
 
     def define_accessor(name)
       if method_defined?(name) || method_defined?("#{name}=")
-        raise ArgumentError, "#{name}: name already defined or reserved"
+        raise ArgumentError, "#{name.inspect}: name already defined or reserved"
       end
       attr_accessor name
     end
   end
 
-  def parse(source, options = {})
-    backend.parse(source, options) {|node| parse_node(node) }
-  end
+  # See also +ClassMethods+
+  module InstanceMethods
+    def parse(source, options = {})
+      backend.parse(source, options) {|node| parse_node(node) }
+    end
 
-  def save(writer)
-    self.class.save(self, writer)
-  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
-  #
-  # 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 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))
+    #    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.save_to(:string)
+    #    ...
+    #    doc = LibXML::XML::Document.new
+    #    cat.save_to(doc)
+    #    puts doc.to_s
+    def save_to(*args)
+      self.class._source_or_dest(*args) do |dest_type, dest, options|
+        save(XML::Writer.new(dest, dest_type, options))
+      end
     end
   end
 end

data/lib/peanuts/xml.rb

@@ -1 +1,78 @@
-require 'peanuts/xml/reader'
+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/libxml.rb

@@ -1,6 +1,6 @@
 require 'libxml'
 require 'forwardable'
-require 'peanuts/xml/reader'
+require 'peanuts/xml'
 
 module Peanuts
   module XML
@@ -14,7 +14,7 @@ module Peanuts
           when :io
             dest
           when :document
-            dest || LibXML::XML::Document.new
+            dest || ::LibXML::XML::Document.new
           else
             raise ArgumentError, "unrecognized destination type #{dest_type.inspect}"
           end
@@ -24,31 +24,31 @@ module Peanuts
           @dest
         end
 
-        attr_writer :value
-
-        def clear
-          @node_type = @local_name = @namespace_uri = @prefix = @value = nil
+        def value=(value)
+          case @node
+          when ::LibXML::XML::Attr
+            @node.value = value || ''
+          else
+            @node.content = value || ''
+          end
         end
 
         def write(node_type, local_name = nil, namespace_uri = nil, prefix = nil)
-          if @node_type
-            mknode
+          case node_type
+          when :element
+            @node = ::LibXML::XML::Node.new(local_name)
+            @parent << @node if @parent
+            @node.namespaces.namespace = mkns(@node, namespace_uri, prefix) if namespace_uri
+          when :attribute
+            @node = ::LibXML::XML::Attr.new(@parent, local_name, '', namespace_uri && mkns(@parent, namespace_uri, prefix))
           else
-            @node = nil
+            raise "unsupported node type #{node_type.inspect}"
           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
@@ -62,22 +62,11 @@ module Peanuts
         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
+        def mkns(node, namespace_uri, prefix)
+          prefix = prefix && prefix.to_s
+          ns = node && node.namespaces.find_by_href(namespace_uri)
+          ns = ::LibXML::XML::Namespace.new(node, prefix, namespace_uri) unless ns && ns.prefix == prefix
+          ns
         end
       end
 

data/spec/cat_spec.rb

@@ -0,0 +1,142 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'bigdecimal'
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require 'peanuts'
+
+
+class Cheezburger
+  include Peanuts
+
+  attribute :weight, :float
+  attribute :price, :decimal
+
+  def initialize(weight = nil, price = nil)
+    @weight, @price = weight, price
+  end
+
+  def eql?(other)
+    other && weight == other.weight && price == other.price
+  end
+
+  alias == eql?
+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 => :kthnx
+  attribute :ears, :integer
+
+  element :ration, [:string], :xmlname => :eats, :xmlns => :kthnx
+  element :name, :xmlns => 'urn:x-lol:kthnx'
+  elements :paws, :xmlname => :paw
+
+  element :friends, :xmlname => :pals do
+    elements :names, :xmlname => :pal
+  end
+
+  element :cheezburger, Cheezburger
+  element :moar_cheezburgers do
+    elements :cheezburger, Cheezburger
+  end
+end
+
+shared_examples_for 'my cat' do
+  it 'should be named Silly Tom' do
+    @cat.name.should eql 'Silly Tom'
+  end
+
+  it 'should eat tigers and lions' do
+    @cat.ration.should eql %w(tigers lions)
+  end
+
+  it 'should be a friend of Chrissy, Missy & Sissy' do
+    @cat.friends.names.should eql ['Chrissy', 'Missy', 'Sissy']
+  end
+
+  it 'should have 2 ears' do
+    @cat.ears.should eql 2
+  end
+
+  it 'should have a tail' do
+    @cat.has_tail.should be_true
+  end
+
+  it 'should have four paws' do
+    @cat.paws.should eql %w(one two three four)
+  end
+
+  it 'should has cheezburger' do
+    @cat.cheezburger.should be_kind_of Cheezburger
+  end
+
+  it 'should has 2 moar good cheezburgerz' do
+    @cat.moar_cheezburgers.cheezburger.should eql [
+      Cheezburger.new(685.940, BigDecimal('19')),
+      Cheezburger.new(9356.7, BigDecimal('7.40'))]
+  end
+end
+
+shared_examples_for 'my cheezburger' do
+  it 'should weigh 14.5547 pounds' do
+    @cheezburger.weight.should eql 14.5547
+  end
+
+  it 'should cost $2.05' do
+    @cheezburger.price.should eql BigDecimal('2.05')
+  end
+end
+
+shared_examples_for 'sample kitteh' do
+  before :all do
+    @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.restore_from(@xml_fragment)
+    @cheezburger = @cat.cheezburger
+  end
+
+  it_should_behave_like 'my cat', 'my cheezburger'
+end
+
+describe 'My cat' do
+  it_should_behave_like 'sample kitteh'
+end
+
+describe 'My cat saved and restored' do
+  it_should_behave_like 'sample kitteh'
+
+  before :all do
+    @cat = Cat.restore_from(@cat.save_to(:string))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: omg-peanuts
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - Igor Gunko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-24 00:00:00 -07:00
+date: 2009-09-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,14 +23,14 @@ dependencies:
         version: 1.1.3
     version: 
 - !ruby/object:Gem::Dependency 
-  name: thoughtbot-shoulda
+  name: rspec
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.0.6
+        version: 1.2.8
     version: 
 description: Peanuts is an XML to Ruby and back again mapping library.
 email: tekmon@gmail.com
@@ -52,7 +52,6 @@ files:
 - lib/peanuts/converters.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
@@ -84,4 +83,4 @@ signing_key:
 specification_version: 2
 summary: Making XML <-> Ruby binding easy
 test_files: 
-- test/parsing_test.rb
+- spec/cat_spec.rb

data/lib/peanuts/xml/reader.rb

@@ -1,78 +0,0 @@
-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/test/parsing_test.rb

@@ -1,115 +0,0 @@
-#$:.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 => :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.restore_from(@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