ardm-serializer 1.2.2

data/lib/dm-serializer/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Serializer
+    VERSION = '1.2.2'
+  end
+end

data/lib/dm-serializer/xml.rb

@@ -0,0 +1,56 @@
+module DataMapper
+  module Serializer
+    module XML
+      # The supported XML Serializers
+      SERIALIZERS = {
+        :libxml => 'LibXML',
+        :nokogiri => 'Nokogiri',
+        :rexml => 'REXML'
+      }
+
+      #
+      # The current XML Serializer.
+      #
+      # @return [Module]
+      #   The module within {DataMapper::Serialize::XML}.
+      #
+      # @since 1.1.0
+      #
+      def self.serializer
+        @serializer
+      end
+
+      #
+      # Sets the XML Serializer to use.
+      #
+      # @param [Symbol] name
+      #   The name of the serializer to use. Must be either `:libxml`,
+      #   `:nokogiri` or `:rexml`.
+      #
+      # @return [Module]
+      #   The module within {DataMapper::Serialize::XML}.
+      #
+      # @since 1.1.0
+      #
+      def self.serializer=(name)
+        serializer_const = SERIALIZERS[name]
+
+        unless serializer_const
+          raise(ArgumentError,"unsupported XML Serializer #{name}")
+        end
+
+        require "dm-serializer/xml/#{name}"
+        @serializer = const_get(serializer_const)
+      end
+
+      [:nokogiri, :libxml, :rexml].each do |name|
+        # attempt to load the first available XML Serializer
+        begin
+          self.serializer = name
+          break
+        rescue LoadError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'libxml'
+
+module DataMapper
+  module Serializer
+    module XML
+      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
+          node
+        end
+
+        def self.add_xml(parent, xml)
+          parent << xml.root.copy(true)
+        end
+
+        def self.output(doc)
+          doc.root.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'nokogiri'
+
+module DataMapper
+  module Serializer
+    module XML
+      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 do |attr_name, attr_val|
+            node[attr_name] = attr_val
+          end
+
+          parent << node
+          node
+        end
+
+        def self.add_xml(parent, xml)
+          parent << xml.root
+        end
+
+        def self.output(doc)
+          doc.root.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'rexml/document'
+
+module DataMapper
+  module Serializer
+    module XML
+      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 do |attr_name, attr_val|
+            node.attributes[attr_name] = attr_val
+          end
+
+          node << ::REXML::Text.new(value.to_s) unless value.nil?
+          node
+        end
+
+        def self.add_xml(parent, xml)
+          parent.add(xml)
+        end
+
+        def self.output(doc)
+          doc.to_s
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/cow.rb

@@ -0,0 +1,11 @@
+class Cow
+  include DataMapper::Resource
+
+  property :id,        Integer, :key => true
+  property :composite, Integer, :key => true
+  property :name,      String
+  property :breed,     String
+
+  belongs_to :mother_cow, :model => self, :required => false
+  has n, :baby_cows, :model => self, :child_key => [ :mother_cow_id, :mother_cow_composite ]
+end

data/spec/fixtures/planet.rb

@@ -0,0 +1,46 @@
+class Planet
+  include DataMapper::Resource
+
+  property :name,     String, :key => true
+  property :aphelion, Float
+
+  validates_length_of :name, :min => 2
+
+  # Sorry these associations don't make any sense
+  # I just needed a many-to-many association to test against
+  has n, :friended_planets
+  has n, :friend_planets, :through => :friended_planets, :model => 'Planet'
+
+  belongs_to :solar_system
+
+  def category
+    case self.name.downcase
+    when "mercury", "venus", "earth", "mars" then "terrestrial"
+    when "jupiter", "saturn", "uranus", "neptune" then "gas giants"
+    when "pluto" then "dwarf planets"
+    end
+  end
+
+  def has_known_form_of_life?
+    self.name.downcase == "earth"
+  end
+end
+
+class FriendedPlanet
+  include DataMapper::Resource
+
+  property :planet_name,        String, :key => true
+  property :friend_planet_name, String, :key => true
+
+  belongs_to :planet, :child_key => [ :planet_name ]
+  belongs_to :friend_planet, :model => 'Planet', :child_key => [ :friend_planet_name ]
+end
+
+class SolarSystem
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  property :name, String
+
+end

data/spec/fixtures/quan_tum_cat.rb

@@ -0,0 +1,15 @@
+# Yes, this crazy capitalization is intentional,
+# to test xml root element name generation
+module QuanTum
+  class Cat
+    include DataMapper::Resource
+
+    property :id,       Serial
+    property :name,     String
+    property :location, String
+
+    repository(:alternate) do
+      property :is_dead, Boolean
+    end
+  end
+end

