peanuts 1.0 → 2.0.7

data/spec/cat_spec.rb

@@ -0,0 +1,151 @@
+$:.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 Paws
+  include Peanuts
+
+  elements :paws, :name => :paw, :ns => 'urn:x-lol'
+end
+
+class Cat
+  include Peanuts
+
+  namespaces :lol => 'urn:x-lol', :kthnx => 'urn:x-lol:kthnx'
+
+  root 'kitteh', :ns => 'urn:x-lol'
+
+  attribute :has_tail?, :boolean, :name => 'has-tail', :ns => :kthnx
+  attribute :ears, :integer
+
+  element :ration, [:string], :name => :eats, :ns => :kthnx
+  element :name, :ns => 'urn:x-lol:kthnx'
+  
+  shallow :paws, Paws
+
+  shallow :pals, :ns => :kthnx do
+    elements :friends, :name => :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 == 'Silly Tom'
+  end
+
+  it 'should eat tigers and lions' do
+    @cat.ration.should == %w(tigers lions)
+  end
+
+  it 'should be a friend of Chrissy, Missy & Sissy' do
+    @cat.friends.should == ['Chrissy', 'Missy', 'Sissy']
+  end
+
+  it 'should have 2 ears' do
+    @cat.ears.should == 2
+  end
+
+  it 'should have a tail' do
+    @cat.should have_tail
+  end
+
+  it 'should have four paws' do
+    @cat.paws.should == %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 == [
+      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 == 14.5547
+  end
+
+  it 'should cost $2.05' do
+    @cheezburger.price.should == 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>
+          <kthnx:pals>
+            <pal>Chrissy</pal>
+            <pal>Missy</pal>
+            <pal>Sissy</pal>
+          </kthnx:pals>
+          <paws>
+            <paw>  one</paw>
+            <paw> two </paw>
+            <paw>three</paw>
+            <paw>four</paw>
+          </paws>
+          <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.from_xml(@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'
+
+  context 'saved and restored' do
+    it_should_behave_like 'sample kitteh'
+
+    before :all do
+      @cat = Cat.from_xml(@cat.to_xml)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: peanuts
 version: !ruby/object:Gem::Version 
-  version: "1.0"
+  version: 2.0.7
 platform: ruby
 authors: 
 - Igor Gunko
@@ -9,18 +9,28 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-21 00:00:00 +03:00
+date: 2009-09-30 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: thoughtbot-shoulda
+  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: 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.\n"
 email: tekmon@gmail.com
@@ -37,11 +47,12 @@ files:
 - Rakefile
 - lib/peanuts.rb
 - lib/omg-peanuts.rb
-- lib/peanuts/nuts.rb
+- lib/peanuts/mappable.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/libxml.rb
 has_rdoc: true
 homepage: http://github.com/omg/peanuts
 licenses: []
@@ -73,4 +84,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/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/nuts.rb

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

@@ -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

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 => '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