representable 2.3.0 → 2.4.0.rc1

data/lib/representable/apply.rb

@@ -1,13 +0,0 @@
-module Representable
-  module Apply
-    # Iterates over all property/collection definitions and yields the Definition instance.
-    def apply(&block)
-      representable_attrs.each do |dfn|
-        block.call(dfn)
-        dfn.representer_module.extend(Apply).apply(&block) if dfn.representer_module # nested.
-      end
-
-      self
-    end
-  end
-end

data/lib/representable/inheritable.rb

@@ -1,71 +0,0 @@
-module Representable
-  # Objects marked cloneable will be cloned in #inherit!.
-  module Cloneable
-    # Implements recursive cloning for Hash.
-    # Values to clone have to include Cloneable.
-    class Hash < ::Hash
-      include Cloneable # This class is marked as Cloneable itself.
-
-      module Clone
-        def clone
-          self.class[ collect { |k,v| [k, clone_value(v)] } ]
-        end
-
-      private
-        def clone_value(value)
-          return value.clone if value.is_a?(Cloneable)
-          value
-        end
-      end
-      include Clone
-    end
-  end
-
-  # Objects marked cloneable will be inherit!ed in #inherit! when available in parent and child.
-  # TODO: #inherit! will be removed in future versions of Representable in favor of #clone, only. manually merging objects sucks.
-  module Inheritable
-    include Cloneable # all Inheritable are also Cloneable since #clone is one step of our inheritance.
-
-    class Array < ::Array
-      include Inheritable
-
-      def inherit!(parent)
-        push(*parent.clone)
-      end
-    end
-
-    # TODO: remove me.
-    class Hash < ::Hash
-      include Inheritable
-
-      module InstanceMethods
-        # FIXME: this method is currently run exactly once, for representable_attrs.inherit!(parent). it is only used for Config.
-        def inherit!(parent)
-          #merge!(parent.clone)
-          for key in (parent.keys + keys).uniq
-            next unless parent_value = parent[key]
-
-            self[key].inherit!(parent_value) and next if self[key].is_a?(Inheritable)
-            self[key] = parent_value.clone and next if parent_value.is_a?(Cloneable)
-
-            self[key] = parent_value # merge! behaviour
-          end
-
-          self
-        end
-
-        def clone
-          self.class[ collect { |k,v| [k, clone_value(v)] } ]
-        end
-
-      private
-        def clone_value(value)
-          return value.clone if value.is_a?(Cloneable)
-          value
-        end
-      end
-
-      include InstanceMethods
-    end
-  end
-end

data/lib/representable/mapper.rb

@@ -1,83 +0,0 @@
-module Representable
-  # Render and parse by looping over the representer's properties and dispatching to bindings.
-  # Conditionals are handled here, too.
-  class Mapper
-    module Methods
-      def initialize(bindings)
-        @bindings = bindings
-      end
-
-      def bindings(represented, options)
-        @bindings.each do |binding|
-          binding.update!(represented, options)
-        end
-      end
-
-      def deserialize(represented, doc, options, private_options)
-        bindings(represented, options).each do |bin|
-          deserialize_property(bin, doc, options, private_options)
-        end
-        represented
-      end
-
-      def serialize(represented, doc, options, private_options)
-        bindings(represented, options).each do |bin|
-          serialize_property(bin, doc, options, private_options)
-        end
-        doc
-      end
-
-    private
-      def serialize_property(binding, doc, options, private_options)
-        return if skip_property?(binding, private_options.merge(:action => :serialize))
-        compile_fragment(binding, doc)
-      end
-
-      def deserialize_property(binding, doc, options, private_options)
-        return if skip_property?(binding, private_options.merge(:action => :deserialize))
-        uncompile_fragment(binding, doc)
-      end
-
-      # Checks and returns if the property should be included.
-      #   1.78      0.107     0.025     0.000     0.081    30002   Representable::Mapper::Methods#skip_property?
-      #   0.96      0.013     0.013     0.000     0.000    30002   Representable::Mapper::Methods#skip_property? hash only
-      #   1.15      0.025     0.016     0.000     0.009    30002   Representable::Mapper::Methods#skip_property?
-
-      def skip_property?(binding, private_options)
-        return unless private_options[:include] || private_options[:exclude] || binding.skip_filters?
-
-        return true if skip_excluded_property?(binding, private_options)  # no need for further evaluation when :exclude'ed
-        return true if skip_protected_property(binding, private_options)
-
-        skip_conditional_property?(binding)
-      end
-
-      def skip_excluded_property?(binding, private_options)
-        return unless props = private_options[:exclude] || private_options[:include]
-        res   = props.include?(binding.name.to_sym)
-        private_options[:include] ? !res : res
-      end
-
-      def skip_conditional_property?(binding)
-        return unless condition = binding[:if]
-
-        not binding.evaluate_option(:if)
-      end
-
-      # DISCUSS: this could be just another :if option in a Pipeline?
-      def skip_protected_property(binding, private_options)
-        private_options[:action] == :serialize ? binding[:readable] == false : binding[:writeable] == false
-      end
-
-      def compile_fragment(bin, doc)
-        bin.compile_fragment(doc)
-      end
-
-      def uncompile_fragment(bin, doc)
-        bin.uncompile_fragment(doc)
-      end
-    end
-
-    include Methods
-  end
-end

