ardm-serializer 1.2.2

data/spec/public/serializer_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DataMapper::Serialize do
+  it "is included into DataMapper::Resource" do
+    Cow.new.should be_kind_of(DataMapper::Serialize)
+  end
+end

data/spec/public/to_csv_spec.rb

@@ -0,0 +1,72 @@
+require '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 "should serialize a resource to CSV" do
+      peter = Cow.new
+      peter.id = 44
+      peter.composite = 344
+      peter.name = 'Peter'
+      peter.breed = 'Long Horn'
+
+      peter.to_csv.chomp.split(',')[0..3].should == ['44','344','Peter','Long Horn']
+    end
+
+    it "should serialize a collection to CSV" do
+      result = @collection.to_csv.gsub(/[[:space:]]+\n/, "\n")
+      result.split("\n")[0].split(',')[0..3].should == ['1','2','Betsy','Jersey']
+      result.split("\n")[1].split(',')[0..3].should == ['10','20','Berta','Guernsey']
+    end
+
+    it 'should integrate 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")
+      result.should include("name,#{planet.errors[:name][0]}")
+      result.should include("solar_system_id,#{planet.errors[:solar_system_id][0]}")
+      result.length.should == 2
+    end
+
+    with_alternate_adapter do
+
+      describe "multiple repositories" do
+        before(:all) do
+          [ :default, :alternate ].each do |repository_name|
+            DataMapper.repository(repository_name) do
+              DataMapper.finalize
+              QuanTum::Cat.auto_migrate!
+              QuanTum::Cat.destroy!
+            end
+          end
+        end
+
+        it "should use the repsoitory for the model" do
+          gerry = QuanTum::Cat.create(:name => "gerry")
+          george = DataMapper.repository(:alternate){ QuanTum::Cat.create(:name => "george", :is_dead => false) }
+          gerry.to_csv.should_not match(/false/)
+          george.to_csv.should 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 '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 = [
+      Hash[ keys.zip([  1,  2, 'Betsy', 'Jersey'   ]) ],
+      Hash[ keys.zip([ 10, 20, 'Berta', 'Guernsey' ]) ],
+    ]
+
+    @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_should_behave_like "A serialization method"
+  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]))
+    betsy = deserialized_collection.first
+    berta = deserialized_collection.last
+
+    betsy["id"].should be_nil
+    betsy["composite"].should == 2
+    betsy["name"].should be_nil
+    betsy["breed"].should be_nil
+
+    berta["id"].should be_nil
+    berta["composite"].should == 20
+    berta["name"].should be_nil
+    berta["breed"].should 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 }
+    JSON.parse(hash.to_json).should == hash
+  end
+
+end
+
+describe DataMapper::Serializer, '#as_json' do
+  it "handles nil for options" do
+    expect { Cow.new.as_json(nil) }.to_not raise_error
+  end
+
+  it "serializes Discriminator types as strings" do
+    Motorcycle.new.as_json[:type].should == "Motorcycle"
+  end
+end

data/spec/public/to_xml_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'rexml/document'
+
+[: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) {
+        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
+
+        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 && ["integer", "datamapper::types::serial"].include?(type)
+          value
+        end
+      }.new
+    end
+
+    it_should_behave_like "A serialization method"
+
+    it "should 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")
+      xml.should_not match(/\A<?xml/)
+    end
+
+    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
+
+      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
+
+    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 should be used as the root node name' do
+        xml = DataMapper::Collection.new(@query).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
+        resources = @model.load([ { 'id' => 1 } ], @query)
+        @collection = DataMapper::Collection.new(@query, resources)
+
+        xml = @collection.to_xml(:collection_element_name => "somanycats")
+        REXML::Document.new(xml).elements[1].name.should == "somanycats"
+      end
+
+      it 'should respect :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')
+        REXML::Document.new(xml).elements[1].elements[1].name.should == "cat"
+      end
+    end
+  end
+end

data/spec/public/to_yaml_spec.rb

@@ -0,0 +1,59 @@
+require '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_should_behave_like 'A serialization method'
+  it_should_behave_like 'A serialization method that also serializes core classes'
+
+  it 'should allow static YAML dumping' do
+    object = Cow.create(
+      :id        => 89,
+      :composite => 34,
+      :name      => 'Berta',
+      :breed     => 'Guernsey'
+    )
+    result = @harness.deserialize(YAML.dump(object))
+    result['name'].should == 'Berta'
+  end
+
+  it 'should allow static YAML dumping of a collection' do
+    object = Cow.create(
+      :id        => 89,
+      :composite => 34,
+      :name      => 'Berta',
+      :breed     => 'Guernsey'
+    )
+    result = @harness.deserialize(YAML.dump(Cow.all))
+    result[0]['name'].should == 'Berta'
+  end
+
+end

data/spec/rcov.opts

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

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--loadby random
+--format profile
+--backtrace

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
+
+Spec::Runner.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+end

data/tasks/spec.rake

@@ -0,0 +1,38 @@
+spec_defaults = lambda do |spec|
+  spec.pattern    = 'spec/**/*_spec.rb'
+  spec.libs      << 'lib' << 'spec'
+  spec.spec_opts << '--options' << 'spec/spec.opts'
+end
+
+begin
+  require 'spec/rake/spectask'
+
+  Spec::Rake::SpecTask.new(:spec, &spec_defaults)
+rescue LoadError
+  task :spec do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+end
+
+begin
+  require 'rcov'
+  require 'spec/rake/verify_rcov'
+
+  Spec::Rake::SpecTask.new(:rcov) do |rcov|
+    spec_defaults.call(rcov)
+    rcov.rcov      = true
+    rcov.rcov_opts = File.read('spec/rcov.opts').split(/\s+/)
+  end
+
+  RCov::VerifyTask.new(:verify_rcov => :rcov) do |rcov|
+    rcov.threshold = 100
+  end
+rescue LoadError
+  %w[ rcov verify_rcov ].each do |name|
+    task name do
+      abort "rcov is not available. In order to run #{name}, you must: gem install rcov"
+    end
+  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

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: ardm-serializer
+version: !ruby/object:Gem::Version
+  version: 1.2.2
+platform: ruby
+authors:
+- Martin Emde
+- Guy van den Berg
+- Dan Kubb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ardm-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: fastercsv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: DataMapper plugin for serializing Resources and Collections
+email:
+- me@martinemde.com
+- dan.kubb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- ardm-serializer.gemspec
+- benchmarks/to_json.rb
+- benchmarks/to_xml.rb
+- lib/ardm-serializer.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.rb
+- lib/dm-serializer/xml/libxml.rb
+- lib/dm-serializer/xml/nokogiri.rb
+- lib/dm-serializer/xml/rexml.rb
+- spec/fixtures/cow.rb
+- spec/fixtures/planet.rb
+- spec/fixtures/quan_tum_cat.rb
+- spec/fixtures/vehicle.rb
+- spec/lib/serialization_method_shared_spec.rb
+- spec/public/serializer_spec.rb
+- spec/public/to_csv_spec.rb
+- spec/public/to_json_spec.rb
+- spec/public/to_xml_spec.rb
+- spec/public/to_yaml_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/spec.rake
+- tasks/yard.rake
+- tasks/yardstick.rake
+homepage: https://github.com/ar-dm/ardm-serializer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ardm fork of dm-serializer
+test_files: []
+has_rdoc: