representable 2.1.8 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1474ed4afb6124795809e52491554dd58a2e13aa
-  data.tar.gz: 60f358588f53073142fd022959f6f5994b64a3cc
+  metadata.gz: 887d742815c848ac3b63287c8858f2988a2de41d
+  data.tar.gz: 78fbbf862aed5b2de60a9bc2ed7375b327a3e058
 SHA512:
-  metadata.gz: 1c242eac1d5b71200bfe7c67be8bacb9ef5f40431af318e2ce65d4b04a8626ce2f6f1fd2dbdf64844b96588adbd341b1d398ff4e4297190cf74b8db82590d46e
-  data.tar.gz: a812ee6f07deff92f515d41fa185c40a45f00e83c37ff5df71c517aeddc834ec643ab79ff4a2e974fba22014cd60744545b8c2a38590521f19a1f6cef62d4959
+  metadata.gz: a4e93c1474e69fb743ca1072fcee054f2e075e4eaf2902b9c885ee7c86b4156db93900889820a5375d61e97a3585c14b2e70931c91722791aec7cf21606226f6
+  data.tar.gz: 93f25a5475e27863649981e0cb5bd553c81b5c02cfe1e16c4c630c368ec972938c4453aae7660ce0e1caf1e67e640a2ff590c5f58d17e7597e0b1abcbc0644a9

data/.travis.yml

@@ -5,6 +5,8 @@ matrix:
     - rvm: 1.9.3
     - rvm: 2.0.0
     - rvm: 2.1.1
-    - rvm: rbx-2.2.10
-    - rvm: jruby-19mode
+    - rvm: 2.2.0
+    # FIXME: add rbx and jruby, again, fix ruby-prof.
+    # - rvm: rbx-2.2.10
+    # - rvm: jruby-19mode
 

data/CHANGES.md

@@ -1,3 +1,34 @@
+# 2.2.0
+
+## New Stuff
+
+* Introduce `Representable::Cached` that will keep the mapper, which in turn will keep the bindings, which in turn will keep their representer, in case they're nested. You have to include this feature manually and you can expect a 50% and more speed-up for rendering and parsing. Not to speak about the reduced memory footprint.
+
+  ``ruby
+  class SongDecorator < Representable::Decorator
+    include Representable::JSON
+    feature Representable::Cached
+
+    # ..
+  end
+  ```
+* Introduced `Decorator#update!` to re-use a decorator instance between requests. This will inject the represented object, only.
+
+  ```ruby
+  decorator = SongDecorator.new(song)
+  decorator.to_json(..)
+
+  decorator.update!(louder_song)
+  decorator.to_json(..)
+  ```
+
+  This is quite awesome.
+
+## API change.
+
+* The `:extend` option only accepts one module. `extend: [Module, Module]` does no longer work and it actually didn't work in former versions of 2.x, anyway, it just included the first element of an array.
+* Remove `Binding#representer_module`.
+
 # 2.1.8
 
 * API change: features are now included into inline representers in the order they were specified. This used to be the other way round and is, of course, wrong, in case a sub-feature wants to override an existing method introduced by an earlier feature.

data/lib/representable.rb

@@ -8,6 +8,10 @@ require 'representable/for_collection'
 require 'representable/represent'
 require 'representable/declarative'
 require 'representable/apply'
+require "representable/populator"
+require "representable/deserializer"
+require "representable/serializer"
+require "representable/cached"
 
 
 require 'uber/callable'
@@ -32,28 +36,33 @@ module Representable
 private
   # Reads values from +doc+ and sets properties accordingly.
   def update_properties_from(doc, options, format)
-    # deserialize_for(bindings, mapper ? , options)
-    representable_mapper(format, options).deserialize(doc, options)
+    private_options = normalize_options!(options)
+
+    representable_mapper(format, options).deserialize(represented, doc, options, private_options)
   end
 
   # Compiles the document going through all properties.
   def create_representation_with(doc, options, format)
-    representable_mapper(format, options).serialize(doc, options)
+    private_options = normalize_options!(options)
+
+    representable_mapper(format, options).serialize(represented, doc, options, private_options)
   end
 
   def representable_bindings_for(format, options)
-    options = cleanup_options(options)  # FIXME: make representable-options and user-options  two different hashes.
-
-    representable_attrs.collect {|attr| representable_binding_for(attr, format, options) }
-    # representable_attrs.binding_cache[format] ||= representable_attrs.collect {|attr| representable_binding_for(attr, format, options) }
+    representable_attrs.collect {|definition| representable_binding_for(definition, format, options) }
   end
 
-  def representable_binding_for(attribute, format, options)
-    format.build(attribute, represented, self, options)
+  def representable_binding_for(definition, format, options)
+    format.build(definition, self)
   end
 
