representable 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7190988a0107b8fdf04b353f9e4ce2839edbc63
-  data.tar.gz: 4822a18cbbccd0b1953d24223dba3adcbfc7bd43
+  metadata.gz: 04ca3309b8af78dd1eaa8b4d47c457323180a881
+  data.tar.gz: c7d43dc372fc53576a6b64f22d3fc0bd1bff5a4e
 SHA512:
-  metadata.gz: 6f58b1085876a04fc2ebeb076d94323b1ad45039cfb987693ebc9ddd957bdb367c02b5b64792e570981fe549eafae4c5390886613992187f5106b1d380c079ab
-  data.tar.gz: db17d2feb4dfe80e37c2a3934218ef6101478fa1c4ab167cd9876710de4a9a30c8798a8914f9f9ff95cdf6642c7fbe8b650ae8d46855f642e364c1badeb88bf4
+  metadata.gz: 528696ff8d8eae7b409566d9831a0117a90a361fdabe5a0345d0e5accac5cfbb2f3bfae5a34589000b5bdbf2632f7951356861215d210172c602b581694e68dc
+  data.tar.gz: 4d7409a62a9a25d31fc1c67d20e2b32b9cd0a1d8e9987b2cbe118bd4e069fe271dd82127f3e7656b92f01e8f1266524965def4089e439b4a1eac370e13a06bff

data/.travis.yml

@@ -11,4 +11,6 @@ rvm:
 matrix:
   include:
   - rvm: jruby-9.1.5.0
-    env: JRUBY_OPTS="--profile.api"
+    env: JRUBY_OPTS="--profile.api"
+  allow_failures:
+  - rvm: jruby-9.1.5.0

data/CHANGES.md

