representable 3.0.0 → 3.2.0

data/lib/representable/hash/allow_symbols.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Representable
   module Hash
     module AllowSymbols
-    private
+      private
+
       def filter_wrap_for(data, *args)
         super(Conversion.stringify_keys(data), *args)
       end
@@ -11,17 +14,12 @@ module Representable
       end
     end
 
-    class Conversion
-      # DISCUSS: we could think about mixin in IndifferentAccess here (either hashie or ActiveSupport).
-      # or decorating the hash.
+    module Conversion
       def self.stringify_keys(hash)
-        hash = hash.dup
-
-        hash.keys.each do |k|
-          hash[k.to_s] = hash.delete(k)
-        end
-        hash
+        hash.keys.collect do |key|
+          [ key.to_s, hash[key] ]
+        end.to_h
       end
     end
   end
-end
+end

data/lib/representable/hash/binding.rb

@@ -5,6 +5,7 @@ module Representable
     class Binding < Representable::Binding
       def self.build_for(definition)
         return Collection.new(definition) if definition.array?
+
         new(definition)
       end
 

data/lib/representable/hash/collection.rb

@@ -1,3 +1,5 @@
+require 'representable/hash'
+
 module Representable::Hash
   module Collection
     include Representable::Hash
@@ -20,7 +22,7 @@ module Representable::Hash
     # TODO: revise lonely collection and build separate pipeline where we just use Serialize, etc.
 
     def create_representation_with(doc, options, format)
-      options = normalize_options(options)
+      options = normalize_options(**options)
       options[:_self] = options
 
       bin   = representable_bindings_for(format, options).first
@@ -30,7 +32,7 @@ module Representable::Hash
     end
 
     def update_properties_from(doc, options, format)
-      options = normalize_options(options)
+      options = normalize_options(**options)
       options[:_self] = options
 
       bin   = representable_bindings_for(format, options).first

data/lib/representable/hash.rb

@@ -6,6 +6,9 @@ module Representable
   # If you plan to write your own representer for a new media type, try to use this module (e.g., check how JSON reuses Hash's internal
   # architecture).
   module Hash
+    autoload :Collection, 'representable/hash/collection'
+    autoload :AllowSymbols, 'representable/hash/allow_symbols'
+
     def self.included(base)
       base.class_eval do
         include Representable # either in Hero or HeroRepresentation.
@@ -34,15 +37,19 @@ module Representable
       hash = create_representation_with({}, options, binding_builder)
 
       return hash if options[:wrap] == false
-      return hash unless wrap = options[:wrap] || representation_wrap(options)
+      return hash unless (wrap = options[:wrap] || representation_wrap(options))
 
       {wrap => hash}
     end
 
+    alias_method :render, :to_hash
+    alias_method :parse, :from_hash
+
   private
     def filter_wrap(data, options)
       return data if options[:wrap] == false
-      return data unless wrap = options[:wrap] || representation_wrap(options)
+      return data unless (wrap = options[:wrap] || representation_wrap(options))
+
       filter_wrap_for(data, wrap)
     end
 

data/lib/representable/hash_methods.rb

@@ -20,8 +20,9 @@ module Representable
     def filter_keys_for!(hash, options)
       excluding = options[:exclude]
       # TODO: use same filtering method as in normal representer in Representable#create_representation_with.
-      return hash unless props = options.delete(:exclude) || options.delete(:include)
-      hash.reject { |k,v| excluding ? props.include?(k.to_sym) : !props.include?(k.to_sym) }
+      return hash unless (props = (options.delete(:exclude) || options.delete(:include)))
+
+      hash.select { |k, _v| excluding ? !props.include?(k.to_sym) : props.include?(k.to_sym) }
     end
   end
 end

data/lib/representable/insert.rb

@@ -35,4 +35,4 @@ module Representable
 
     Insert = Pipeline::Function::Insert.new
   end # Pipeline
-end
+end

data/lib/representable/json/collection.rb

@@ -1,3 +1,6 @@
+require 'representable/json'
+require 'representable/hash/collection'
+
 module Representable::JSON
   module Collection
     include Representable::JSON

data/lib/representable/json.rb

@@ -1,15 +1,13 @@
-require "representable/hash"
-require "representable/json/collection"
+gem "multi_json", '>= 1.14.1'
+require "multi_json"
 
-begin
-  require "multi_json"
-rescue LoadError => _
-  abort "Missing dependency 'multi_json' for Representable::JSON. See dependencies section in README.md for details."
-end
+require "representable"
 
 module Representable
   # Brings #to_json and #from_json to your object.
   module JSON
+    autoload :Collection, "representable/json/collection"
+
     extend Hash::ClassMethods
     include Hash
 
@@ -43,5 +41,8 @@ module Representable
     def to_json(*args)
       MultiJson.dump to_hash(*args)
     end
+
+    alias_method :render, :to_json
+    alias_method :parse, :from_json
   end
 end

