sbf-dm-serializer 1.3.0.beta

data/spec/lib/serialization_method_shared_spec.rb

@@ -0,0 +1,287 @@
+shared_examples '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(&: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)
+    expect(result[0].values_at('id', 'composite', 'name', 'breed')).to eq [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 = [
+      keys.zip([1,  2, 'Betsy', 'Jersey']).to_h,
+      keys.zip([89, 34, 'Berta', 'Guernsey']).to_h,
+    ]
+
+    collection = DataMapper::Collection.new(query, query.model.load(resources, query))
+
+    result = @harness.test(collection)
+    expect(result[0].values_at(*keys)).to eq resources[0].values_at(*keys)
+    expect(result[1].values_at(*keys)).to eq resources[1].values_at(*keys)
+  end
+end
+
+shared_examples '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(&:destroy!)
+  end
+
+  describe '(serializing single resources)' do
+    it 'serializes 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)
+      expect(result.values_at('name', 'breed')).to eq %w(Berta Guernsey)
+    end
+
+    it 'serializes a resource' do
+      cow = Cow.new(
+        id: 89,
+        composite: 34,
+        name: 'Berta',
+        breed: 'Guernsey'
+      )
+
+      result = @harness.test(cow)
+      expect(result.values_at('id', 'composite', 'name', 'breed')).to eq [89, 34, 'Berta', 'Guernsey']
+    end
+
+    it 'excludes nil properties' do
+      cow = Cow.new(
+        id: 89,
+        name: nil
+      )
+
+      result = @harness.test(cow)
+      expect(result.values_at('id', 'composite')).to eq [89, nil]
+    end
+
+    it 'only includes properties given to :only option' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      planet = Planet.new(
+        name: 'Mars',
+        aphelion: 249_209_300.4
+      )
+
+      result = @harness.test(planet, only: [:name])
+      expect(result.values_at('name', 'aphelion')).to eq ['Mars', nil]
+    end
+
+    it 'serializes values returned by an array of methods given to :methods option' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      planet = Planet.new(
+        name: 'Mars',
+        aphelion: 249_209_300.4
+      )
+
+      result = @harness.test(planet, methods: %i(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?'
+      expect(result.values_at('category', boolean_method_name)).to eq ['terrestrial', false]
+    end
+
+    it 'serializes values returned by a single method given to :methods option' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      planet = Planet.new(
+        name: 'Mars',
+        aphelion: 249_209_300.4
+      )
+
+      result = @harness.test(planet, methods: :category)
+      expect(result.values_at('category')).to eq ['terrestrial']
+    end
+
+    it 'only includes properties given to :only option' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      planet = Planet.new(
+        name: 'Mars',
+        aphelion: 249_209_300.4
+      )
+
+      result = @harness.test(planet, only: [:name])
+      expect(result.values_at('name', 'aphelion')).to eq ['Mars', nil]
+    end
+
+    it 'excludes properties given to :exclude option' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      planet = Planet.new(
+        name: 'Mars',
+        aphelion: 249_209_300.4
+      )
+
+      result = @harness.test(planet, exclude: [:aphelion])
+      expect(result.values_at('name', 'aphelion')).to eq ['Mars', nil]
+    end
+
+    it 'gives higher precedence to :only option over :exclude' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      planet = Planet.new(
+        name: 'Mars',
+        aphelion: 249_209_300.4
+      )
+
+      result = @harness.test(planet, only: [:name], exclude: [:name])
+      expect(result.values_at('name', 'aphelion')).to eq ['Mars', nil]
+    end
+
+    it 'supports child associations included via the :methods parameter' do
+      pending 'Psych provides no way to pass in parameters' if @ruby_192 && @to_yaml
+
+      solar_system = SolarSystem.create(name: 'one')
+      planet = Planet.new(name: 'earth')
+      planet.solar_system = solar_system
+      result = @harness.test(planet, methods: [:solar_system])
+      expect(result['solar_system'].values_at('name', 'id')).to eq ['one', 1]
+    end
+  end
+
+  describe '(collections and proxies)' do
+    it 'serializes 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)
+      expect(result[0].values_at('name', 'breed')).to eq %w(Berta Guernsey)
+    end
+
+    it 'serializes a collection' do
+      query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+
+      keys = %w(id composite name breed)
+
+      resources = [
+        keys.zip([1,  2, 'Betsy', 'Jersey']).to_h,
+        keys.zip([10, 20, 'Berta', 'Guernsey']).to_h,
+      ]
+
+      collection = DataMapper::Collection.new(query, query.model.load(resources, query))
+
+      result = @harness.test(collection)
+      expect(result[0].values_at(*keys)).to eq resources[0].values_at(*keys)
+      expect(result[1].values_at(*keys)).to eq resources[1].values_at(*keys)
+    end
+
+    it 'serializes an empty collection' do
+      query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+      collection = DataMapper::Collection.new(query)
+
+      result = @harness.test(collection)
+      expect(result).to 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)
+      expect(result).to be_kind_of(Array)
+
+      expect(result[0].values_at(*%w(id composite name breed))).to eq [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)
+      expect(result).to be_kind_of(Hash)
+      expect(result.values_at(*%w(id composite name breed))).to eq [1, 322, 'Harry', 'Angus']
+    end
+
+    it 'serializes a many to many relationship' do
+      pending 'TODO: fix many to many in dm-core'
+      p1 = Planet.create(name: 'earth')
+      p2 = Planet.create(name: 'mars')
+
+      FriendedPlanet.create(planet: p1, friend_planet: p2)
+
+      result = @harness.test(p1.reload.friend_planets)
+      expect(result).to be_kind_of(Array)
+
+      expect(result[0]['name']).to eq 'mars'
+    end
+  end
+
+  with_alternate_adapter do
+
+    describe '(multiple repositories)' do
+      before(:all) do
+        %i(default alternate).each do |repository_name|
+          DataMapper.repository(repository_name) do
+            QuanTum::Cat.auto_migrate!
+            QuanTum::Cat.destroy!
+          end
+        end
+      end
+
+      it 'uses the repository 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) }
+        expect(@harness.test(gerry)['is_dead']).to be(nil)
+        expect(@harness.test(george)['is_dead']).to be(false)
+      end
+    end
+
+  end
+
+  it 'integrates with dm-validations' do
+    planet = Planet.create(name: 'a')
+    results = @harness.test(planet.errors)
+    expect(results).to eq({
+                            'name' => planet.errors[:name].map(&:to_s),
+                            'solar_system_id' => planet.errors[:solar_system_id].map(&:to_s)
+                          })
+  end
+end

data/spec/public/serializer_spec.rb

@@ -0,0 +1,7 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Serialize do
+  it 'is included into DataMapper::Resource' do
+    expect(Cow.new).to be_kind_of(DataMapper::Serialize)
+  end
+end

data/spec/public/to_csv_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../spec_helper'
+
+if defined?(::CSV)
+  describe DataMapper::Serialize, '#to_csv' do
+    #
+    # ==== blah, it's CSV
+    #
+
+    before(:all) do
+      DataMapper.finalize
+      query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+
+      resources = [
+        {id: 1, composite: 2, name: 'Betsy', breed: 'Jersey'},
+        {id: 10, composite: 20, name: 'Berta', breed: 'Guernsey'}
+      ]
+
+      @collection = DataMapper::Collection.new(query, resources)
+
+      @empty_collection = DataMapper::Collection.new(query)
+    end
+
+    it 'serializes a resource to CSV' do
+      peter = Cow.new
+      peter.id = 44
+      peter.composite = 344
+      peter.name = 'Peter'
+      peter.breed = 'Long Horn'
+
+      expect(peter.to_csv.chomp.split(',')[0..3]).to eq ['44','344','Peter','Long Horn']
+    end
+
+    it 'serializes a collection to CSV' do
+      result = @collection.to_csv.gsub(/[[:space:]]+\n/, "\n")
+      expect(result.split("\n")[0].split(',')[0..3]).to eq %w(1 2 Betsy Jersey)
+      expect(result.split("\n")[1].split(',')[0..3]).to eq %w(10 20 Berta Guernsey)
+    end
+
+    it 'integrates with dm-validations by providing one line per error' do
+      planet = Planet.create(name: 'a')
+      result = planet.errors.to_csv.gsub(/[[:space:]]+\n/, "\n").split("\n")
+      expect(result).to include("name,#{planet.errors[:name][0]}")
+      expect(result).to include("solar_system_id,#{planet.errors[:solar_system_id][0]}")
+      expect(result.length).to eq 2
+    end
+
+    with_alternate_adapter do
+
+      describe 'multiple repositories' do
+        before(:all) do
+          %i(default alternate).each do |repository_name|
+            DataMapper.repository(repository_name) do
+              DataMapper.finalize
+              QuanTum::Cat.auto_migrate!
+              QuanTum::Cat.destroy!
+            end
+          end
+        end
+
+        it 'uses the repository for the model' do
+          gerry = QuanTum::Cat.create(name: 'gerry')
+          george = DataMapper.repository(:alternate){ QuanTum::Cat.create(name: 'george', is_dead: false) }
+          expect(gerry.to_csv).not_to match(/false/)
+          expect(george&.to_csv).not_to match(/false/)
+        end
+      end
+    end
+  end
+else
+  warn "[WARNING] Cannot require 'faster_csv' or 'csv', not running #to_csv specs"
+end

data/spec/public/to_json_spec.rb

@@ -0,0 +1,75 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Serializer, '#to_json' do
+  #
+  # ==== ajaxy JSON
+  #
+
+  before(:all) do
+    DataMapper.finalize
+    DataMapper.auto_migrate!
+    query = DataMapper::Query.new(DataMapper::repository(:default), Cow)
+
+    keys = %w(id composite name breed)
+
+    resources = [
+      keys.zip([1, 2, 'Betsy', 'Jersey']).to_h,
+      keys.zip([10, 20, 'Berta', 'Guernsey']).to_h,
+    ]
+
+    @collection = DataMapper::Collection.new(query, query.model.load(resources, query))
+
+    @harness = Class.new(SerializerTestHarness) do
+      def method_name
+        :to_json
+      end
+
+      protected
+
+      def deserialize(result)
+        JSON.parse(result)
+      end
+    end.new
+  end
+
+  it_behaves_like 'A serialization method'
+  it_behaves_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]))
+    betsy = deserialized_collection.first
+    berta = deserialized_collection.last
+
+    expect(betsy['id']).to be_nil
+    expect(betsy['composite']).to eq 2
+    expect(betsy['name']).to be_nil
+    expect(betsy['breed']).to be_nil
+
+    expect(berta['id']).to be_nil
+    expect(berta['composite']).to eq 20
+    expect(berta['name']).to be_nil
+    expect(berta['breed']).to be_nil
+  end
+
+  it 'supports :include option for one level depth'
+
+  it 'supports :include option for more than one level depth'
+
+  it 'has :repository option to override used repository'
+
+  it 'can be serialized within a Hash' do
+    hash = {'cows' => Cow.all}
+    expect(JSON.parse(hash.to_json)).to eq hash
+  end
+
+end
+
+describe DataMapper::Serializer, '#as_json' do
+  it 'handles nil for options' do
+    expect { Cow.new.as_json(nil) }.not_to raise_error
+  end
+
+  it 'serializes Discriminator types as strings' do
+    expect(Motorcycle.new.as_json[:type]).to eq 'Motorcycle'
+  end
+end