-  def cleanup_options(options) # TODO: remove me. this clearly belongs in Representable.
-    options.reject { |k,v| [:include, :exclude].include?(k) }
+  def normalize_options!(options)
+    # TODO: ideally, private_options would be nil if none set or so, so we could save a lot of time in nested objects.
+    private_options = {}
+    # return private_options if options.size == 0
+    private_options[:include] = options.delete(:include) if options[:include]
+    private_options[:exclude] = options.delete(:exclude) if options[:exclude]
+    private_options
   end
 
   def representable_attrs
@@ -62,11 +71,11 @@ private
 
   def representable_mapper(format, options)
     bindings = representable_bindings_for(format, options)
-    Mapper.new(bindings, represented, options) # TODO: remove self, or do we need it? and also represented!
+    Mapper.new(bindings)
   end
 
   def representation_wrap(*args)
-    representable_attrs.wrap_for(self.class.name, represented, *args)
+    representable_attrs.wrap_for(nil, represented, *args) { self.class.name }
   end
 
   def represented

data/lib/representable/binding.rb

@@ -1,7 +1,3 @@
-require "representable/populator"
-require "representable/deserializer"
-require "representable/serializer"
-
 module Representable
   # The Binding wraps the Definition instance for this property and provides methods to read/write fragments.
 
@@ -19,18 +15,41 @@ module Representable
       build_for(definition, *args)
     end
 
-    def initialize(definition, represented, decorator, user_options={})  # TODO: remove default arg for user options.
-      @definition   = definition
+    def initialize(definition, parent_decorator)
+      @definition       = definition
+      @parent_decorator = parent_decorator # DISCUSS: where's this needed?
 
-      setup!(represented, decorator, user_options) # this can be used in #compile_fragment/#uncompile_fragment in case we wanna reuse the Binding instance.
+      # static options. do this once.
+      @representable    = @definition.representable?
+      @name             = @definition.name
+      @skip_filters     = self[:readable]==false || self[:writeable]==false || self[:if] # Does this binding contain :if, :readable or :writeable settings?
+      @getter           = @definition.getter
+      @setter           = @definition.setter
+      @array            = @definition.array?
+      @typed            = @definition.typed?
+      @has_default      = @definition.has_default?
     end
 
     attr_reader :user_options, :represented # TODO: make private/remove.
 
+    # DISCUSS: an overall strategy to speed up option reads will come around 3.0.
+    attr_reader :representable, :name, :getter, :setter, :array, :typed, :skip_filters, :has_default
+    alias_method :representable?, :representable
+    alias_method :array?, :array
+    alias_method :typed?, :typed
+    alias_method :skip_filters?, :skip_filters
+    alias_method :has_default?, :has_default
+
     def as # DISCUSS: private?
       @as ||= evaluate_option(:as)
     end
 
+    # DISCUSS:
+    # currently, we need to call B#update! before compile_fragment/uncompile_fragment.
+    # this will change to B#renderer(represented, options).call
+    #                     B#parser  (represented, options).call
+    # goal is to have two objects for 2 entirely different tasks.
+
     # Retrieve value and write fragment to the doc.
     def compile_fragment(doc)
       evaluate_option(:writer, doc) do
@@ -55,7 +74,6 @@ module Representable
     end
 
     def render_fragment(value, doc)
-      # DISCUSS: should we return a Skip object instead of this block trick? (same in Populator?)
       fragment = serialize(value) { return } # render fragments of hash, xml, yaml.
 
       write(doc, fragment)
@@ -75,7 +93,6 @@ module Representable
       evaluate_option(:parse_filter, value, doc) { value }
     end
 
-
     def get
       evaluate_option(:getter) do
         exec_context.send(getter)
@@ -89,20 +106,23 @@ module Representable
     end
 
     # DISCUSS: do we really need that?
+    #   1.38      0.104     0.021     0.000     0.083    40001   Representable::Binding#representer_module_for
+    #   1.13      0.044     0.017     0.000     0.027    40001   Representable::Binding#representer_module_for (with memoize).
     def representer_module_for(object, *args)
+      # TODO: cache this!
       evaluate_option(:extend, object) # TODO: pass args? do we actually have args at the time this is called (compile-time)?
     end
 
     # Evaluate the option (either nil, static, a block or an instance method call) or
     # executes passed block when option not defined.
     def evaluate_option(name, *args)
-      unless proc = self[name]
+      unless proc = @definition[name] # TODO: this could dispatch directly to the @definition using #send?
         return yield if block_given?
         return
       end
 
       # TODO: it would be better if user_options was nil per default and then we just don't pass it into lambdas.
-      options = self[:pass_options] ? Options.new(self, user_options, represented, decorator) : user_options
+      options = self[:pass_options] ? Options.new(self, user_options, represented, parent_decorator) : user_options
 
       proc.evaluate(exec_context, *(args<<options)) # from Uber::Options::Value.
     end
@@ -110,39 +130,12 @@ module Representable
     def [](name)
       @definition[name]
     end