data/lib/representable/object/binding.rb

@@ -1,8 +1,11 @@
+require 'representable/binding'
+
 module Representable
   module Object
     class Binding < Representable::Binding
       def self.build_for(definition)  # TODO: remove default arg.
         return Collection.new(definition)  if definition.array?
+
         new(definition)
       end
 
@@ -10,6 +13,7 @@ module Representable
         fragment = hash.send(as) # :getter? no, that's for parsing!
 
         return FragmentNotFound if fragment.nil? and typed?
+
         fragment
       end
 
@@ -31,4 +35,4 @@ module Representable
       end
     end
   end
-end
+end

data/lib/representable/object.rb

@@ -26,4 +26,4 @@ module Representable
       create_representation_with(nil, options, binding_builder)
     end
   end
-end
+end

data/lib/representable/option.rb

@@ -0,0 +1,19 @@
+require "trailblazer/option"
+
+module Representable
+  # Extend `Trailblazer::Option` to support static values as callables too.
+  class Option < ::Trailblazer::Option
+    def self.callable?(value)
+      [Proc, Symbol, Uber::Callable].any?{ |kind| value.is_a?(kind) }
+    end
+
+    def self.build(value)
+      return ->(*) { value } unless callable?(value) # Wrap static `value` into a proc. 
+      super
+    end
+  end
+
+  def self.Option(value)
+    ::Representable::Option.build(value)
+  end
+end

data/lib/representable/pipeline.rb

@@ -4,11 +4,12 @@ module Representable
   class Pipeline < Array
     Stop = Class.new
 
-    # options is mutuable.
+    # options is mutable.
     def call(input, options)
       inject(input) do |memo, block|
         res = evaluate(block, memo, options)
-        return(Stop)if Stop == res
+        return(Stop) if Stop == res
+
         res
       end
     end

data/lib/representable/pipeline_factories.rb

@@ -2,7 +2,8 @@
 module Representable
   module Binding::Factories
     def pipeline_for(name, input, options)
-      return yield unless proc = @definition[name]
+      return yield unless (proc = @definition[name])
+
       # proc.(self, options)
       instance_exec(input, options, &proc)
     end
@@ -11,6 +12,7 @@ module Representable
     def collect_for(item_functions)
       return [Collect[*item_functions]] if array?
       return [Collect::Hash[*item_functions]] if self[:hash]
+
       item_functions
     end
 
@@ -92,4 +94,4 @@ module Representable
       funcs << (self[:setter] ? Setter : SetValue)
     end
   end
-end
+end

data/lib/representable/populator.rb

@@ -21,7 +21,7 @@ module Representable
     def self.apply!(options)
       return unless populator = options[:populator]
 
-      options[:parse_pipeline] = ->(input, options) do
+      options[:parse_pipeline] = ->(_input, _opts) do
         pipeline = Pipeline[*parse_functions] # TODO: AssignFragment
         pipeline = Pipeline::Insert.(pipeline, SetValue, delete: true) # remove the setter function.
         pipeline = Pipeline::Insert.(pipeline, populator, replace: CreateObject::Populator) # let the actual populator do the job.

data/lib/representable/represent.rb

@@ -1,6 +1,7 @@
 module Representable::Represent
   def represent(represented, array_class=Array)
     return for_collection.prepare(represented) if represented.is_a?(array_class)
+
     prepare(represented)
   end
 end

data/lib/representable/serializer.rb

@@ -3,7 +3,7 @@ module Representable
     options[:binding].evaluate_option(:getter, input, options)
   end
 
-  GetValue = ->(input, options) { options[:binding].send(:exec_context, options).send(options[:binding].getter) }
+  GetValue = ->(_input, options) { options[:binding].send(:exec_context, options).public_send(options[:binding].getter) }
 
   Writer = ->(input, options) do
     options[:binding].evaluate_option(:writer, input, options)
@@ -37,6 +37,7 @@ module Representable
 
   Serialize = ->(input, options) do
     return if input.nil? # DISCUSS: how can we prevent that?
+
     binding, options = options[:binding], options[:options] # FIXME: rename to :local_options.
 
     options_for_nested = OptionsForNested.(options, binding)
@@ -51,4 +52,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.0"
+  VERSION = "3.2.0"
 end

data/lib/representable/xml/binding.rb

@@ -1,8 +1,14 @@
 require 'representable/binding'
-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?
@@ -10,6 +16,7 @@ module Representable
         return AttributeHash.new(definition)   if definition.hash? and definition[:use_attributes]
         return Attribute.new(definition)       if definition[:attribute]
         return Content.new(definition)         if definition[:content]
+
         new(definition)
       end
 
@@ -17,7 +24,7 @@ module Representable
         wrap_node = parent
 
         if wrap = self[:wrap]
-          parent << wrap_node = node_for(parent, wrap)
+          parent << wrap_node = XML::Node(parent.document, wrap)
         end
 
         wrap_node << serialize_for(fragments, parent, as)