data/spec/public/to_xml_spec.rb

@@ -0,0 +1,108 @@
+require_relative '../spec_helper'
+require 'rexml/document'
+
+%i(rexml libxml nokogiri).each do |lib|
+  begin
+    DataMapper::Serializer::XML.serializer = lib
+  rescue LoadError => e
+    warn "[WARNING] #{e.message}"
+    warn "[WARNING] Not running #to_xml specs for #{lib}"
+    next
+  end
+
+  describe DataMapper::Serializer, "#to_xml using #{lib}" do
+    before(:all) do
+      DataMapper.finalize
+
+      @harness = Class.new(SerializerTestHarness) do
+        def method_name
+          :to_xml
+        end
+
+        protected def deserialize(result)
+          f = lambda do |element|
+            case element.attributes['type']
+            when 'hash'
+              element.elements.to_a.inject({}) do |a, e|
+                a.update(e.name => f[e])
+              end
+            when 'array'
+              element.elements.collect do |e|
+                f[e]
+              end
+            else
+              if element.elements.empty?
+                cast(element.text, element.attributes['type'])
+              else
+                element.elements.to_a.inject({}) do |a, e|
+                  a.update(e.name => f[e])
+                end
+              end
+            end
+          end
+
+          doc = REXML::Document.new(result)
+          f[doc.elements[1]]
+        end
+
+        protected def cast(value, type)
+          boolean_conversions = {'true' => true, 'false' => false}
+          value = boolean_conversions[value] if boolean_conversions.key?(value)
+          value = value.to_i if value && %w(integer datamapper::types::serial).include?(type)
+          value
+        end
+      end.new
+    end
+
+    it_behaves_like 'A serialization method'
+
+    it 'does not include the XML prologue, so that the result can be embedded in other XML documents' do
+      planet = Planet.new
+      xml = planet.to_xml(element_name: 'aplanet')
+      expect(xml).not_to match(/\A<?xml/)
+    end
+
+    describe ':element_name option for Resource' do
+      it 'is used as the root node name by #to_xml' do
+        planet = Planet.new
+        xml = planet.to_xml(element_name: 'aplanet')
+        expect(REXML::Document.new(xml).elements[1].name).to eq 'aplanet'
+      end
+
+      it 'when not specified the class name underscored and with slashes replaced with dashes is used as the root node name' do
+        cat = QuanTum::Cat.new
+        xml = cat.to_xml
+        expect(REXML::Document.new(xml).elements[1].name).to eq 'quan_tum-cat'
+      end
+    end
+
+    describe ':collection_element_name for Collection' do
+      before(:each) do
+        @model = QuanTum::Cat
+        @query = DataMapper::Query.new(DataMapper::repository(:default), @model)
+        @collection = DataMapper::Collection.new(@query)
+      end
+
+      it 'when not specified the class name tableized and with slashes replaced with dashes is used as the root node name' do
+        xml = DataMapper::Collection.new(@query).to_xml
+        expect(REXML::Document.new(xml).elements[1].name).to eq 'quan_tum-cats'
+      end
+
+      it 'is used as the root node name by #to_xml' do
+        resources = @model.load([{'id' => 1}], @query)
+        @collection = DataMapper::Collection.new(@query, resources)
+
+        xml = @collection.to_xml(collection_element_name: 'somanycats')
+        expect(REXML::Document.new(xml).elements[1].name).to eq 'somanycats'
+      end
+
+      it 'respects :element_name for collection elements' do
+        resources = @model.load([{'id' => 1}], @query)
+        @collection = DataMapper::Collection.new(@query, resources)
+
+        xml = @collection.to_xml(collection_element_name: 'somanycats', element_name: 'cat')
+        expect(REXML::Document.new(xml).elements[1].elements[1].name).to eq 'cat'
+      end
+    end
+  end
+end

