sbf-dm-serializer 1.3.0.beta

data/benchmarks/to_json.rb

@@ -0,0 +1,137 @@
+require "rubygems"
+require 'pathname'
+require 'better-benchmark'
+
+gem 'dm-core', '1.0.0'
+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:')
+
+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_old(*args)
+      options = args.first || {}
+      result = '{ '
+      fields = []
+
+      propset = properties_to_serialize(options)
+
+      fields += propset.map do |property|
+        "#{property.name.to_json}: #{send(property.name).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
+
+  class Collection
+    def to_json_old(*args)
+      opts = args.first || {}
+      '[' << map { |e| e.to_json_old(opts) }.join(',') << ']'
+    end
+  end
+end
+
+
+
+
+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, :model => 'Cow'
+  belongs_to :mother_cow, :model => 'Cow', :required => false
+end
+
+DataMapper.auto_migrate!
+cow = Cow.create(
+  :id        => 89,
+  :composite => 34,
+  :name      => 'Berta',
+  :breed     => 'Guernsey'
+)
+
+10.times do |n|
+  Cow.create(
+    :id         => n*10,
+    :composite  => n,
+    :name       => "Bertha"*n,
+    :breed      => "Mooing#{n}"
+  )
+end
+
+all_cows = Cow.all.reload
+
+puts "Benchmarking single resource serialization."
+puts "Set 1: old method"
+puts "Set 2: new method"
+result = Benchmark.compare_realtime(
+    :iterations => 10,
+    :inner_iterations => 20000,
+    :verbose => true
+) { |iteration|
+  cow.to_json_old
+}.with { |iteration|
+  cow.to_json
+}
+
+Benchmark.report_on result
+
+puts
+
+puts "Benchmarking collection serialization."
+puts "Set 1: old method"
+puts "Set 2: new method"
+result = Benchmark.compare_realtime(
+    :iterations => 10,
+    :inner_iterations => 5000,
+    :verbose => true
+) { |iteration|
+  all_cows.to_json_old
+}.with { |iteration|
+  all_cows.to_json
+}
+
+Benchmark.report_on result

data/benchmarks/to_xml.rb

@@ -0,0 +1,89 @@
+require "rubygems"
+require 'pathname'
+
+gem 'dm-core', '1.0.0'
+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, :model => 'Cow'
+  belongs_to :mother_cow, :model => '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/dm-serializer.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('../lib/dm-serializer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors     = ['Guy van den Berg', 'Dan Kubb']
+  gem.email       = ['dan.kubb@gmail.com']
+  gem.summary     = 'DataMapper plugin for serializing Resources and Collections'
+  gem.description = 'dm-serializer allows DataMapper models and collections to be serialized to a variety of formats ' \
+                    '(currently JSON, XML, YAML and CSV)'
+  gem.license = 'Nonstandard'
+  gem.homepage = 'https://datamapper.org'
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.extra_rdoc_files = %w(LICENSE README.rdoc)
+
+  gem.name          = 'sbf-dm-serializer'
+  gem.require_paths = ['lib']
+  gem.version       = DataMapper::Serializer::VERSION
+  gem.required_ruby_version = '>= 2.7'
+
+  gem.add_runtime_dependency('sbf-dm-core',    '~> 1.3.0.beta')
+  gem.add_runtime_dependency('fastercsv',  '~> 1.5.4')
+  gem.add_runtime_dependency('multi_json', '~> 1.3.2')
+  gem.add_runtime_dependency('rexml', '~> 3.2')
+end

data/lib/dm-serializer/common.rb

@@ -0,0 +1,27 @@
+require 'dm-core'
+
+module DataMapper
+  module Serializer
+    # Returns properties to serialize based on :only or :exclude arrays,
+    # if provided :only takes precedence 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])
+
+      model.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
+
+  Model.append_inclusions(Serializer)
+end

data/lib/dm-serializer/to_csv.rb

@@ -0,0 +1,71 @@
+require 'dm-serializer/common'
+
+if RUBY_VERSION >= '1.9.0'
+  require 'csv'
+else
+  begin
+    require 'fastercsv'
+    CSV = FasterCSV
+  rescue LoadError
+    # do nothing
+  end
+end
+
+module DataMapper
+  module Serializer
+    # Serialize a Resource to comma-separated values (CSV).
+    #
+    # @return <String> a CSV representation of the Resource
+    def to_csv(*args)
+      options = args.first || {}
+      options = options.to_h if options.respond_to?(:to_h)
+      options[:writer] = '' unless options.key? :writer
+
+      CSV.generate(options[:writer]) do |csv|
+        row = properties_to_serialize(options).map do |property|
+          __send__(property.name).to_s
+        end
+        csv << row
+      end
+    end
+
+    module ValidationErrors
+      module ToCsv
+        def to_csv(*args)
+          options = args.first || {}
+          options = options.to_h if options.respond_to?(:to_h)
+          options[:writer] = '' unless options.key? :writer
+
+          CSV.generate(options[:writer]) do |csv|
+            violations.each do |key, value|
+              value.each do |error|
+                row = []
+                row << key.to_s
+                row << error.to_s
+                csv << row
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class Collection
+    def to_csv(*args)
+      result = ''
+      each do |item|
+        result << ("#{item.to_csv(args.first)}\n")
+      end
+      result
+    end
+  end
+
+  if const_defined?(:Validations)
+    module Validations
+      class ValidationErrors
+        include DataMapper::Serializer::ValidationErrors::ToCsv
+      end
+    end
+  end
+end

