sbf-dm-serializer 1.3.0.beta

data/lib/dm-serializer/to_yaml.rb

@@ -0,0 +1,157 @@
+require 'dm-serializer/common'
+
+module DataMapper
+  module Serializer
+    TAG_NAME = "ruby/DataMapper,#{DataMapper::VERSION}".freeze
+
+    # Include a callback to register the YAML output
+    #
+    # @param [DataMapper::Model] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.included(descendant)
+      YAML.add_domain_type(TAG_NAME, descendant.name) do |_tag, values|
+        values
+      end
+    end
+
+    # Serialize a Resource to YAML
+    #
+    # @example
+    #   yaml = resource.to_yaml  # => a valid YAML string
+    #
+    # @param [Hash] options
+    #
+    # @return [String]
+    #
+    # @api public
+    unless YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
+      def to_yaml(options = {})
+        YAML.quick_emit(object_id, options) do |out|
+          out.map(to_yaml_type, to_yaml_style) do |map|
+            encode_with(map, options.is_a?(Hash) ? options : {})
+          end
+        end
+      end
+    end
+
+    # A callback to encode the resource in the YAML stream
+    #
+    # @param [#add] coder
+    #   handles adding the values to the output
+    #
+    # @param [Hash] options
+    #   optional Hash configuring the output
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def encode_with(coder, options = {})
+      coder.tag   = to_yaml_type  if coder.respond_to?(:tag=)
+      coder.style = to_yaml_style if coder.respond_to?(:style=)
+
+      methods = []
+
+      methods.concat(properties_to_serialize(options).map(&:name))
+      methods.concat Array(options[:methods])
+
+      methods.each do |method|
+        coder.add(method.to_s, __send__(method))
+      end
+    end
+
+    # Return the YAML type to use for the output
+    #
+    # @return [String]
+    #
+    # @api private
+    private def to_yaml_type
+      "!#{TAG_NAME}:#{model.name}"
+    end
+
+    # Return the YAML style to use for the output
+    #
+    # @return [Integer]
+    #
+    # @api private
+    if YAML.const_defined?(:ENGINE) && YAML::ENGINE.yamler == 'psych'
+      def to_yaml_style
+        Psych::Nodes::Mapping::ANY
+      end
+    end
+
+    module ValidationErrors
+      module ToYaml
+        # Serialize the errors to YAML
+        #
+        # @example
+        #   yaml = errors.to_yaml  # => a valid YAML string
+        #
+        # @param [Hash] args
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_yaml(*args)
+          violations.to_h.to_yaml(*args)
+        end
+
+        # A callback to encode the errors in the YAML stream
+        #
+        # @param [#add] coder
+        #   handles adding the values to the output
+        #
+        # @return [undefined]
+        #
+        # @api public
+        def encode_with(coder)
+          coder.map = errors.to_h
+        end
+      end
+    end
+
+    module Collection
+      module ToYaml
+        # Serialize the collection to YAML
+        #
+        # @example
+        #   yaml = collection.to_yaml  # => a valid YAML string
+        #
+        # @param [Hash] args
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_yaml(*args)
+          to_a.to_yaml(*args)
+        end
+
+        # A callback to encode the collection in the YAML stream
+        #
+        # @param [#add] coder
+        #   handles adding the values to the output
+        #
+        # @return [undefined]
+        #
+        # @api public
+        def encode_with(coder)
+          coder.seq = to_a
+        end
+      end
+    end
+  end
+
+  class Collection
+    include Serializer::Collection::ToYaml
+  end
+
+  if const_defined?(:Validations)
+    module Validations
+      class ValidationErrors
+        include DataMapper::Serializer::ValidationErrors::ToYaml
+      end
+    end
+  end
+end

data/lib/dm-serializer/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Serializer
+    VERSION = '1.3.0.beta'.freeze
+  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/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'
+      }.freeze
+
+      #
+      # 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
+
+      %i(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.rb

@@ -0,0 +1,14 @@
+require 'dm-serializer/to_json'
+require 'dm-serializer/to_xml'
+require 'dm-serializer/to_yaml'
+require 'dm-serializer/to_csv'
+
+module DataMapper
+  # Define the `Serialize` constant for backwards compatibility.
+  #
+  # @note
+  #   The `Serialize` constant will be removed soon, please use
+  #   {Serializer} instead.
+  #
+  Serialize = Serializer
+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: %i(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