-    # TODO: i don't want to define all methods here, but it is faster!
-    # TODO: test public interface.
-    def getter
-      @definition.getter
-    end
-    def setter
-      @definition.setter
-    end
-    def typed?
-      @definition.typed?
-    end
-    def representable?
-      @definition.representable?
-    end
-    def has_default?(*args)
-      @definition.has_default?(*args)
-    end
-    def name
-      @definition.name
-    end
-    def representer_module
-      @definition.representer_module
-    end
-    # perf : 1.7-1.9
-    #extend Forwardable
-    #def_delegators :@definition, *%w([] getter setter typed? representable? has_default? name representer_module)
-    # perf : 1.7-1.9
-    # %w([] getter setter typed? representable? has_default? name representer_module).each do |name|
-    #   define_method(name.to_sym) { |*args| @definition.send(name, *args) }
-    # end
 
+    #   1.55      0.031     0.022     0.000     0.009    60004   Representable::Binding#skipable_empty_value?
+    #   1.51      0.030     0.022     0.000     0.008    60004   Representable::Binding#skipable_empty_value?
+    # after polymorphism:
+    # 1.44      0.031     0.022     0.000     0.009    60002   Representable::Binding#skipable_empty_value?
     def skipable_empty_value?(value)
-      return true if array? and self[:render_empty] == false and value and value.size == 0  # TODO: change in 2.0, don't render emtpy.
       value.nil? and not self[:render_nil]
     end
 
@@ -151,48 +144,57 @@ module Representable
       value
     end
 
-    def array?
-      @definition.array?
-    end
-
-  private
-    def setup!(represented, decorator, user_options)
-      @represented  = represented
-      @decorator    = decorator
-      @user_options = user_options
+    # Note: this method is experimental.
+    def update!(represented, user_options)
+      @represented      = represented
+      @user_options     = user_options
 
       setup_exec_context!
     end
 
-    def setup_exec_context!
-      context = represented
-      context = self        if self[:exec_context] == :binding
-      context = decorator   if self[:exec_context] == :decorator
+    attr_accessor :cached_representer
 
-      @exec_context = context
+  private
+    #   1.80      0.066     0.027     0.000     0.039    30002   Representable::Binding#setup_exec_context!
+    #   0.98      0.034     0.014     0.000     0.020    30002   Representable::Binding#setup_exec_context!
+    def setup_exec_context!
+      return @exec_context = @represented unless self[:exec_context]
+      @exec_context = self             if self[:exec_context] == :binding
+      @exec_context = parent_decorator if self[:exec_context] == :decorator
     end
 
-    attr_reader :exec_context, :decorator
+    attr_reader :exec_context, :parent_decorator
 
     def serialize(object, &block)
       serializer.call(object, &block)
     end
 
-    def serializer_class
-      Serializer
-    end
+    module Factories
+      def serializer_class
+        Serializer
+      end
 
-    def serializer
-      serializer_class.new(self)
-    end
+      def serializer
+        @serializer ||= serializer_class.new(self)
+      end
 
-    def populator
-      populator_class.new(self)
-    end
+      def populator
+        @populator ||= populator_class.new(self)
+      end
+
+      def populator_class
+        Populator
+      end
 
-    def populator_class
-      Populator
+      def deserializer_class
+        Deserializer
+      end
+
+      def deserializer
+        @deserializer ||= deserializer_class.new(self)
+      end
     end
+    include Factories
 
 
     # Options instance gets passed to lambdas when pass_options: true.
@@ -210,6 +212,16 @@ module Representable
       def serializer_class
         Serializer::Collection
       end
+
+      def deserializer_class
+        Deserializer::Collection
+      end
+
+      def skipable_empty_value?(value)
+        # TODO: this can be optimized, again.
+        return true if value.nil? and not self[:render_nil] # FIXME: test this without the "and"
+        return true if self[:render_empty] == false and value and value.size == 0  # TODO: change in 2.0, don't render emtpy.
+      end
     end
 
     # and the same for hashes.
@@ -222,6 +234,10 @@ module Representable
       def serializer_class
         Serializer::Hash
       end
+
+      def deserializer_class
+        Deserializer::Hash
+      end
     end
   end
 

data/lib/representable/cached.rb