data/lib/representable/populator.rb

@@ -1,56 +0,0 @@
-module Representable
-  #
-  # populator
-      # skip_parse? --> return
-      # deserialize (this is where additional logic can happen, e.g. Object-HAL's collection semantics).
-      # parse_filter
-      # set
-  class Populator # rename to Deserializer?
-    def initialize(binding)
-      @binding = binding
-    end
-
-    # goal of this is to have this workflow apply-able to collections AND to items per collection, or for items in hashes.
-    def call(fragment, doc)
-      # the rest should be applied per item (collection) or per fragment (collection and property)
-      if fragment == Binding::FragmentNotFound
-        return unless @binding.has_default?
-        value = @binding[:default]
-      else
-        # DISCUSS: should we return a Skip object instead of this block trick? (same in Binding#serialize?)
-        value = deserialize(fragment) { return } # stop here if skip_parse.
-      end
-
-      value = @binding.parse_filter(value, doc)
-        # parse_filter
-        # set
-      @binding.set(value)
-    end
-
-  private
-    def deserialize(fragment)
-      return yield if @binding.evaluate_option(:skip_parse, fragment) # TODO: move this into Deserializer.
-
-      # use a Deserializer to transform fragment to/into object.
-      deserializer.call(fragment) # CollectionDeserializer/HashDeserializer/etc.
-    end
-
-    def deserializer
-      @binding.deserializer
-    end
-
-
-    # A separated collection deserializer/populator allows us better dealing with populating/modifying
-    # collections of models. (e.g. replace, update, push, etc.).
-    # That also gives us a place to apply options like :parse_filter, etc. per item.
-    class Collection < self
-    private
-      def deserialize(fragment)
-        return deserializer.call(fragment)
-      end
-    end
-
-    class Hash < self
-    end
-  end
-end

data/test/inheritable_test.rb

@@ -1,97 +0,0 @@
-require 'test_helper'
-
-# tests Inheritable:: classes (the #inherit! method). This can be moved to uber if necessary.
-
-class ConfigInheritableTest < MiniTest::Spec
-  class CloneableObject
-    include Representable::Cloneable
-
-    # same instance returns same clone.
-    def clone
-      @clone ||= super
-    end
-  end
-
-
-  # Inheritable::Array
-  it do
-    parent = Representable::Inheritable::Array.new([1,2,3])
-    child  = Representable::Inheritable::Array.new([4])
-
-    child.inherit!(parent).must_equal([4,1,2,3])
-  end
-
-  # Inheritable::Hash
-  Inheritable = Representable::Inheritable
-  describe "Inheritable::Hash" do
-    it do
-      parent = Inheritable::Hash[
-        :volume => volume = Uber::Options::Value.new(9),
-        :genre  => "Powermetal",
-        :only_parent => only_parent = Representable::Inheritable::Array["Pumpkin Box"],
-        :in_both     => in_both     = Representable::Inheritable::Array["Roxanne"],
-        :hash => {:type => :parent},
-        :clone => parent_clone = CloneableObject.new # cloneable is in both hashes.
-      ]
-      child  = Inheritable::Hash[
-        :genre => "Metal",
-        :pitch => 99,
-        :in_both => Representable::Inheritable::Array["Generator"],
-        :hash => {:type => :child},
-        :clone => child_clone = CloneableObject.new
-      ]
-
-      child.inherit!(parent)
-
-      # order:
-      child.to_a.must_equal [
-        [:genre, "Powermetal"], # parent overrides child
-        [:pitch, 99],           # parent doesn't define pitch
-        [:in_both, ["Generator", "Roxanne"]], # Inheritable array gets "merged".
-        [:hash, {:type => :parent}], # normal hash merge: parent overwrites child value.
-        [:clone, parent_clone.clone],
-        [:volume, volume],
-        [:only_parent, ["Pumpkin Box"]],
-      ]
-
-      # clone
-      child[:only_parent].object_id.wont_equal parent[:only_parent].object_id
-      child[:clone].object_id.wont_equal parent[:clone].object_id
-
-      # still a hash:
-      child.must_equal(
-        :genre => "Powermetal",
-        :pitch => 99,
-        :in_both => ["Generator", "Roxanne"],
-        :hash => {:type => :parent},
-        :clone => parent_clone.clone,
-        :volume => volume,
-        :only_parent => ["Pumpkin Box"]
-      )
-    end
-
-    # nested:
-    it do
-      parent = Inheritable::Hash[
-        :details => Inheritable::Hash[
-          :title  => title  = "Man Of Steel",
-          :length => length = Representable::Definition.new(:length) # Cloneable.
-      ]]
-
-      child  = Inheritable::Hash[].inherit!(parent)
-      child[:details][:track] = 1
-
-      parent.must_equal({:details => {:title => "Man Of Steel", :length => length}})
-
-      child.keys.must_equal [:details]
-      child[:details].keys.must_equal [:title, :length, :track]
-      child[:details][:title].must_equal "Man Of Steel"
-      child[:details][:track].must_equal 1
-      child[:details][:length].name.must_equal "length"
-
-      # clone
-      child[:details][:title].object_id.must_equal  title.object_id
-      child[:details][:length].object_id.wont_equal length.object_id
-    end
-  end
-end