data/spec/fixtures/vehicle.rb

@@ -0,0 +1,14 @@
+class Vehicle
+  include DataMapper::Resource
+  property :id, Serial
+  property :name, String
+  property :type, Discriminator
+end
+
+class Car < Vehicle
+
+end
+
+class Motorcycle < Vehicle
+
+end

data/spec/lib/serialization_method_shared_spec.rb

@@ -0,0 +1,290 @@
+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
+    DataMapper::Model.descendants.each { |model| model.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)
+
+    keys = %w[ id composite name breed ]
+
+    resources = [
+      Hash[ keys.zip([  1,  2, 'Betsy', 'Jersey'   ]) ],
+      Hash[ keys.zip([ 89, 34, 'Berta', 'Guernsey' ]) ],
+    ]
+
+    collection = DataMapper::Collection.new(query, query.model.load(resources, query))
+
+    result = @harness.test(collection)
+    result[0].values_at(*keys).should == resources[0].values_at(*keys)
+    result[1].values_at(*keys).should == resources[1].values_at(*keys)
+  end
+end
+
+share_examples_for 'A serialization method' do
+  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
+    DataMapper::Model.descendants.each { |model| model.destroy! }
+  end
+
+  describe '(serializing single resources)' do
+    it 'should serialize Model.first' do
+      # At the moment this is implied by serializing a resource, but this
+      # test ensures the contract even if dm-core changes
+      Cow.create(
+        :id        => 89,
+        :composite => 34,
+        :name      => 'Berta',
+        :breed     => 'Guernsey'
+      )
+      result = @harness.test(Cow.first)
+      result.values_at("name", "breed").should == ["Berta", "Guernsey"]
+    end
+
+    it 'should serialize a resource' do
+      cow = Cow.new(
+        :id        => 89,
+        :composite => 34,
+        :name      => 'Berta',
+        :breed     => 'Guernsey'
+      )
+
+      result = @harness.test(cow)
+      result.values_at("id", "composite", "name", "breed").should == [89,  34, 'Berta', 'Guernsey']
+    end
+
+    it 'should exclude nil properties' do
+      cow = Cow.new(
+        :id        => 89,
+        :name      => nil
+      )
+
+      result = @harness.test(cow)
+      result.values_at("id", "composite").should == [89,  nil]
+    end
+
+    it "should only includes properties given to :only option" do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        planet = Planet.new(
+          :name     => "Mars",
+          :aphelion => 249_209_300.4
+        )
+
+        result = @harness.test(planet, :only => [:name])
+        result.values_at("name", "aphelion").should == ["Mars", nil]
+      end
+    end
+
+    it "should serialize values returned by an array of methods given to :methods option" do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        planet = Planet.new(
+          :name     => "Mars",
+          :aphelion => 249_209_300.4
+        )
+
+        result = @harness.test(planet, :methods => [:category, :has_known_form_of_life?])
+        # XML currently can't serialize ? at the end of method names
+        boolean_method_name = @harness.method_name == :to_xml ? "has_known_form_of_life" : "has_known_form_of_life?"
+        result.values_at("category", boolean_method_name).should == ["terrestrial", false]
+      end
+    end
+
+    it "should serialize values returned by a single method given to :methods option" do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        planet = Planet.new(
+          :name     => "Mars",
+          :aphelion => 249_209_300.4
+        )
+
+        result = @harness.test(planet, :methods => :category)
+        result.values_at("category").should == ["terrestrial"]
+      end
+    end
+
+    it "should only include properties given to :only option" do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        planet = Planet.new(
+          :name     => "Mars",
+          :aphelion => 249_209_300.4
+        )
+
+        result = @harness.test(planet, :only => [:name])
+        result.values_at("name", "aphelion").should == ["Mars", nil]
+      end
+    end
+
+    it "should exclude properties given to :exclude option" do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        planet = Planet.new(
+          :name     => "Mars",
+          :aphelion => 249_209_300.4
+        )
+
+        result = @harness.test(planet, :exclude => [:aphelion])
+        result.values_at("name", "aphelion").should == ["Mars", nil]
+      end
+    end
+
+    it "should give higher precendence to :only option over :exclude" do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        planet = Planet.new(
+          :name     => "Mars",
+          :aphelion => 249_209_300.4
+        )
+
+        result = @harness.test(planet, :only => [:name], :exclude => [:name])
+        result.values_at("name", "aphelion").should == ["Mars", nil]
+      end
+    end
+
+    it 'should support child associations included via the :methods parameter' do
+      pending_if 'Psych provides no way to pass in parameters', @ruby_192 && @to_yaml do
+        solar_system = SolarSystem.create(:name => "one")
+        planet = Planet.new(:name => "earth")
+        planet.solar_system = solar_system
+        result = @harness.test(planet, :methods => [:solar_system])
+        result['solar_system'].values_at('name', 'id').should == ['one', 1]
+      end
+    end
+  end
+
+  describe "(collections and proxies)" do
+    it 'should serialize Model.all' do
+      # At the moment this is implied by serializing a collection, but this
+      # test ensures the contract even if dm-core changes
+      Cow.create(
+        :id        => 89,
+        :composite => 34,
+        :name      => 'Berta',
+        :breed     => 'Guernsey'
+      )
+      result = @harness.test(Cow.all)
+      result[0].values_at("name", "breed").should == ["Berta", "Guernsey"]
+    end
+
+    it 'should serialize a collection' do
+      query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+
+      keys = %w[ id composite name breed ]
+
+      resources = [
+        Hash[ keys.zip([  1,  2, 'Betsy', 'Jersey'   ]) ],
+        Hash[ keys.zip([ 10, 20, 'Berta', 'Guernsey' ]) ],
+      ]
+
+      collection = DataMapper::Collection.new(query, query.model.load(resources, query))
+
+      result = @harness.test(collection)
+      result[0].values_at(*keys).should == resources[0].values_at(*keys)
+      result[1].values_at(*keys).should == resources[1].values_at(*keys)
+    end
+
+    it 'should serialize an empty collection' do
+      query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+      collection = DataMapper::Collection.new(query)
+
+      result = @harness.test(collection)
+      result.should be_empty
+    end
+
+    it "serializes a one to many relationship" do
+      parent = Cow.new(:id => 1, :composite => 322, :name => "Harry", :breed => "Angus")
+      baby = Cow.new(:mother_cow => parent, :id => 2, :composite => 321, :name => "Felix", :breed => "Angus")
+
+      parent.save
+      baby.save
+
+      result = @harness.test(parent.baby_cows)
+      result.should be_kind_of(Array)
+
+      result[0].values_at(*%w{id composite name breed}).should == [2, 321, "Felix", "Angus"]
+    end
+
+    it "serializes a many to one relationship" do
+      parent = Cow.new(:id => 1, :composite => 322, :name => "Harry", :breed => "Angus")
+      baby = Cow.new(:mother_cow => parent, :id => 2, :composite => 321, :name => "Felix", :breed => "Angus")
+
+      parent.save
+      baby.save
+
+      result = @harness.test(baby.mother_cow)
+      result.should be_kind_of(Hash)
+      result.values_at(*%w{id composite name breed}).should == [1, 322, "Harry", "Angus"]
+    end
+
+    it "serializes a many to many relationship" do
+      pending 'TODO: fix many to many in dm-core' do
+        p1 = Planet.create(:name => 'earth')
+        p2 = Planet.create(:name => 'mars')
+
+        FriendedPlanet.create(:planet => p1, :friend_planet => p2)
+
+        result = @harness.test(p1.reload.friend_planets)
+        result.should be_kind_of(Array)
+
+        result[0]["name"].should == "mars"
+      end
+    end
+  end
+
+  with_alternate_adapter do
+
+    describe "(multiple repositories)" do
+      before(:all) do
+        [ :default, :alternate ].each do |repository_name|
+          DataMapper.repository(repository_name) do
+            QuanTum::Cat.auto_migrate!
+            QuanTum::Cat.destroy!
+          end
+        end
+      end
+
+      it "should use the repsoitory for the model" do
+        alternate_repo = DataMapper::Spec.spec_adapters[:alternate].name
+        gerry = QuanTum::Cat.create(:name => "gerry")
+        george = DataMapper.repository(alternate_repo){ QuanTum::Cat.create(:name => "george", :is_dead => false) }
+        @harness.test(gerry )['is_dead'].should be(nil)
+        @harness.test(george)['is_dead'].should be(false)
+      end
+    end
+
+  end
+
+  it 'should integrate with dm-validations' do
+    planet = Planet.create(:name => 'a')
+    results = @harness.test(planet.errors)
+    results.should == {
+      "name"            => planet.errors[:name].map { |e| e.to_s },
+      "solar_system_id" => planet.errors[:solar_system_id].map { |e| e.to_s }
+    }
+  end
+end