@@ -0,0 +1,58 @@
+module Representable
+  # Using this module only makes sense with Decorator representers.
+  module Cached
+    # The main point here is that the decorator instance simply saves its mapper. Since the mapper
+    # in turn stores the bindings, we have a straight-forward way of "caching" the bindings without
+    # having to mess around on the class level: this all happens in the decorator _instance_.
+    #
+    # Every binding in turn stores its nested representer (if it has one), implementing a recursive caching.
+    #
+    # Decorator -> Mapper -> [Binding->Decorator, Binding]
+    def representable_mapper(format, options)
+      @mapper ||= super.tap do |mapper|
+        mapper.bindings(represented, options).each { |binding| binding.extend(Binding) }
+      end
+    end
+
+    # replace represented for each property in this representer.
+    def update!(represented)
+      @represented = represented
+      self
+    end
+
+    # TODO: also for deserializer.
+    # TODO: create Populator in Binding, too (easier to override).
+    module Binding
+      def serializer
+        @__serializer ||= super.tap do |serializer|
+          serializer.extend(Serializer)
+        end
+      end
+
+      def deserializer
+        @__deserializer ||= super.tap do |deserializer|
+          deserializer.extend(Serializer)
+        end
+      end
+    end
+
+    module Serializer
+      def prepare_for(mod, object)
+        if representer = @binding.cached_representer
+          return representer.update!(object)
+        end
+
+        # puts "--------> caching representer for #{object} in #{@binding.object_id}"
+        @binding.cached_representer = super(mod, object)
+      end
+
+      # for Deserializer::Collection.
+      # TODO: this is a temporary solution.
+      def item_deserializer
+        @__item_deserializer ||= super.tap do |deserializer|
+          deserializer.extend(Serializer)
+        end
+      end
+    end
+  end
+end

data/lib/representable/config.rb

@@ -77,11 +77,13 @@ module Representable
     end
 
     # Computes the wrap string or returns false.
-    def wrap_for(name, context, *args)
+    def wrap_for(name, context, *args, &block)
       return unless self[:wrap]
 
       value = self[:wrap].evaluate(context, *args)
 
+      name = yield if block_given? # DISCUSS: deprecate/restructure the entire wrapping flow.
+
       return infer_name_for(name) if value === true
       value
     end

data/lib/representable/deserializer.rb

@@ -36,21 +36,26 @@ module Representable
       object.send(@binding.deserialize_method, fragment, options)
     end
 
-    def prepare(object)
-      @binding.evaluate_option(:prepare, object) do
-        prepare!(object)
+    module Prepare
+      def prepare(object)
+        @binding.evaluate_option(:prepare, object) do
+          prepare!(object)
+        end
       end
-    end
 
-    def prepare!(object)
-      mod = @binding.representer_module_for(object)
+      def prepare!(object)
+        mod = @binding.representer_module_for(object)
 
-      return object unless mod
+        return object unless mod
+
+        prepare_for(mod, object)
+      end
 
-      mod = mod.first if mod.is_a?(Array) # TODO: deprecate :extend => [..]
-      mod.prepare(object)
+      def prepare_for(mod, object)
+        mod.prepare(object)
+      end
     end
-    # in deserialize, we should get the original object?
+    include Prepare
 
     def create_object(fragment, *args)
       instance_for(fragment, *args) or class_for(fragment, *args)
@@ -89,8 +94,11 @@ module Representable
 
     private
       def deserialize!(*args)
-        # TODO: re-use deserializer.
-        Deserializer.new(@binding).call(*args)
+        item_deserializer.call(*args)
+      end
+
+      def item_deserializer
+        @item_deserializer = Deserializer.new(@binding)
       end
     end
 

data/lib/representable/hash/binding.rb

@@ -4,6 +4,7 @@ module Representable
   module Hash
     class Binding < Representable::Binding
       def self.build_for(definition, *args)  # TODO: remove default arg.
+        # puts "@@@build@@ #{definition.inspect}"
         return Collection.new(definition, *args)  if definition.array?
         return Hash.new(definition, *args)        if definition.hash?
         new(definition, *args)

data/lib/representable/hash/collection.rb

@@ -19,12 +19,12 @@ module Representable::Hash
 
 
     def create_representation_with(doc, options, format)
-      bin   = representable_mapper(format, options).bindings.first
+      bin   = representable_mapper(format, options).bindings(represented, options).first
       bin.render_fragment(represented, doc)
     end
 
     def update_properties_from(doc, options, format)
-      bin   = representable_mapper(format, options).bindings.first
+      bin   = representable_mapper(format, options).bindings(represented, options).first
       #value = bin.deserialize_from(doc)
       value = Deserializer::Collection.new(bin).call(doc)
       represented.replace(value)

data/lib/representable/hash_methods.rb

@@ -1,14 +1,15 @@
 module Representable
   module HashMethods
     def create_representation_with(doc, options, format)
-      bin   = representable_mapper(format, options).bindings.first
-      hash  = filter_keys_for(represented, options)
+      hash  = filter_keys_for!(represented, options) # FIXME: this modifies options and replicates logic from Representable.
+      bin   = representable_mapper(format, options).bindings(represented, options).first
+
       bin.render_fragment(hash, doc) # TODO: Use something along Populator, which does
     end
 
     def update_properties_from(doc, options, format)
-      bin   = representable_mapper(format, options).bindings.first
-      hash  = filter_keys_for(doc, options)
+      hash  = filter_keys_for!(doc, options)
+      bin   = representable_mapper(format, options).bindings(represented, options).first
 
       value = Deserializer::Hash.new(bin).call(hash)
       # value = bin.deserialize_from(hash)
@@ -16,9 +17,11 @@ module Representable
     end
 
   private