data/lib/dm-serializer/to_json.rb

@@ -0,0 +1,99 @@
+require 'dm-serializer/common'
+
+require 'multi_json'
+
+module DataMapper
+  module Serializer
+    #
+    # Converts the resource into a hash of properties.
+    #
+    # @param [Hash] options
+    #   Additional options.
+    #
+    # @return [Hash{String => String}]
+    #   The hash of resources properties.
+    #
+    # @since 1.0.1
+    #
+    def as_json(options = {})
+      options = {} if options.nil?
+      result  = {}
+
+      properties_to_serialize(options).each do |property|
+        property_name = property.name
+        value = __send__(property_name)
+        result[property_name] = value.is_a?(DataMapper::Model) ? value.name : value
+      end
+
+      # add methods
+      Array(options[:methods]).each do |method|
+        next unless respond_to?(method)
+
+        result[method] = __send__(method)
+      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]}})
+      #
+      # TODO: This needs tests and also needs to be ported to #to_xml and
+      # #to_yaml
+      options[:relationships]&.each do |relationship_name, opts|
+        result[relationship_name] = __send__(relationship_name).to_json(opts.merge(to_json: false)) if respond_to?(relationship_name)
+      end
+
+      result
+    end
+
+    # 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
+      options = {} unless options.is_a?(Hash)
+
+      result = as_json(options)
+
+      # default to making JSON
+      if options.fetch(:to_json, true)
+        MultiJson.dump(result)
+      else
+        result
+      end
+    end
+
+    module ValidationErrors
+      module ToJson
+        def to_json(*_args)
+          MultiJson.dump(violations.to_h)
+        end
+      end
+    end
+  end
+
+  class Collection
+    def to_json(*args)
+      options = args.first
+      options = {} unless options.is_a?(Hash)
+
+      resource_options = options.merge(to_json: false)
+      collection = map { |resource| resource.to_json(resource_options) }
+
+      # default to making JSON
+      if options.fetch(:to_json, true)
+        MultiJson.dump(collection)
+      else
+        collection
+      end
+    end
+  end
+
+  if const_defined?(:Validations)
+    module Validations
+      class ValidationErrors
+        include DataMapper::Serializer::ValidationErrors::ToJson
+      end
+    end
+  end
+end

data/lib/dm-serializer/to_xml.rb

@@ -0,0 +1,123 @@
+require 'dm-serializer/common'
+require 'dm-serializer/xml'
+
+module DataMapper
+  module Serializer
+    # Serialize a Resource to XML.
+    #
+    # @return [LibXML::Document, Nokogiri::Document, REXML::Document]
+    #   An XML representation of this Resource.
+    #
+    def to_xml(opts = {})
+      xml = XML.serializer
+      xml.output(to_xml_document(opts)).to_s
+    end
+
+    # 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 = XML.serializer
+      doc ||= xml.new_document
+
+      default_xml_element_name = lambda {
+        DataMapper::Inflector.underscore(model.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 = {}
+
+        dump_class = property.dump_class
+        attrs['type'] = dump_class.to_s.downcase unless dump_class == ::String
+        xml.add_node(root, property.name.to_s, value, attrs)
+      end
+
+      Array(opts[:methods]).each do |meth|
+        next unless respond_to?(meth)
+
+        xml_name = meth.to_s.gsub(/[^a-z0-9_]/, '')
+        value = __send__(meth)
+
+        unless value.nil?
+          if value.respond_to?(:to_xml_document)
+            xml.add_xml(root, value.to_xml_document)
+          else
+            xml.add_node(root, xml_name, value.to_s)
+          end
+        end
+      end
+
+      doc
+    end
+
+    module ValidationErrors
+      module ToXml
+        def to_xml(opts = {})
+          to_xml_document(opts).to_s
+        end
+
+        def to_xml_document(_opts = {})
+          xml = DataMapper::Serializer::XML.serializer
+          doc = xml.new_document
+          root = xml.root_node(doc, 'errors', {'type' => 'hash'})
+
+          violations.each do |key, value|
+            property = xml.add_node(root, key.to_s, nil, {'type' => 'array'})
+            property.attributes['type'] = 'array'
+
+            value.each do |error|
+              xml.add_node(property, 'error', error)
+            end
+          end
+
+          doc
+        end
+      end
+    end
+  end
+
+  class Collection
+    def to_xml(opts = {})
+      to_xml_document(opts).to_s
+    end
+
+    def to_xml_document(opts = {})
+      xml = DataMapper::Serializer::XML.serializer
+      doc = xml.new_document
+
+      default_collection_element_name = lambda {
+        DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(model.to_s)).tr('/', '-')
+      }
+
+      xml.root_node(
+        doc,
+        opts[:collection_element_name] || default_collection_element_name[],
+        {'type' => 'array'}
+      )
+
+      each do |item|
+        item.to_xml_document(opts, doc)
+      end
+
+      doc
+    end
+  end
+
+  if const_defined?(:Validations)
+    module Validations
+      class ValidationErrors
+        include DataMapper::Serializer::ValidationErrors::ToXml
+      end
+    end
+  end
+end