dm-serializer 0.9.8 → 0.9.9

data/History.txt

@@ -1,3 +1,17 @@
+=== 0.9.9 / 2009-01-04
+
+* 1 major enhancement:
+
+  * Uses LibXML or Nokogiri if available for a ~6x improvement in
+    serialization performance.
+
+* 4 minor enhancements:
+
+  * Added :element_name and :collection_element_name options to #to_xml
+  * Removed #xml_element_name override in #to_xml
+  * Removed :read_only_attributes option from #to_json
+  * Removed #serialized_properties override in #to_json
+
 === 0.9.8 / 2008-12-07
 
 * 2 minor enhancements:

data/Manifest.txt

@@ -1,13 +1,23 @@
 History.txt
 LICENSE
 Manifest.txt
-README.txt
+README.textile
 Rakefile
 TODO
 autotest/discover.rb
 autotest/dmserializer_rspec.rb
+benchmarks/to_xml.rb
 lib/dm-serializer.rb
+lib/dm-serializer/common.rb
+lib/dm-serializer/to_csv.rb
+lib/dm-serializer/to_json.rb
+lib/dm-serializer/to_xml.rb
+lib/dm-serializer/to_yaml.rb
 lib/dm-serializer/version.rb
+lib/dm-serializer/xml_serializers.rb
+lib/dm-serializer/xml_serializers/libxml.rb
+lib/dm-serializer/xml_serializers/nokogiri.rb
+lib/dm-serializer/xml_serializers/rexml.rb
 spec/fixtures/cow.rb
 spec/fixtures/planet.rb
 spec/fixtures/quan_tum_cat.rb

data/README.textile

@@ -0,0 +1,61 @@
+h1. dm-serializer
+
+h2. Overview
+
+dm-serializer allows DataMapper models and collections to be serialized to a variety of formats (currently JSON, XML, YAML and CSV).
+
+h2. How it works
+
+One method is added to each model/collection for each serialization type - @to_json@, @to_xml@, @to_yaml@, and @to_csv@. With the exception of @to_csv@, all of these methods share the same interface. @to_json@ will be used for examples. Any method specific behaviour is documented in its own section below.
+
+<pre><code>require 'dm-serializer'
+
+class Cow
+  include DataMapper::Resource
+
+  property :id,        Integer, :key => true
+  property :name,      String
+
+  def description
+    "A Cow"
+  end
+end
+
+cow = Cow.create(
+  :id    => 1,
+  :name  => "Berta"
+)
+
+cow.to_json                      # => { "id": 1, "name": "Berta" }
+cow.to_json(:only    => [:name]) # => { "name": "Berta" } 
+cow.to_json(:exclude => [:id])   # => { "name": "Berta" }
+cow.to_json(:methods => [:desc]) # => { "id": 1, "name": "Berta", "desc": "A Cow" }</code></pre>
+
+You can include associations by passing the association accessor the @:methods@ option.
+
+If you want to only load a particular serialization method, that's cool, you can do that:
+
+<pre><code>require 'dm-serializer/to_json'</code></pre>
+
+h2. to_xml
+
+@to_xml@ supports some extra options to allow you to override the element names
+
+<pre><code>cow.to_xml(            :element_name => 'bovine') # => <bovine><id>1</id><name>Berta</name></bovine>
+cows.to_xml(:collection_element_name => 'kine')   # => <kine><bovine><id>1</id><name>Berta</name></bovine></kine></code></pre>
+
+If you would like a nice speed boost (~5x), require @libxml@ or @nokogiri@ before @dm-serializer@, and that library will be used rather than REXML.
+
+h2. to_csv
+
+@to_csv@ currently doesn't support any options yet. It will in the future. It will not support serializing child associations.
+
+h2. Arrays, Hashes, and other core classes
+
+@dm-serializer@ only adds serialization methods to DataMapper objects and collections, however some libraries used (json, yaml) add methods to core classes, such as @Array@. Note that passing @dm-serializer@ options (such as @:only@) to these methods is *not supported*.
+
+<pre><code>Cow.all.to_a.to_yaml(:only => 'name') # WILL NOT WORK</code></pre>
+
+h2. Beware
+
+If you go spelunking through the code you will find other undocumented options. Use at your own risk, I plan on removing or changing these in the near future.

data/Rakefile

@@ -14,7 +14,7 @@ GEM_NAME = 'dm-serializer'
 GEM_VERSION = DataMapper::Serializer::VERSION
 GEM_DEPENDENCIES = [['dm-core', "~>#{GEM_VERSION}"]]
 GEM_CLEAN = %w[ log pkg coverage ]
-GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO History.txt ] }
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.textile LICENSE TODO History.txt ] }
 
 PROJECT_NAME = 'datamapper'
 PROJECT_URL  = "http://github.com/sam/dm-more/tree/master/#{GEM_NAME}"

data/benchmarks/to_xml.rb

@@ -0,0 +1,89 @@
+require "rubygems"
+require 'pathname'
+
+gem 'dm-core', '~>0.9.9'
+require 'dm-core'
+
+spec_dir_path = Pathname(__FILE__).dirname.expand_path
+$LOAD_PATH.unshift(spec_dir_path.parent + 'lib/')
+require 'dm-serializer'
+
+def load_driver(name, default_uri)
+  begin
+    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
+    DataMapper::Repository.adapters[:alternate] = DataMapper::Repository.adapters[name]
+    true
+  rescue LoadError => e
+    warn "Could not load do_#{name}: #{e}"
+    false
+  end
+end
+
+HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
+
+class Cow
+  include DataMapper::Resource
+
+  property :id,        Integer, :key => true
+  property :composite, Integer, :key => true
+  property :name,      String
+  property :breed,     String
+
+  has n, :baby_cows, :class_name => 'Cow'
+  belongs_to :mother_cow, :class_name => 'Cow'
+end
+
+require "benchwarmer"
+
+TIMES = 2000
+DataMapper.auto_migrate!
+cow = Cow.create(
+  :id        => 89,
+  :composite => 34,
+  :name      => 'Berta',
+  :breed     => 'Guernsey'
+)
+all_cows = Cow.all
+
+puts "REXML"
+Benchmark.warmer(TIMES) do
+  group("Serialization:") do
+    report "Single Resource" do
+      cow.to_xml
+    end
+    report "Collection" do
+      all_cows.to_xml
+    end
+  end
+end
+
+require 'nokogiri'
+load 'dm-serializer/xml_serializers.rb'
+
+puts "Nokogiri"
+Benchmark.warmer(TIMES) do
+  group("Serialization:") do
+    report "Single Resource" do
+      cow.to_xml
+    end
+    report "Collection" do
+      all_cows.to_xml
+    end
+  end
+end
+
+require 'libxml'
+load 'dm-serializer/xml_serializers.rb'
+
+puts "LibXML"
+Benchmark.warmer(TIMES) do
+  group("Serialization:") do
+    report "Single Resource" do
+      cow.to_xml
+    end
+    report "Collection" do
+      all_cows.to_xml
+    end
+  end
+end

data/lib/dm-serializer/common.rb

@@ -0,0 +1,24 @@
+module DataMapper
+  module Serialize
+    # Returns propreties to serialize based on :only or :exclude arrays, if provided
+    # :only takes precendence over :exclude
+    #
+    # @return <Array> properties that need to be serialized
+    def properties_to_serialize(options)
+      only_properties     = Array(options[:only])
+      excluded_properties = Array(options[:exclude])
+
+      self.class.properties(repository.name).reject do |p|
+        if only_properties.include? p.name
+          false
+        else
+          excluded_properties.include?(p.name) || !(only_properties.empty? || only_properties.include?(p.name))
+        end
+      end
+    end
+  end
+
+  module Resource
+    include Serialize
+  end
+end

data/lib/dm-serializer/to_csv.rb

@@ -0,0 +1,35 @@
+require 'dm-serializer/common'
+
+begin
+  gem('fastercsv')
+  require 'faster_csv'
+rescue LoadError
+  nil
+end
+
+module DataMapper
+  module Serialize
+    # Serialize a Resource to comma-separated values (CSV).
+    #
+    # @return <String> a CSV representation of the Resource
+    def to_csv(writer = '')
+      FasterCSV.generate(writer) do |csv|
+        row = []
+        self.class.properties(repository.name).each do |property|
+         row << send(property.name).to_s
+        end
+        csv << row
+      end
+    end
+  end
+
+  class Collection
+    def to_csv
+      result = ""
+      each do |item|
+        result << item.to_csv + "\n"
+      end
+      result
+    end
+  end
+end

data/lib/dm-serializer/to_json.rb