-    def filter_keys_for(hash, options)
-      return hash unless props = options[:exclude] || options[:include]
-      hash.reject { |k,v| options[:exclude] ? props.include?(k.to_sym) : !props.include?(k.to_sym) }
+    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) }
     end
   end
 end

data/lib/representable/mapper.rb

@@ -3,50 +3,59 @@ module Representable
   # Conditionals are handled here, too.
   class Mapper
     module Methods
-      def initialize(bindings, represented, options) # TODO: get rid of represented dependency.
-        @represented  = represented # the (extended) model.
-        @bindings     = bindings
+      def initialize(bindings)
+        @bindings = bindings
       end
 
-      attr_reader :bindings
+      def bindings(represented, options)
+        @bindings.each do |binding|
+          binding.update!(represented, options)
+        end
+      end
 
-      def deserialize(doc, options)
-        bindings.each do |bin|
-          deserialize_property(bin, doc, options)
+      def deserialize(represented, doc, options, private_options)
+        bindings(represented, options).each do |bin|
+          deserialize_property(bin, doc, options, private_options)
         end
-        @represented
+        represented
       end
 
-      def serialize(doc, options)
-        bindings.each do |bin|
-          serialize_property(bin, doc, options)
+      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)
-        return if skip_property?(binding, options.merge(:action => :serialize))
+      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)
-        return if skip_property?(binding, options.merge(:action => :deserialize))
+      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.
-      def skip_property?(binding, options)
-        return true if skip_excluded_property?(binding, options)  # no need for further evaluation when :exclude'ed
-        return true if skip_protected_property(binding, options)
+      #   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, options)
-        return unless props = options[:exclude] || options[:include]
+      def skip_excluded_property?(binding, private_options)
+        return unless props = private_options[:exclude] || private_options[:include]
         res   = props.include?(binding.name.to_sym)
-        options[:include] ? !res : res
+        private_options[:include] ? !res : res
       end
 
       def skip_conditional_property?(binding)
@@ -56,8 +65,8 @@ module Representable
       end
 
       # DISCUSS: this could be just another :if option in a Pipeline?
-      def skip_protected_property(binding, options)
-        options[:action] == :serialize ? binding[:readable] == false : binding[:writeable] == false
+      def skip_protected_property(binding, private_options)
+        private_options[:action] == :serialize ? binding[:readable] == false : binding[:writeable] == false
       end
 
       def compile_fragment(bin, doc)

data/lib/representable/populator.rb

@@ -35,12 +35,8 @@ module Representable
       deserializer.call(fragment) # CollectionDeserializer/HashDeserializer/etc.
     end
 
-    def deserializer_class
-      Deserializer
-    end
-
     def deserializer
-      deserializer_class.new(@binding)
+      @binding.deserializer
     end
 
 
@@ -52,17 +48,9 @@ module Representable
       def deserialize(fragment)
         return deserializer.call(fragment)
       end
-
-      def deserializer
-        Deserializer::Collection.new(@binding)
-      end
     end
 
     class Hash < self
-    private
-      def deserializer_class
-        Deserializer::Hash
-      end
     end
   end
 end

data/lib/representable/serializer.rb

@@ -27,8 +27,10 @@ module Representable
       end
     end
 
+    #   0.33      0.004     0.004     0.000     0.000    20001   Hash#merge!
+    #   0.00      0.000     0.000     0.000     0.000        1   Hash#merge!
     def marshal(object, user_options)
-      object.send(@binding.serialize_method, user_options.merge!({:wrap => false}))
+      object.send(@binding.serialize_method, user_options)
     end
 
 

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "2.1.8"
+  VERSION = "2.2.0"
 end

data/representable.gemspec

@@ -30,5 +30,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "mocha", ">= 0.13.0"
   s.add_development_dependency "mongoid"
   s.add_development_dependency "virtus"
-  s.add_development_dependency "json", '~> 1.7.7'
+  s.add_development_dependency "json", '>= 1.7.7'
+
+  s.add_development_dependency "ruby-prof"
 end

data/test/binding_test.rb