data/spec/public/to_yaml_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Serializer, '#to_yaml' do
+  #
+  # ==== yummy YAML
+  #
+
+  before(:all) do
+    DataMapper.finalize
+    @harness = Class.new(SerializerTestHarness) do
+      def method_name
+        :to_yaml
+      end
+
+      def deserialize(result)
+        result = YAML.load(result)
+        process = lambda { |object|
+          if object.is_a?(Array)
+            object.collect(&process)
+          elsif object.is_a?(Hash)
+            object.inject({}) { |a, (key, value)| a.update(key.to_s => process[value]) }
+          else
+            object
+          end
+        }
+        process[result]
+      end
+    end.new
+
+    @ruby_192 = RUBY_VERSION >= '1.9.2'
+    @to_yaml  = true
+  end
+
+  it_behaves_like 'A serialization method'
+  it_behaves_like 'A serialization method that also serializes core classes'
+
+  it 'allows static YAML dumping' do
+    object = Cow.create(
+      id: 89,
+      composite: 34,
+      name: 'Berta',
+      breed: 'Guernsey'
+    )
+    result = @harness.deserialize(YAML.dump(object))
+    expect(result['name']).to eq 'Berta'
+  end
+
+  it 'allows static YAML dumping of a collection' do
+    Cow.create(
+      id: 89,
+      composite: 34,
+      name: 'Berta',
+      breed: 'Guernsey'
+    )
+    result = @harness.deserialize(YAML.dump(Cow.all))
+    expect(result[0]['name']).to eq 'Berta'
+  end
+
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+require 'dm-core/spec/lib/pending_helpers'
+
+require 'dm-validations' # FIXME: must be required before dm-serializer
+require 'dm-serializer'
+require 'dm-migrations'
+
+require File.expand_path('spec/lib/serialization_method_shared_spec')
+
+# require fixture resources
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+Pathname.glob("#{SPEC_ROOT}fixtures/**/*.rb".to_s).each { |file| require file }
+
+class SerializerTestHarness
+  def test(object, *args)
+    deserialize(object.send(method_name, *args))
+  end
+end
+
+DataMapper::Spec.setup
+
+RSpec.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+end

data/tasks/spec.rake

@@ -0,0 +1,21 @@
+require 'rspec/core/rake_task'
+
+begin
+  task(:default).clear
+  task(:spec).clear
+
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+
+    require 'simplecov'
+    SimpleCov.start do
+      minimum_coverage 100
+    end
+  end
+rescue LoadError
+  task :spec do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+end
+
+task default: :spec

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/tasks/yardstick.rake

@@ -0,0 +1,19 @@
+begin
+  require 'pathname'
+  require 'yardstick/rake/measurement'
+  require 'yardstick/rake/verify'
+
+  # yardstick_measure task
+  Yardstick::Rake::Measurement.new
+
+  # verify_measurements task
+  Yardstick::Rake::Verify.new do |verify|
+    verify.threshold = 100
+  end
+rescue LoadError
+  %w[ yardstick_measure verify_measurements ].each do |name|
+    task name.to_s do
+      abort "Yardstick is not available. In order to run #{name}, you must: gem install yardstick"
+    end
+  end
+end