@@ -0,0 +1,73 @@
+require 'dm-serializer/common'
+
+begin
+  gem('json')
+  require 'json/ext'
+rescue LoadError
+  gem('json_pure')
+  require 'json/pure'
+end
+
+module DataMapper
+  module Serialize
+    # Serialize a Resource to JavaScript Object Notation (JSON; RFC 4627)
+    #
+    # @return <String> a JSON representation of the Resource
+    def to_json(*args)
+      options = args.first || {}
+      result = '{ '
+      fields = []
+
+      propset = properties_to_serialize(options)
+
+      fields += propset.map do |property|
+        "#{property.name.to_json}: #{send(property.getter).to_json}"
+      end
+
+      # add methods
+      (options[:methods] || []).each do |meth|
+        if self.respond_to?(meth)
+          fields << "#{meth.to_json}: #{send(meth).to_json}"
+        end
+      end
+
+      # Note: if you want to include a whole other model via relation, use :methods
+      # comments.to_json(:relationships=>{:user=>{:include=>[:first_name],:methods=>[:age]}})
+      # add relationships
+      # TODO: This needs tests and also needs to be ported to #to_xml and #to_yaml
+      (options[:relationships] || {}).each do |rel,opts|
+        if self.respond_to?(rel)
+          fields << "#{rel.to_json}: #{send(rel).to_json(opts)}"
+        end
+      end
+
+      result << fields.join(', ')
+      result << ' }'
+      result
+    end
+  end
+
+  module Associations
+    # the json gem adds Object#to_json, which breaks the DM proxies, since it
+    # happens *after* the proxy has been blank slated. This code removes the added
+    # method, so it is delegated correctly to the Collection
+    proxies = []
+
+    proxies << ManyToMany::Proxy if defined?(ManyToMany::Proxy)
+    proxies << OneToMany::Proxy  if defined?(OneToMany::Proxy)
+    proxies << ManyToOne::Proxy  if defined?(ManyToOne::Proxy)
+
+    proxies.each do |proxy|
+      if proxy.public_instance_methods.any? { |m| m.to_sym == :to_json }
+        proxy.send(:undef_method, :to_json)
+      end
+    end
+  end
+
+  class Collection
+    def to_json(*args)
+      opts = args.first || {}
+      "[" << map {|e| e.to_json(opts)}.join(",") << "]"
+    end
+  end
+end

data/lib/dm-serializer/to_xml.rb

@@ -0,0 +1,61 @@
+require 'dm-serializer/common'
+require 'dm-serializer/xml_serializers'
+require 'rexml/document'
+
+module DataMapper
+  module Serialize
+    # Serialize a Resource to XML
+    #
+    # @return <REXML::Document> an XML representation of this Resource
+    def to_xml(opts = {})
+      to_xml_document(opts).to_s
+    end
+
+    protected
+    # This method requires certain methods to be implemented in the individual
+    # serializer library subclasses:
+    # new_document
+    # root_node
+    # add_property_node
+    # add_node
+    def to_xml_document(opts={}, doc = nil)
+      xml = XMLSerializers::SERIALIZER
+      doc ||= xml.new_document
+      default_xml_element_name = lambda { Extlib::Inflection.underscore(self.class.name).tr("/", "-") }
+      root = xml.root_node(doc, opts[:element_name] || default_xml_element_name[])
+      properties_to_serialize(opts).each do |property|
+        value = send(property.name)
+        attrs = (property.type == String) ? {} : {'type' => property.type.to_s.downcase}
+        xml.add_node(root, property.name.to_s, value, attrs)
+      end
+
+      (opts[:methods] || []).each do |meth|
+        if self.respond_to?(meth)
+          xml_name = meth.to_s.gsub(/[^a-z0-9_]/, '')
+          value = send(meth)
+          xml.add_node(root, xml_name, value.to_s) unless value.nil?
+        end
+      end
+      doc
+    end
+  end
+
+  class Collection
+    def to_xml(opts = {})
+      to_xml_document(opts).to_s
+    end
+
+    protected
+
+    def to_xml_document(opts = {})
+      xml = DataMapper::Serialize::XMLSerializers::SERIALIZER
+      doc = xml.new_document
+      default_collection_element_name = lambda {Extlib::Inflection.pluralize(Extlib::Inflection.underscore(self.model.to_s)).tr("/", "-")}
+      root = xml.root_node(doc, opts[:collection_element_name] || default_collection_element_name[], {'type' => 'array'})
+      self.each do |item|
+        item.send(:to_xml_document, opts, doc)
+      end
+      doc
+    end
+  end
+end

data/lib/dm-serializer/to_yaml.rb