@@ -5,7 +5,7 @@ class BindingTest < MiniTest::Spec
   let (:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
 
   describe "#skipable_empty_value?" do
-    let (:binding) { Binding.new(render_nil_definition, nil, nil) }
+    let (:binding) { Binding.new(render_nil_definition, nil) }
 
     # don't skip when present.
     it { binding.skipable_empty_value?("Disconnect, Disconnect").must_equal false }
@@ -14,16 +14,16 @@ class BindingTest < MiniTest::Spec
     it { binding.skipable_empty_value?(nil).must_equal false }
 
     # skip when nil and :render_nil undefined.
-    it { Binding.new(Representable::Definition.new(:song), nil, nil).skipable_empty_value?(nil).must_equal true }
+    it { Binding.new(Representable::Definition.new(:song), nil).skipable_empty_value?(nil).must_equal true }
 
     # don't skip when nil and :render_nil undefined.
-    it { Binding.new(Representable::Definition.new(:song), nil, nil).skipable_empty_value?("Fatal Flu").must_equal false }
+    it { Binding.new(Representable::Definition.new(:song), nil).skipable_empty_value?("Fatal Flu").must_equal false }
   end
 
 
   describe "#default_for" do
     let (:definition) { Representable::Definition.new(:song, :default => "Insider") }
-    let (:binding) { Binding.new(definition, nil, nil) }
+    let (:binding) { Binding.new(definition, nil) }
 
     # 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, nil, nil).default_for(nil).must_equal nil }
+    it { Binding.new(render_nil_definition, nil).default_for(nil).must_equal 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"), nil, nil).default_for(nil).must_equal nil }
+    it { Binding.new(Representable::Definition.new(:song, :render_nil => true, :default => "The Quest"), nil).default_for(nil).must_equal nil }
 
     # return nil if no :default
-    it { Binding.new(Representable::Definition.new(:song), nil, nil).default_for(nil).must_equal nil }
+    it { Binding.new(Representable::Definition.new(:song), nil).default_for(nil).must_equal nil }
   end
 end

data/test/cached_test.rb

@@ -0,0 +1,135 @@
+require "test_helper"
+require 'ruby-prof'
+
+class CachedTest < MiniTest::Spec
+  # TODO: also test with feature(Cached)
+
+  module Model
+    Song  = Struct.new(:title, :composer)
+    Album = Struct.new(:name, :songs, :artist)
+    Artist = Struct.new(:name, :hidden_taste)
+  end
+
+  class SongRepresenter < Representable::Decorator
+    include Representable::Hash
+    feature Representable::Cached
+
+    property :title, render_filter: lambda { |value, doc, options| "#{value}:#{options.user_options}" }, pass_options: true
+    property :composer, class: Model::Artist do
+      property :name
+    end
+  end
+
+  class AlbumRepresenter < Representable::Decorator
+    include Representable::Hash
+    include Representable::Cached
+
+    property :name
+    collection :songs, decorator: SongRepresenter, class: Model::Song
+  end
+
+
+  describe "serialization" do
+    let (:album_hash) { {"name"=>"Louder And Even More Dangerous", "songs"=>[{"title"=>"Southbound:{:volume=>10}"}, {"title"=>"Jailbreak:{:volume=>10}"}]} }
+
+    let (:song) { Model::Song.new("Jailbreak") }
+    let (:song2) { Model::Song.new("Southbound") }
+    let (:album) { Model::Album.new("Live And Dangerous", [song, song2, Model::Song.new("Emerald")]) }
+    let (:representer) { AlbumRepresenter.new(album) }
+
+    it do
+      album2 = Model::Album.new("Louder And Even More Dangerous", [song2, song])
+
+      # makes sure options are passed correctly.
+      representer.to_hash(volume: 9).must_equal({"name"=>"Live And Dangerous",
+        "songs"=>[{"title"=>"Jailbreak:{:volume=>9}"}, {"title"=>"Southbound:{:volume=>9}"}, {"title"=>"Emerald:{:volume=>9}"}]}) # called in Deserializer/Serializer
+
+      # representer becomes reusable as it is stateless.
+      representer.update!(album2)
+
+      # makes sure options are passed correctly.
+      representer.to_hash(volume:10).must_equal(album_hash)
+    end
+
+    # profiling
+    it "xx" do
+     RubyProf.start
+        representer.to_hash
+      res = RubyProf.stop
+
+      printer = RubyProf::FlatPrinter.new(res)
+
+      data = StringIO.new
+      printer.print(data)
+      data = data.string
+
+      printer.print(STDOUT)
+
+      # only 1 nested decorators are instantiated, Song.
+      data.must_match "1   <Class::Representable::Decorator>#prepare"
+      # a total of 4 properties in the object graph.
+      data.must_match "4   Representable::Binding#initialize"
+      # 2 mappers for Album, Song
+      data.must_match "2   Representable::Mapper::Methods#initialize"
+      # 6 deserializers as the songs collection uses 2.
+      data.must_match "3   Representable::Deserializer#initialize"
+    end
+  end
+
+
+  describe "deserialization" do
+    let (:album_hash) {
+      {
+        "name"=>"Louder And Even More Dangerous",
+        "songs"=>[
+          {"title"=>"Southbound", "composer"=>{"name"=>"Lynott"}},
+          {"title"=>"Jailbreak", "composer"=>{"name"=>"Phil Lynott"}},
+          {"title"=>"Emerald"}
+        ]
+      }
+    }
+
+    it do
+      album = Model::Album.new
+
+      AlbumRepresenter.new(album).from_hash(album_hash)
+
+      album.songs.size.must_equal 3
+      album.name.must_equal "Louder And Even More Dangerous"
+      album.songs[0].title.must_equal "Southbound"
+      album.songs[0].composer.name.must_equal "Lynott"
+      album.songs[1].title.must_equal "Jailbreak"
+      album.songs[1].composer.name.must_equal "Phil Lynott"
+      album.songs[2].title.must_equal "Emerald"
+      album.songs[2].composer.must_equal nil
+
+      # TODO: test options.
+    end
+
+    it do
+      representer = AlbumRepresenter.new(Model::Album.new)
+
+      RubyProf.start
+        representer.from_hash(album_hash)
+      res = RubyProf.stop
+
+      printer = RubyProf::FlatPrinter.new(res)
+
+      data = StringIO.new
+      printer.print(data)
+      data = data.string
+
+      # only 2 nested decorators are instantiated, Song, and Artist.
+      data.must_match "2   <Class::Representable::Decorator>#prepare"
+      # a total of 5 properties in the object graph.
+      data.must_match "5   Representable::Binding#initialize"
+      # three mappers for Album, Song, composer
+      data.must_match "3   Representable::Mapper::Methods#initialize"
+      # 6 deserializers as the songs collection uses 2.
+      data.must_match "6   Representable::Deserializer#initialize"
+      # one populater for every property.
+      data.must_match "5   Representable::Populator#initialize"
+      # printer.print(STDOUT)
+    end
+  end
+end

data/test/definition_test.rb

@@ -214,8 +214,8 @@ class DefinitionTest < MiniTest::Spec
   describe "#create_binding" do
     it "executes the block (without special context)" do
       definition = Representable::Definition.new(:title, :binding => lambda { |*args| @binding = Representable::Binding.new(*args) })
-      definition.create_binding(object=Object.new, nil, nil).must_equal @binding
-      @binding.instance_variable_get(:@represented).must_equal object
+      definition.create_binding(object=Object.new).must_equal @binding
+      @binding.instance_variable_get(:@parent_decorator).must_equal object
     end
   end
 

data/test/hash_bindings_test.rb

@@ -15,7 +15,7 @@ class HashBindingTest < MiniTest::Spec
   describe "PropertyBinding" do
     describe "#read" do
       before do
-        @property = Representable::Hash::Binding.new(Representable::Definition.new(:song), nil, nil)
+        @property = Representable::Hash::Binding.new(Representable::Definition.new(:song), nil)
       end
 
       it "returns fragment if present" do
@@ -35,7 +35,7 @@ class HashBindingTest < MiniTest::Spec
   describe "CollectionBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::Hash::Binding::Collection.new(Representable::Definition.new(:songs, :collection => true), Album.new, nil)
+        @property = Representable::Hash::Binding::Collection.new(Representable::Definition.new(:songs, :collection => true), Album.new)
       end
 
       it "extracts with #read" do
@@ -56,7 +56,7 @@ class HashBindingTest < MiniTest::Spec
   describe "HashBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::Hash::Binding::Hash.new(Representable::Definition.new(:songs, :hash => true), nil, nil)
+        @property = Representable::Hash::Binding::Hash.new(Representable::Definition.new(:songs, :hash => true), nil)
       end
 
       it "extracts with #read" do
@@ -72,7 +72,7 @@ class HashBindingTest < MiniTest::Spec
 
     describe "with objects" do
       before do
-        @property = Representable::Hash::Binding::Hash.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter), nil, nil)
+        @property = Representable::Hash::Binding::Hash.new(Representable::Definition.new(:songs, :hash => true, :class => Song, :extend => SongRepresenter), nil)
       end
 
       it "doesn't change the represented hash in #write" do