@@ -1,3 +1,8 @@
+# 3.0.4
+
+* Add proper XML namespace support.
+* [internal] Replace `XML::Binding#node_for` with function `XML::Node`.
+
 # 3.0.3
 
 * Replace `Uber::Option` with the new [`Declarative::Option`](https://github.com/apotonick/declarative-option). This should result in a significant performance boost.

data/README.md

@@ -5,7 +5,7 @@ Representable maps Ruby objects to documents and back.
 [![Gitter Chat](https://badges.gitter.im/trailblazer/chat.svg)](https://gitter.im/trailblazer/chat)
 [![TRB Newsletter](https://img.shields.io/badge/TRB-newsletter-lightgrey.svg)](http://trailblazer.to/newsletter/)
 [![Build
-Status](https://travis-ci.org/apotonick/representable.svg)](https://travis-ci.org/apotonick/representable)
+Status](https://travis-ci.org/trailblazer/representable.svg)](https://travis-ci.org/trailblazer/representable)
 [![Gem Version](https://badge.fury.io/rb/representable.svg)](http://badge.fury.io/rb/representable)
 
 In other words: Take an object and decorate it with a representer module. This will allow you to render a JSON, XML or YAML document from that object. But that's only half of it! You can also use representers to parse a document and create or populate an object.

data/TODO

@@ -1,8 +1,6 @@
 * Pass key/index as first block arg to :class and :extend
 class: |key, hsh|
 
-* Allow passing options to Binding#serialize.
-	serialize(.., options{:exclude => ..})
 
 document `XML::AttributeHash` etc
 
@@ -37,4 +35,4 @@ module ReaderWriter
 * DISCUSS: should inline representers be created at runtime, so we don't need ::representer_engine?
 * deprecate `Decorator::Coercion`.
 
-* cleanup XML so it matches the current #serialize standard.
+* cleanup XML so it matches the current #serialize standard.

data/TODO-4.0.md

@@ -0,0 +1,72 @@
+# Decorator
+
+  XML::Binding::Collection.to_xml(represented)
+    bindings.each bin.to_xml
+
+
+  # hat vorteil: [].each{ Collection.to_xml(item) }
+
+* make all properties "Object-like", even arrays of strings etc. This saves us from having `extend ObjectBinding if typed?` and we could just call to_hash/from_hash on all attributes. performance issues here? otherwise: implement!
+
+
+# how to?
+
+class CH
+  wrap :character
+  prpoerty :a
+
+
+class
+  proerty :author, dec: CH
+
+# how to?
+
+* override specific bindings and their logic? e.g. `Namespace#read`
+* Extend nested representers, e.g. the namespace prefix, when it gets plugged into composition
+* Easier polymorphic representer
+
+# XML
+
+* ditch annoying nokogiri in favor of https://github.com/YorickPeterse/oga
+
+# Parsing
+
+* Let bindings have any "xpath"
+* Allow to parse "wildcard" sections where you have no idea about the property names (and attribute names, eg. with links)
+
+# Options
+
+* There should be an easier way to pass a set of options to all nested #to_node decorators.
+
+```ruby
+representable_attrs.keys.each do |property|
+  options[property.to_sym] = { show_definition: false, namespaces: options[:namespaces] }
+end
+```
+
+* Allow passing options to Binding#serialize.
+  serialize(.., options{:exclude => ..})
+
+
+# wrap, as
+
+AsWithNamespace( Binding )
+   BUT NOT FOR AsWithNamespace( Binding::Attribute )
+  => selectively wrap bindings at compile- and runtime
+
+
+
+
+
+
+* Cleanup the manifest part in Decorator.
+
+* all property objects should be extended/wrapped so we don't need the switch.
+
+# Deprecations
+
+* deprecate instance: { nil } which is superseded by parse_strategy: :sync
+
+
+
+from_hash, property :band, class: vergessen

data/lib/representable/declarative.rb

@@ -47,10 +47,10 @@ module Representable
     NestedBuilder = ->(options) do
       Module.new do
         include Representable # FIXME: do we really need this?
-        feature *options[:_features]
-        include *options[:_base] # base when :inherit, or in decorator.
+        feature(*options[:_features])
+        include(*options[:_base]) # base when :inherit, or in decorator.
 
-        module_eval &options[:_block]
+        module_eval(&options[:_block])
       end
     end
 

data/lib/representable/deserializer.rb

@@ -96,7 +96,7 @@ module Representable
   If = ->(input, options) { options[:binding].evaluate_option(:if, nil, options) ? input : Pipeline::Stop }
 
   StopOnExcluded = ->(input, options) do
-    return input unless private = options[:options]
+    return input unless options[:options]
     return input unless props = (options[:options][:exclude] || options[:options][:include])
 
     res = props.include?(options[:binding].name.to_sym) # false with include: Stop. false with exclude: go!

data/lib/representable/serializer.rb

@@ -51,4 +51,4 @@ module Representable
   # Warning: don't rely on AssignAs/AssignName, i am not sure if i leave that as functions.
   AssignAs   = ->(input, options) { options[:as] = As.(input, options); input }
   AssignName = ->(input, options) { options[:as] = options[:binding].name; input }
-end
+end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "3.0.3"
+  VERSION = "3.0.4"
 end

data/lib/representable/xml.rb

@@ -1,6 +1,4 @@
 require 'representable'
-require 'representable/xml/binding'
-require 'representable/xml/collection'
 
 begin
   require 'nokogiri'
@@ -46,10 +44,10 @@ module Representable
 
     # Returns a Nokogiri::XML object representing this object.
     def to_node(options={})
-      options[:doc] ||= Nokogiri::XML::Document.new
+      options[:doc] = Nokogiri::XML::Document.new # DISCUSS: why do we need a fresh Document here?
       root_tag = options[:wrap] || representation_wrap(options)
 
-      create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, options[:doc]), options, Binding)
+      create_representation_with(Node(options[:doc], root_tag.to_s), options, Binding)
     end
 
     def to_xml(*args)
@@ -73,3 +71,7 @@ module Representable
     end
   end
 end
+
+require "representable/xml/binding"
+require "representable/xml/collection"
+require "representable/xml/namespace"

data/lib/representable/xml/binding.rb

@@ -3,6 +3,14 @@ require 'representable/hash/binding.rb'
 
 module Representable
   module XML
+    module_function
+    def Node(document, name, attributes={})
+      node = Nokogiri::XML::Node.new(name.to_s, document) # Java::OrgW3cDom::DOMException: NAMESPACE_ERR: An attempt is made to create or change an object in a way which is incorrect with regard to namespaces.
+
+      attributes.each { |k, v| node[k] = v } # TODO: benchmark.
+      node
+    end
+
     class Binding < Representable::Binding
       def self.build_for(definition)
         return Collection.new(definition)      if definition.array?
@@ -17,7 +25,7 @@ module Representable
         wrap_node = parent
 
         if wrap = self[:wrap]
-          parent << wrap_node = node_for(parent, wrap)
+          parent << wrap_node = XML::Node(parent, wrap)
         end
 
         wrap_node << serialize_for(fragments, parent, as)
@@ -32,12 +40,15 @@ module Representable
 
       # Creates wrapped node for the property.
       def serialize_for(value, parent, as)
-        node = node_for(parent, as)
-        serialize_node(node, value)
+        node = XML::Node(parent, as) # node doesn't have attr="" attributes!!!
+        serialize_node(node, value, as)
       end
 
-      def serialize_node(node, value)
-        return value if typed?
+      def serialize_node(node, value, as)
+        if typed?
+          value.name = as if as != self[:name]
+          return value
+        end
 
         node.content = value
         node
@@ -60,11 +71,7 @@ module Representable
       def find_nodes(doc, as)
         selector  = as
         selector  = "#{self[:wrap]}/#{as}" if self[:wrap]
-        nodes     = doc.xpath(selector)
-      end
-
-      def node_for(parent, name)
-        Nokogiri::XML::Node.new(name.to_s, parent.document)
+        doc.xpath(selector) # nodes
       end
 
       def content_for(node) # TODO: move this into a ScalarDecorator.
@@ -100,8 +107,8 @@ module Representable
       class Hash < Collection
         def serialize_for(value, parent, as)
           set_for(parent, value.collect do |k, v|
-            node = node_for(parent, k)
-            serialize_node(node, v)
+            node = XML::Node(parent, k)
+            serialize_node(node, v, as)
           end)
         end
 

data/lib/representable/xml/namespace.rb

@@ -0,0 +1,122 @@
+module Representable::XML
+  # Experimental!
+  # Best explanation so far: http://books.xmlschemata.org/relaxng/relax-CHP-11-SECT-1.html
+  #
+  # Note: This module doesn't work with JRuby because Nokogiri uses a completely
+  # different implementation in Java which has other requirements that we couldn't fulfil.
+  # Please wait for Representable 4 where we replace Nokogiri with Oga.
+  module Namespace
+    def self.included(includer)
+      includer.extend(DSL)
+    end
+
+    module DSL
+      def namespace(namespace)
+        representable_attrs.options[:local_namespace] = namespace
+        representable_attrs.options[:namespace_mappings] ||= {}
+        representable_attrs.options[:namespace_mappings][namespace] = nil # this might get overwritten via #namespace_def later.
+      end
+
+      def namespace_def(mapping)
+        namespace_defs.merge!(mapping.invert)
+      end
+
+      # :private:
+      def namespace_defs
+        representable_attrs.options[:namespace_mappings] ||= {}
+      end
+
+      def property(name, options={})
+        uri = representable_attrs.options[:local_namespace] # per default, a property belongs to the local namespace.
+        options[:namespace] ||= uri # don't override if already set.
+
+        # a nested representer is automatically assigned "its" local namespace. It's like saying
+        #   property :author, namespace: "http://ns/author" do ... end
+
+        super.tap do |dfn|
+          if dfn.typed? # FIXME: ouch, this should be doable with property's API to hook into the creation process.
+            dfn.merge!( namespace: dfn.representer_module.representable_attrs.options[:local_namespace] )
+
+            update_namespace_defs!(namespace_defs)
+          end
+        end
+      end
+
+      # :private:
+      # super ugly hack
+      # recursively injects the namespace_defs into all representers of this tree. will be done better in 4.0.
+      def update_namespace_defs!(namespace_defs)
+        representable_attrs.each do |dfn|
+          dfn.merge!(namespace_defs: namespace_defs) # this only helps with scalars
+
+          if dfn.typed?
+            representer = Class.new(dfn.representer_module) # don't pollute classes.
+            representer.update_namespace_defs!(namespace_defs)
+            dfn.merge!(extend: representer)
+          end
+        end
+      end
+    end
+
+    module AsWithNamespace
+      def write(doc, fragment, as)
+        super(doc, fragment, prefixed(self, as))
+      end
+
+      # FIXME: this is shit, the NestedOptions is executed too late here!
+      def read(node, as)
+        super(node, prefixed(self, as))
+      end
+
+      private
+      def prefixed(dfn, as)
+        uri    = dfn[:namespace] # this is generic behavior and per property
+        prefix = dfn[:namespace_defs][uri]
+        as     = Namespace::Namespaced(prefix, as)
+      end
+    end
+
+  # FIXME: some "bug" in Representable's XML doesn't consider the container tag, so we could theoretically pick the
+  # wrong namespaced tag here :O
+    def from_node(node, options={})
+      super
+    end
+
+    def to_node(options={})
+      local_uri = representable_attrs.options[:local_namespace] # every decorator MUST have a local namespace.
+      prefix    = self.class.namespace_defs[local_uri]
+
+      root_tag = [prefix, representation_wrap(options)].compact.join(":")
+
+      options = { wrap: root_tag }.merge(options)
+
+      # TODO: there should be an easier way to pass a set of options to all nested #to_node decorators.
+      representable_attrs.keys.each do |property|
+        options[property.to_sym] = { show_definition: false, namespaces: options[:namespaces] }
+      end
+
+      super(options).tap do |node|
+        add_namespace_definitions!(node, self.class.namespace_defs) unless options[:show_definition] == false
+      end
+    end
+
+    # "Physically" add `xmlns` attributes to `node`.
+    def add_namespace_definitions!(node, namespaces)
+      namespaces.each do |uri, prefix|
+        prefix = prefix.nil? ? nil : prefix.to_s
+        node.add_namespace_definition(prefix, uri)
+      end
+    end
+
+    def self.Namespaced(prefix, name)
+      [ prefix, name ].compact.join(":")
+    end
+
+    # FIXME: this is a PoC, we need a better API to inject code.
+    def representable_map(options, format)
+      super.tap do |map|
+        map.each { |bin| bin.extend(AsWithNamespace) unless bin.is_a?(Binding::Attribute) }
+      end
+    end
+  end
+end

data/representable.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.platform    = Gem::Platform::RUBY
   spec.authors     = ["Nick Sutterer"]
   spec.email       = ["apotonick@gmail.com"]
-  spec.homepage    = "https://github.com/apotonick/representable/"
+  spec.homepage    = "https://github.com/trailblazer/representable/"
   spec.summary     = %q{Renders and parses JSON/XML/YAML documents from and to Ruby objects. Includes plain properties, collections, nesting, coercion and more.}
   spec.description = spec.summary
 
@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "declarative-option", "< 0.2.0"
 
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "test_xml", "0.1.6"
+  spec.add_development_dependency "test_xml", ">= 0.1.6"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "virtus"
   spec.add_development_dependency "multi_json"

data/test/as_test.rb

@@ -7,8 +7,8 @@ class AsTest < MiniTest::Spec
     # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
   ) do |format, mod, input, output|
 
-    let (:song) { representer.prepare(Song.new("Revolution")) }
-    let (:format) { format }
+    let(:song) { representer.prepare(Song.new("Revolution")) }
+    let(:format) { format }
 
 
     describe "as: with :symbol" do

data/test/binding_test.rb

@@ -2,10 +2,10 @@ require 'test_helper'
 
 class BindingTest < MiniTest::Spec
   Binding = Representable::Binding
-  let (:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
+  let(:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
 
   describe "#skipable_empty_value?" do
-    let (:binding) { Binding.new(render_nil_definition) }
+    let(:binding) { Binding.new(render_nil_definition) }
 
     # don't skip when present.
     it { binding.skipable_empty_value?("Disconnect, Disconnect").must_equal false }
@@ -22,8 +22,8 @@ class BindingTest < MiniTest::Spec
 
 
   describe "#default_for" do
-    let (:definition) { Representable::Definition.new(:song, :default => "Insider") }
-    let (:binding) { Binding.new(definition) }
+    let(:definition) { Representable::Definition.new(:song, :default => "Insider") }
+    let(:binding) { Binding.new(definition) }
 
     # return value when value present.
     it { binding.default_for("Black And Blue").must_equal "Black And Blue" }
@@ -35,12 +35,12 @@ class BindingTest < MiniTest::Spec
     it { binding.default_for(nil).must_equal "Insider" }
 
     # return nil when value nil and render_nil: true.
-    it { Binding.new(render_nil_definition).default_for(nil).must_equal nil }
+    it { Binding.new(render_nil_definition).default_for(nil).must_be_nil }
 
     # return nil when value nil and render_nil: true, even when :default is set" do
-    it { Binding.new(Representable::Definition.new(:song, :render_nil => true, :default => "The Quest")).default_for(nil).must_equal nil }
+    it { Binding.new(Representable::Definition.new(:song, :render_nil => true, :default => "The Quest")).default_for(nil).must_be_nil }
 
     # return nil if no :default
-    it { Binding.new(Representable::Definition.new(:song)).default_for(nil).must_equal nil }
+    it { Binding.new(Representable::Definition.new(:song)).default_for(nil).must_be_nil }
   end
 end