ardm-serializer 1.2.2

data/lib/ardm-serializer.rb

@@ -0,0 +1 @@
+require 'dm-serializer'

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/lib/dm-serializer/common.rb

@@ -0,0 +1,28 @@
+require 'dm-core'
+
+module DataMapper
+  module Serializer
+
+    # Returns propreties to serialize based on :only or :exclude arrays,
+    # if provided :only takes precendence 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.has_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.has_key? :writer
+
+          CSV.generate(options[:writer]) do |csv|
+            errors.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,103 @@
+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.kind_of?(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
+      if options[:relationships]
+        options[:relationships].each do |relationship_name, opts|
+          if respond_to?(relationship_name)
+            result[relationship_name] = __send__(relationship_name).to_json(opts.merge(:to_json => false))
+          end
+        end
+      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.kind_of?(Hash)
+
+      result = as_json(options)
+
+      # default to making JSON
+      if options.fetch(:to_json, true)
+        MultiJson.encode(result)
+      else
+        result
+      end
+    end
+
+    module ValidationErrors
+      module ToJson
+        def to_json(*args)
+          MultiJson.encode(Hash[ errors ])
+        end
+      end
+    end
+
+  end
+
+  class Collection
+    def to_json(*args)
+      options = args.first
+      options = {} unless options.kind_of?(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.encode(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,126 @@
+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 = {}
+
+        unless property.primitive == String
+          attrs['type'] = property.primitive.to_s.downcase
+        end
+
+        xml.add_node(root, property.name.to_s, value, attrs)
+      end
+
+      Array(opts[:methods]).each do |meth|
+        if self.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
+      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'})
+
+          errors.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(self.model.to_s)).tr("/", "-")
+      }
+
+      root = xml.root_node(
+        doc,
+        opts[:collection_element_name] || default_collection_element_name[],
+        {'type' => 'array'}
+      )
+
+      self.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

data/lib/dm-serializer/to_yaml.rb

@@ -0,0 +1,160 @@
+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
+    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.kind_of?(Hash) ? options : {})
+        end
+      end
+    end unless YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
+
+    # 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 { |property| property.name }
+      methods.concat Array(options[:methods])
+
+      methods.each do |method|
+        coder.add(method.to_s, __send__(method))
+      end
+    end
+
+  private
+
+    # Return the YAML type to use for the output
+    #
+    # @return [String]
+    #
+    # @api private
+    def to_yaml_type
+      "!#{TAG_NAME}:#{model.name}"
+    end
+
+    # Return the YAML style to use for the output
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def to_yaml_style
+      Psych::Nodes::Mapping::ANY
+    end if YAML.const_defined?(:ENGINE) && YAML::ENGINE.yamler == 'psych'
+
+    module ValidationErrors
+      module ToYaml
+
+        # Serialize the errors to YAML
+        #
+        # @example
+        #   yaml = errors.to_yaml  # => a valid YAML string
+        #
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_yaml(*args)
+          Hash[errors].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 = Hash[errors]
+        end
+
+      end # module ToYaml
+    end # module ValidationErrors
+
+    module Collection
+      module ToYaml
+
+        # Serialize the collection to YAML
+        #
+        # @example
+        #   yaml = collection.to_yaml  # => a valid YAML string
+        #
+        # @param [Hash] options
+        #
+        # @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 # module ToYaml
+    end # module Collection
+  end # module Serializer
+
+  class Collection
+    include Serializer::Collection::ToYaml
+  end # class Collection
+
+  if const_defined?(:Validations)
+    module Validations
+      class ValidationErrors
+        include DataMapper::Serializer::ValidationErrors::ToYaml
+      end # class ValidationErrors
+    end # module Validations
+  end
+
+end # module DataMapper