data/test/json_test.rb

@@ -88,15 +88,15 @@ module JsonTest
 
       describe "#build_for" do
         it "returns TextBinding" do
-          assert_kind_of Representable::Hash::Binding, Representable::Hash::Binding.build_for(Def.new(:band), nil, nil)
+          assert_kind_of Representable::Hash::Binding, Representable::Hash::Binding.build_for(Def.new(:band), nil)
         end
 
         it "returns HashBinding" do
-          assert_kind_of Representable::Hash::Binding::Hash, Representable::Hash::Binding.build_for(Def.new(:band, :hash => true), nil, nil)
+          assert_kind_of Representable::Hash::Binding::Hash, Representable::Hash::Binding.build_for(Def.new(:band, :hash => true), nil)
         end
 
         it "returns CollectionBinding" do
-          assert_kind_of Representable::Hash::Binding::Collection, Representable::Hash::Binding.build_for(Def.new(:band, :collection => true), nil, nil)
+          assert_kind_of Representable::Hash::Binding::Collection, Representable::Hash::Binding.build_for(Def.new(:band, :collection => true), nil)
         end
       end
 
@@ -119,7 +119,7 @@ module JsonTest
       module AlbumRepresenter
         include Representable::JSON
         property :best_song, :class => Song, :extend => SongRepresenter
-        collection :songs, :class => Song, :extend => [SongRepresenter]
+        collection :songs, :class => Song, :extend => SongRepresenter
       end
 
 

data/test/xml_bindings_test.rb