@@ -0,0 +1,48 @@
+require 'dm-serializer/common'
+
+module DataMapper
+  module Serialize
+    # Serialize a Resource to YAML
+    #
+    # @return <YAML> a YAML representation of this Resource
+    def to_yaml(opts_or_emitter = {})
+      if opts_or_emitter.is_a?(YAML::Syck::Emitter)
+        emitter = opts_or_emitter
+        opts = {}
+      else
+        emitter = {}
+        opts = opts_or_emitter
+      end
+
+      YAML::quick_emit(object_id,emitter) do |out|
+        out.map(nil,to_yaml_style) do |map|
+          propset = properties_to_serialize(opts)
+          propset.each do |property|
+            value = send(property.name.to_sym)
+            map.add(property.name, value.is_a?(Class) ? value.to_s : value)
+          end
+          # add methods
+          (opts[:methods] || []).each do |meth|
+            if self.respond_to?(meth)
+              map.add(meth.to_sym, send(meth))
+            end
+          end
+          (instance_variable_get("@yaml_addes") || []).each do |k,v|
+            map.add(k.to_s,v)
+          end
+        end
+      end
+    end
+  end
+
+  class Collection
+    def to_yaml(opts_or_emitter = {})
+      if opts_or_emitter.is_a?(YAML::Syck::Emitter)
+        to_a.to_yaml(opts_or_emitter)
+      else
+        # FIXME: Don't double handle the YAML (remove the YAML.load)
+        to_a.collect {|x| YAML.load(x.to_yaml(opts_or_emitter)) }.to_yaml
+      end
+    end
+  end
+end

data/lib/dm-serializer/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Serializer
-    VERSION = '0.9.8'
+    VERSION = '0.9.9'
   end
 end

data/lib/dm-serializer/xml_serializers/libxml.rb

@@ -0,0 +1,29 @@
+module DataMapper
+  module Serialize
+    module XMLSerializers
+      module LibXML
+        def self.new_document
+          ::LibXML::XML::Document.new
+        end
+
+        def self.root_node(doc, name, attrs = {})
+          root = ::LibXML::XML::Node.new(name)
+          attrs.each do |attr_name, attr_val|
+            root[attr_name] = attr_val
+          end
+          doc.root.nil? ? doc.root = root : doc.root << root
+          root
+        end
+
+        def self.add_node(parent, name, value, attrs = {})
+          value_str = value.to_s unless value.nil?
+          node = ::LibXML::XML::Node.new(name, value_str)
+          attrs.each do |attr_name, attr_val|
+            node[attr_name] = attr_val
+          end
+          parent << node
+        end
+      end
+    end
+  end
+end

data/lib/dm-serializer/xml_serializers/nokogiri.rb

@@ -0,0 +1,28 @@
+module DataMapper
+  module Serialize
+    module XMLSerializers
+      module Nokogiri
+        def self.new_document
+          ::Nokogiri::XML::Document.new
+        end
+
+        def self.root_node(doc, name, attrs = {})
+          root = ::Nokogiri::XML::Node.new(name, doc)
+          attrs.each do |attr_name, attr_val|
+            root[attr_name] = attr_val
+          end
+          doc.root.nil? ? doc.root = root : doc.root << root
+          root
+        end
+
+        def self.add_node(parent, name, value, attrs = {})
+          node = ::Nokogiri::XML::Node.new(name, parent.document)
+          node << ::Nokogiri::XML::Text.new(value.to_s, parent.document) unless value.nil?
+          attrs.each {|attr_name, attr_val| node[attr_name] = attr_val }
+          parent << node
+          node
+        end
+      end
+    end
+  end
+end

data/lib/dm-serializer/xml_serializers/rexml.rb

@@ -0,0 +1,23 @@
+module DataMapper
+  module Serialize
+    module XMLSerializers
+      module REXML
+        def self.new_document
+          ::REXML::Document.new
+        end
+
+        def self.root_node(document, name, attrs = {})
+          add_node(document.root || document, name, nil, attrs)
+        end
+
+        def self.add_node(parent, name, value, attrs = {})
+          node = parent.add_element(name)
+          attrs.each {|attr_name, attr_val| node.attributes[attr_name] = attr_val}
+          node << ::REXML::Text.new(value.to_s) unless value.nil?
+          node
+        end
+      end
+
+    end
+  end
+end

data/lib/dm-serializer/xml_serializers.rb

@@ -0,0 +1,17 @@
+require 'dm-serializer/xml_serializers/rexml'
+require 'dm-serializer/xml_serializers/nokogiri'
+require 'dm-serializer/xml_serializers/libxml'
+
+module DataMapper
+  module Serialize
+    module XMLSerializers
+      SERIALIZER = if defined?(::LibXML)
+                     LibXML
+                   elsif defined?(::Nokogiri)
+                     Nokogiri
+                   else
+                     REXML
+                   end
+    end
+  end
+end

data/lib/dm-serializer.rb