@@ -32,12 +39,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.document, 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 +70,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 +106,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.document, 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/lib/representable/xml.rb

@@ -1,15 +1,14 @@
-require 'representable'
-require 'representable/xml/binding'
-require 'representable/xml/collection'
+gem 'nokogiri', '> 1.10.8'
+require 'nokogiri'
 
-begin
-  require 'nokogiri'
-rescue LoadError => _
-  abort "Missing dependency 'nokogiri' for Representable::XML. See dependencies section in README.md for details."
-end
+require 'representable'
 
 module Representable
   module XML
+    autoload :Binding, 'representable/xml/binding'
+    autoload :Collection, 'representable/xml/collection'
+    autoload :Namespace, 'representable/xml/namespace'
+
     def self.included(base)
       base.class_eval do
         include Representable
@@ -46,16 +45,19 @@ 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)
       to_node(*args).to_s
     end
 
+    alias_method :render, :to_xml
+    alias_method :parse, :from_xml
+
   private
     def remove_namespaces?
       # TODO: make local Config easily extendable so you get Config#remove_ns? etc.

data/lib/representable/yaml/binding.rb

@@ -5,6 +5,7 @@ module Representable
     class Binding < Representable::Hash::Binding
       def self.build_for(definition)
         return Collection.new(definition) if definition.array?
+
         new(definition)
       end
 

data/lib/representable/yaml.rb

@@ -1,8 +1,9 @@
-require 'representable/hash'
-require 'representable/yaml/binding'
+require 'psych'
+require 'representable'
 
 module Representable
   module YAML
+    autoload :Binding, 'representable/yaml/binding'
     include Hash
 
     def self.included(base)
@@ -38,5 +39,8 @@ module Representable
       doc.children << to_ast(*args)
       stream.to_yaml
     end
+
+    alias_method :render, :to_yaml
+    alias_method :parse, :from_yaml
   end
 end

data/lib/representable.rb

@@ -1,7 +1,8 @@
 require "uber/delegates"
-
+require "uber/callable"
 require "declarative/schema"
 
+require "representable/option"
 require "representable/config"
 require "representable/definition"
 require "representable/declarative"
@@ -15,6 +16,17 @@ require "representable/for_collection"
 require "representable/represent"
 
 module Representable
+  autoload :Binding, 'representable/binding'
+  autoload :HashMethods, 'representable/hash_methods'
+  autoload :Decorator, 'representable/decorator'
+
+  autoload :Hash, 'representable/hash'
+  autoload :JSON, 'representable/json'
+  autoload :Object, 'representable/object'
+  autoload :YAML, 'representable/yaml'
+  autoload :XML, 'representable/xml'
+
+
   attr_writer :representable_attrs
 
   def self.included(base)
@@ -31,7 +43,7 @@ module Representable
 private
   # Reads values from +doc+ and sets properties accordingly.
   def update_properties_from(doc, options, format)
-    propagated_options = normalize_options(options)
+    propagated_options = normalize_options(**options)
 
     representable_map!(doc, propagated_options, format, :uncompile_fragment)
     represented
@@ -39,25 +51,12 @@ private
 
   # Compiles the document going through all properties.
   def create_representation_with(doc, options, format)
-    propagated_options = normalize_options(options)
+    propagated_options = normalize_options(**options)
 
     representable_map!(doc, propagated_options, format, :compile_fragment)
     doc
   end
 
-  class Binding::Map < Array
-    def call(method, options)
-      each do |bin|
-        options[:binding] = bin # this is so much faster than options.merge().
-        bin.send(method, options)
-      end
-    end
-
-     # TODO: Merge with Definitions.
-    def <<(binding) # can be slow. this is compile time code.
-      (existing = find { |bin| bin.name == binding.name }) ? self[index(existing)] = binding : super(binding)
-    end
-  end
 
   def representable_map(options, format)
     Binding::Map.new(representable_bindings_for(format, options))
@@ -73,9 +72,8 @@ private
     representable_attrs.collect {|definition| format.build(definition) }
   end
 
-  def normalize_options(options)
-    return options if options.any?
-    {user_options: {}}.merge(options) # TODO: use keyword args once we drop 2.0.
+  def normalize_options(user_options: {}, **options)
+    { user_options: user_options }.merge(options)
   end
 
   # Prepares options for a particular nested representer.
@@ -95,8 +93,8 @@ private
     @representable_attrs ||= self.class.definitions
   end
 
-  def representation_wrap(*args)
-    representable_attrs.wrap_for(represented, *args)
+  def representation_wrap(options = {})
+    representable_attrs.wrap_for(represented, options)
   end
 
   def represented
@@ -117,8 +115,4 @@ private
       represented.extend(self)
     end
   end
-
-  # require "representable/deprecations"
 end
-
-require 'representable/autoload'