@@ -29,7 +29,7 @@ class XMLBindingTest < MiniTest::Spec
   describe "AttributeBinding" do
     describe "with plain text items" do
       before do
-        @property = Representable::XML::Binding::Attribute.new(Representable::Definition.new(:name, :attribute => true), nil, nil)
+        @property = Representable::XML::Binding::Attribute.new(Representable::Definition.new(:name, :attribute => true), nil)
       end
 
       it "extracts with #read" do
@@ -46,7 +46,7 @@ class XMLBindingTest < MiniTest::Spec
 
   describe "ContentBinding" do
     before do
-      @property = Representable::XML::Binding::Content.new(Representable::Definition.new(:name, :content => true), nil, nil)
+      @property = Representable::XML::Binding::Content.new(Representable::Definition.new(:name, :content => true), nil)
     end
 
     it "extracts with #read" do

data/test/xml_test.rb

@@ -104,20 +104,20 @@ class XmlTest < MiniTest::Spec
 
     describe "XML::Binding#build_for" do
       it "returns AttributeBinding" do
-        assert_kind_of XML::Binding::Attribute, XML::Binding.build_for(Def.new(:band, :as => "band", :attribute => true), nil, nil)
+        assert_kind_of XML::Binding::Attribute, XML::Binding.build_for(Def.new(:band, :as => "band", :attribute => true), nil)
       end
 
       it "returns Binding" do
-        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :class => Hash), nil, nil)
-        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :as => :content), nil, nil)
+        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :class => Hash), nil)
+        assert_kind_of XML::Binding, XML::Binding.build_for(Def.new(:band, :as => :content), nil)
       end
 
       it "returns CollectionBinding" do
-        assert_kind_of XML::Binding::Collection, XML::Binding.build_for(Def.new(:band, :collection => :true), nil, nil)
+        assert_kind_of XML::Binding::Collection, XML::Binding.build_for(Def.new(:band, :collection => :true), nil)
       end
 
       it "returns HashBinding" do
-        assert_kind_of XML::Binding::Hash, XML::Binding.build_for(Def.new(:band, :hash => :true), nil, nil)
+        assert_kind_of XML::Binding::Hash, XML::Binding.build_for(Def.new(:band, :hash => :true), nil)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: representable
 version: !ruby/object:Gem::Version
-  version: 2.1.8
+  version: 2.2.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-09 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -140,16 +140,30 @@ dependencies:
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Renders and parses JSON/XML/YAML documents from and to Ruby objects.
   Includes plain properties, collections, nesting, coercion and more.
 email:
@@ -171,6 +185,7 @@ files:
 - lib/representable/apply.rb
 - lib/representable/autoload.rb
 - lib/representable/binding.rb
+- lib/representable/cached.rb
 - lib/representable/coercion.rb
 - lib/representable/config.rb
 - lib/representable/debug.rb
@@ -207,6 +222,7 @@ files:
 - test/as_test.rb
 - test/benchmarking.rb
 - test/binding_test.rb
+- test/cached_test.rb
 - test/class_test.rb
 - test/coercion_test.rb
 - test/config/inherit_test.rb
@@ -277,4 +293,53 @@ signing_key:
 specification_version: 4
 summary: Renders and parses JSON/XML/YAML documents from and to Ruby objects. Includes
   plain properties, collections, nesting, coercion and more.
-test_files: []
+test_files:
+- test/as_test.rb
+- test/benchmarking.rb
+- test/binding_test.rb
+- test/cached_test.rb
+- test/class_test.rb
+- test/coercion_test.rb
+- test/config/inherit_test.rb
+- test/config_test.rb
+- test/decorator_scope_test.rb
+- test/decorator_test.rb
+- test/definition_test.rb
+- test/example.rb
+- test/examples/object.rb
+- test/exec_context_test.rb
+- test/features_test.rb
+- test/filter_test.rb
+- test/for_collection_test.rb
+- test/generic_test.rb
+- test/getter_setter_test.rb
+- test/hash_bindings_test.rb
+- test/hash_test.rb
+- test/if_test.rb
+- test/inherit_test.rb
+- test/inheritable_test.rb
+- test/inline_test.rb
+- test/instance_test.rb
+- test/is_representable_test.rb
+- test/json_test.rb
+- test/lonely_test.rb
+- test/mongoid_test.rb
+- test/nested_test.rb
+- test/object_test.rb
+- test/parse_strategy_test.rb
+- test/pass_options_test.rb
+- test/prepare_test.rb
+- test/reader_writer_test.rb
+- test/realistic_benchmark.rb
+- test/represent_test.rb
+- test/representable_test.rb
+- test/schema_test.rb
+- test/serialize_deserialize_test.rb
+- test/skip_test.rb
+- test/stringify_hash_test.rb
+- test/test_helper.rb
+- test/test_helper_test.rb
+- test/wrap_test.rb
+- test/xml_bindings_test.rb
+- test/xml_test.rb
+- test/yaml_test.rb