@@ -1,230 +1,4 @@
-require 'rexml/document'
-
-begin
-  gem('fastercsv')
-  require 'faster_csv'
-rescue LoadError
-  nil
-end
-
-begin
-  gem('json')
-  require 'json/ext'
-rescue LoadError
-  gem('json_pure')
-  require 'json/pure'
-end
-
-module DataMapper
-  module Serialize
-    # Serialize a Resource to JavaScript Object Notation (JSON; RFC 4627)
-    #
-    # @return <String> a JSON representation of the Resource
-    def to_json(*args)
-      options = args.first || {}
-      result = '{ '
-      fields = []
-
-      propset = properties_to_serialize(options)
-
-      fields += propset.map do |property|
-        "#{property.name.to_json}: #{send(property.getter).to_json}"
-      end
-
-      if self.respond_to?(:serialize_properties)
-        self.serialize_properties.each do |k,v|
-          fields << "#{k.to_json}: #{v.to_json}"
-        end
-      end
-
-      if self.class.respond_to?(:read_only_attributes) && exclude_read_only
-        self.class.read_only_attributes.each do |property|
-          fields << "#{property.to_json}: #{send(property).to_json}"
-        end
-      end
-
-      # add methods
-      (options[:methods] || []).each do |meth|
-        if self.respond_to?(meth)
-          fields << "#{meth.to_json}: #{send(meth).to_json}"
-        end
-      end
-
-      # Note: if you want to include a whole other model via relation, use :methods
-      # comments.to_json(:relationships=>{:user=>{:include=>[:first_name],:methods=>[:age]}})
-      # add relationships
-      (options[:relationships] || {}).each do |rel,opts|
-        if self.respond_to?(rel)
-          fields << "#{rel.to_json}: #{send(rel).to_json(opts)}"
-        end
-      end
-
-      result << fields.join(', ')
-      result << ' }'
-      result
-    end
-
-    # Serialize a Resource to comma-separated values (CSV).
-    #
-    # @return <String> a CSV representation of the Resource
-    def to_csv(writer = '')
-      FasterCSV.generate(writer) do |csv|
-        row = []
-        self.class.properties(repository.name).each do |property|
-         row << send(property.name).to_s
-        end
-        csv << row
-      end
-    end
-
-    # Serialize a Resource to XML
-    #
-    # @return <REXML::Document> an XML representation of this Resource
-    def to_xml(opts = {})
-
-      to_xml_document(opts).to_s
-    end
-
-    # Serialize a Resource to YAML
-    #
-    # @return <YAML> a YAML representation of this Resource
-    def to_yaml(opts = {})
-      YAML::quick_emit(object_id,opts) do |out|
-        out.map(nil,to_yaml_style) do |map|
-          propset = properties_to_serialize(opts)
-          propset.each do |property|
-            value = send(property.name.to_sym)
-            map.add(property.name, value.is_a?(Class) ? value.to_s : value)
-          end
-          # add methods
-          (opts[:methods] || []).each do |meth|
-            if self.respond_to?(meth)
-              map.add(meth.to_sym, send(meth))
-            end
-          end
-          (instance_variable_get("@yaml_addes") || []).each do |k,v|
-            map.add(k.to_s,v)
-          end
-        end
-      end
-    end
-
-    protected
-
-    # Returns propreties to serialize based on :only or :exclude arrays, if provided
-    # :only takes precendence over :exclude
-    #
-    # @return <Array> properties that need to be serialized
-    def properties_to_serialize(options)
-      only_properties     = Array(options[:only])
-      excluded_properties = Array(options[:exclude])
-      exclude_read_only   = options[:without_read_only_attributes] || false
-
-      self.class.properties(repository.name).reject do |p|
-        if only_properties.include? p.name
-          false
-        else
-          excluded_properties.include?(p.name) || !(only_properties.empty? || only_properties.include?(p.name))
-        end
-      end
-    end
-
-
-    # Return the name of this Resource - to be used as the root element name.
-    # This can be overloaded.
-    #
-    # @return <String> name of this Resource
-    def xml_element_name
-      Extlib::Inflection.underscore(self.class.name).tr("/", "-")
-    end
-
-    # Return a REXML::Document representing this Resource
-    #
-    # @return <REXML::Document> an XML representation of this Resource
-    def to_xml_document(opts={}, doc=nil)
-      doc ||= REXML::Document.new
-      root = doc.add_element(xml_element_name)
-
-      #TODO old code base was converting single quote to double quote on attribs
-
-      propset = properties_to_serialize(opts)
-      propset.each do |property|
-          value = send(property.name)
-          node = root.add_element(property.name.to_s)
-          unless property.type == String
-            node.attributes["type"] = property.type.to_s.downcase
-          end
-          node << REXML::Text.new(value.to_s) unless value.nil?
-      end
-
-      # add methods
-      (opts[:methods] || []).each do |meth|
-        if self.respond_to?(meth)
-          xml_name = meth.to_s.gsub(/[^a-z0-9_]/, '')
-          node = root.add_element(xml_name)
-          value = send(meth)
-          node << REXML::Text.new(value.to_s, :raw => true) unless value.nil?
-        end
-      end
-      doc
-    end
-
-  end # module Serialize
-
-  module Resource
-    include Serialize
-  end # module Resource
-
-  # the json gem adds Object#to_json, which breaks the DM proxies, since it
-  # happens *after* the proxy has been blank slated. This code removes the added
-  # method, so it is delegated correctly to the Collection
-  [
-    Associations::OneToMany::Proxy,
-    (Associations::ManyToOne::Proxy if defined?(Associations::ManyToOne::Proxy)),
-    Associations::ManyToMany::Proxy
-  ].each do |proxy|
-    [:to_json].each do |method|
-      proxy.send(:undef_method, :to_json) rescue nil
-    end
-  end
-
-  class Collection
-    def to_yaml(opts = {})
-      # FIXME: Don't double handle the YAML (remove the YAML.load)
-      to_a.collect {|x| YAML.load(x.to_yaml(opts)) }.to_yaml
-    end
-
-    def to_json(*args)
-      opts = args.first || {}
-      "[" << map {|e| e.to_json(opts)}.join(",") << "]"
-    end
-
-    def to_xml(opts = {})
-      to_xml_document(opts).to_s
-    end
-
-    def to_csv
-      result = ""
-      each do |item|
-        result << item.to_csv + "\n"
-      end
-      result
-    end
-
-    protected
-    def xml_element_name
-      Extlib::Inflection.pluralize(Extlib::Inflection.underscore(self.model.to_s)).tr("/", "-")
-    end
-
-    def to_xml_document(opts={})
-      doc = REXML::Document.new
-      root = doc.add_element(xml_element_name)
-      root.attributes["type"] = 'array'
-      each do |item|
-        item.send(:to_xml_document, opts, root)
-      end
-      doc
-    end
-  end
-
-end # module DataMapper
+require 'dm-serializer/to_json'
+require 'dm-serializer/to_xml'
+require 'dm-serializer/to_yaml'
+require 'dm-serializer/to_csv'

data/spec/fixtures/cow.rb

@@ -8,8 +8,4 @@ class Cow
 
   has n, :baby_cows, :class_name => 'Cow'
   belongs_to :mother_cow, :class_name => 'Cow'
-
-  def serialize_properties
-    {:extra => "Extra", :another => 42}
-  end
 end

data/spec/lib/serialization_method_shared_spec.rb

@@ -1,6 +1,47 @@
 require 'pathname'
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 
+share_examples_for 'A serialization method that also serializes core classes' do
+  # This spec ensures that we don't break any serialization methods attached
+  # to core classes, such as Array
+  before(:all) do
+    %w[ @harness ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_get(ivar)
+    end
+
+    DataMapper.auto_migrate!
+  end
+
+  before(:each) do
+    Cow.all.destroy!
+    Planet.all.destroy!
+    FriendedPlanet.all.destroy!
+  end
+
+  it 'serializes an array of extended objects' do
+    Cow.create(
+      :id        => 89,
+      :composite => 34,
+      :name      => 'Berta',
+      :breed     => 'Guernsey'
+    )
+    result = @harness.test(Cow.all.to_a)
+    result[0].values_at("id", "composite", "name", "breed").should ==
+      [89, 34, "Berta", "Guernsey"]
+  end
+
+  it 'serializes an array of collections' do
+    query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+    collection = DataMapper::Collection.new(query) do |c|
+      c.load([1, 2, 'Betsy', 'Jersey'])
+      c.load([89, 34, 'Berta', 'Guernsey'])
+    end
+    result = @harness.test([collection])
+    result[0][1].values_at("id", "composite", "name", "breed").should ==
+      [89, 34, "Berta", "Guernsey"]
+  end
+end
+
 share_examples_for 'A serialization method' do
   before(:all) do
     %w[ @harness ].each do |ivar|

data/spec/public/to_json_spec.rb

@@ -29,45 +29,7 @@ describe DataMapper::Serialize, '#to_json' do
   end
 
   it_should_behave_like "A serialization method"
-
-  it "should serialize an array of collections" do
-    deserialized_collection = JSON.parse([@collection].to_json).first
-    betsy = deserialized_collection.first
-    berta = deserialized_collection.last
-
-    betsy["id"].should        == 1
-    betsy["composite"].should == 2
-    betsy["name"].should      == "Betsy"
-    betsy["breed"].should     == "Jersey"
-
-    berta["id"].should        == 10
-    berta["composite"].should == 20
-    berta["name"].should      == "Berta"
-    berta["breed"].should     == "Guernsey"
-  end
-
-  it "should serialize an array of extended objects" do
-    deserialized_collection = JSON.parse(@collection.to_a.to_json)
-    betsy = deserialized_collection.first
-    berta = deserialized_collection.last
-
-    betsy["id"].should        == 1
-    betsy["composite"].should == 2
-    betsy["name"].should      == "Betsy"
-    betsy["breed"].should     == "Jersey"
-
-    berta["id"].should        == 10
-    berta["composite"].should == 20
-    berta["name"].should      == "Berta"
-    berta["breed"].should     == "Guernsey"
-  end
-
-  it "handles extra properties" do
-    deserialized_hash = JSON.parse(Cow.new(:id => 1, :name => "Harry", :breed => "Angus").to_json)
-
-    deserialized_hash["extra"].should == "Extra"
-    deserialized_hash["another"].should == 42
-  end
+  it_should_behave_like 'A serialization method that also serializes core classes'
 
   it "handles options given to a collection properly" do
     deserialized_collection = JSON.parse(@collection.to_json(:only => [:composite]))

data/spec/public/to_xml_spec.rb

@@ -1,89 +1,102 @@
 require 'pathname'
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 
-describe DataMapper::Serialize, '#to_xml' do
-  #
-  # ==== enterprisey XML
-  #
+{
+  'REXML'  => nil,
+  'LibXML' => 'libxml',
+  'Nokogiri' => 'nokogiri'
+}.each do |lib, file_to_require|
+  begin
+    require file_to_require if file_to_require
+  rescue LoadError
+    warn "[WARNING] Cannot require '#{file_to_require}', not running #to_xml specs for #{lib}"
+    next
+  end
 
-  before(:all) do
-    @harness = Class.new(SerializerTestHarness) do
-      def method_name
-        :to_xml
-      end
+  describe DataMapper::Serialize, "#to_xml using #{lib}" do
+    #
+    # ==== enterprisey XML
+    #
+
+    before(:all) do
+      @harness = Class.new(SerializerTestHarness) do
+        def method_name
+          :to_xml
+        end
 
-      protected
+        protected
 
-      def deserialize(result)
-        doc = REXML::Document.new(result)
-        root = doc.elements[1]
-        if root.attributes["type"] == "array"
-          root.elements.collect do |element|
+        def deserialize(result)
+          doc = REXML::Document.new(result)
+          root = doc.elements[1]
+          if root.attributes["type"] == "array"
+            root.elements.collect do |element|
+              a = {}
+              element.elements.each do |v|
+                a.update(v.name => cast(v.text, v.attributes["type"]))
+              end
+              a
+            end
+          else
             a = {}
-            element.elements.each do |v|
+            root.elements.each do |v|
               a.update(v.name => cast(v.text, v.attributes["type"]))
             end
             a
           end
-        else
-          a = {}
-          root.elements.each do |v|
-            a.update(v.name => cast(v.text, v.attributes["type"]))
-          end
-          a
         end
-      end
-
-      def cast(value, type)
-        boolean_conversions = {"true" => true, "false" => false}
-        value = boolean_conversions[value] if boolean_conversions.has_key?(value)
-        value = value.to_i if value && type == "integer"
-        value
-      end
-    end.new
-  end
-
-  it_should_behave_like "A serialization method"
 
-  describe 'Resource#xml_element_name' do
-    it 'should return the class name underscored and with slashes replaced with dashes' do
-      QuanTum::Cat.new.send(:xml_element_name).should == 'quan_tum-cat'
+        def cast(value, type)
+          boolean_conversions = {"true" => true, "false" => false}
+          value = boolean_conversions[value] if boolean_conversions.has_key?(value)
+          value = value.to_i if value && type == "integer"
+          value
+        end
+      end.new
+      DataMapper::Serialize::XMLSerializers.instance_eval { remove_const('SERIALIZER') }
+      DataMapper::Serialize::XMLSerializers::SERIALIZER = DataMapper::Serialize::XMLSerializers::const_get(lib)
     end
 
-    it 'should be used as the root node name by #to_xml' do
-      planet = Planet.new
-      class << planet
-        def xml_element_name
-          "aplanet"
-        end
+    it_should_behave_like "A serialization method"
+
+    describe ':element_name option for Resource' do
+      it 'should be used as the root node name by #to_xml' do
+        planet = Planet.new
+        xml = planet.to_xml(:element_name => "aplanet")
+        REXML::Document.new(xml).elements[1].name.should == "aplanet"
       end
 
-      xml = planet.to_xml
-      REXML::Document.new(xml).elements[1].name.should == "aplanet"
+      it 'when not specified the class name underscored and with slashes replaced with dashes should be used as the root node name' do
+        cat = QuanTum::Cat.new
+        xml = cat.to_xml
+        REXML::Document.new(xml).elements[1].name.should == "quan_tum-cat"
+      end
     end
-  end
 
-  describe 'Collection#xml_element_name' do
-    before(:each) do
-      query = DataMapper::Query.new(DataMapper::repository(:default), QuanTum::Cat)
-      @collection = DataMapper::Collection.new(query) {}
-    end
+    describe ':collection_element_name for Collection' do
+      before(:each) do
+        query = DataMapper::Query.new(DataMapper::repository(:default), QuanTum::Cat)
+        @collection = DataMapper::Collection.new(query) {}
+      end
 
-    it 'should return the class name tableized and with slashes replaced with dashes' do
-      @collection.send(:xml_element_name).should == 'quan_tum-cats'
-    end
+      it 'when not specified the class name tableized and with slashes replaced with dashes should be used as the root node name' do
+        xml = @collection.to_xml
+        REXML::Document.new(xml).elements[1].name.should == "quan_tum-cats"
+      end
 
-    it 'should be used as the root node name by #to_xml' do
-      planet = Planet.new
-      @collection.load([1])
-      class << @collection
-        def xml_element_name
-          "somanycats"
-        end
+      it 'should be used as the root node name by #to_xml' do
+        @collection.load([1])
+
+        xml = @collection.to_xml(:collection_element_name => "somanycats")
+        REXML::Document.new(xml).elements[1].name.should == "somanycats"
       end
 
-      xml = @collection.to_xml
-      REXML::Document.new(xml).elements[1].name.should == "somanycats"
+      it 'should respect :element_name for collection elements' do
+        @collection.load([1])
+
+        xml = @collection.to_xml(:collection_element_name => "somanycats", :element_name => 'cat')
+        REXML::Document.new(xml).elements[1].elements[1].name.should == "cat"
+      end
     end
   end
 end

data/spec/public/to_yaml_spec.rb

@@ -18,15 +18,20 @@ describe DataMapper::Serialize, '#to_yaml' do
       def deserialize(result)
         stringify_keys = lambda {|hash| hash.inject({}) {|a, (key, value)| a.update(key.to_s => value) }}
         result = YAML.load(result)
-        if result.is_a?(Array)
-          result.collect(&stringify_keys)
-        else
-          stringify_keys[result]
-        end
+        (process = lambda {|object|
+          if object.is_a?(Array)
+            object.collect(&process)
+          elsif object.is_a?(Hash)
+            stringify_keys[object]
+          else
+            object
+          end
+        })[result]
       end
     end.new
   end
 
-  it_should_behave_like "A serialization method"
+  it_should_behave_like 'A serialization method'
+  it_should_behave_like 'A serialization method that also serializes core classes'
 
 end

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
 require 'pathname'
 require 'rubygems'
 
-gem 'dm-core', '~>0.9.8'
+gem 'dm-core', '~>0.9.9'
 require 'dm-core'
 
 spec_dir_path = Pathname(__FILE__).dirname.expand_path
-require spec_dir_path.parent + 'lib/dm-serializer'
+$LOAD_PATH.unshift(spec_dir_path.parent + 'lib/')
+require 'dm-serializer'
 
 def load_driver(name, default_uri)
   return false if ENV['ADAPTER'] != name.to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-serializer
 version: !ruby/object:Gem::Version 
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors: 
 - Guy van den Berg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-07 00:00:00 -08:00
+date: 2009-01-04 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.9.8
+        version: 0.9.9
     version: 
 description: DataMapper plugin for serializing DataMapper objects
 email: 
@@ -30,7 +30,7 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.txt
+- README.textile
 - LICENSE
 - TODO
 - History.txt
@@ -38,13 +38,23 @@ files:
 - History.txt
 - LICENSE
 - Manifest.txt
-- README.txt
+- README.textile
 - Rakefile
 - TODO
 - autotest/discover.rb
 - autotest/dmserializer_rspec.rb
+- benchmarks/to_xml.rb
 - lib/dm-serializer.rb
+- lib/dm-serializer/common.rb
+- lib/dm-serializer/to_csv.rb
+- lib/dm-serializer/to_json.rb
+- lib/dm-serializer/to_xml.rb
+- lib/dm-serializer/to_yaml.rb
 - lib/dm-serializer/version.rb
+- lib/dm-serializer/xml_serializers.rb
+- lib/dm-serializer/xml_serializers/libxml.rb
+- lib/dm-serializer/xml_serializers/nokogiri.rb
+- lib/dm-serializer/xml_serializers/rexml.rb
 - spec/fixtures/cow.rb
 - spec/fixtures/planet.rb
 - spec/fixtures/quan_tum_cat.rb

data/README.txt

@@ -1,3 +0,0 @@
-= dm-serializer
-
-DataMapper plugin for serializing DataMapper objects.