representable 2.3.0 → 2.4.0.rc1

data/lib/representable/hash.rb

@@ -14,14 +14,16 @@ module Representable
       end
     end
 
-
     module ClassMethods
+      def format_engine
+        Representable::Hash
+      end
+
       def collection_representer_class
         Collection
       end
     end
 
-
     def from_hash(data, options={}, binding_builder=Binding)
       data = filter_wrap(data, options)
 
@@ -31,7 +33,7 @@ module Representable
     def to_hash(options={}, binding_builder=Binding)
       hash = create_representation_with({}, options, binding_builder)
 
-      return hash if options[:wrap] == false # TODO: same for parse.
+      return hash if options[:wrap] == false
       return hash unless wrap = options[:wrap] || representation_wrap(options)
 
       {wrap => hash}

data/lib/representable/hash/binding.rb

@@ -3,20 +3,16 @@ require 'representable/binding'
 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)
+      def self.build_for(definition)
+        return Collection.new(definition)  if definition.array?
+        new(definition)
       end
 
-      def read(hash)
-        return FragmentNotFound unless hash.has_key?(as)
-
-        hash[as] # fragment
+      def read(hash, as)
+        hash.has_key?(as) ? hash[as] : FragmentNotFound
       end
 
-      def write(hash, fragment)
+      def write(hash, fragment, as)
         hash[as] = fragment
       end
 
@@ -31,11 +27,6 @@ module Representable
       class Collection < self
         include Representable::Binding::Collection
       end
-
-
-      class Hash < self
-        include Representable::Binding::Hash
-      end
     end
   end
 end

data/lib/representable/hash/collection.rb

@@ -6,7 +6,7 @@ module Representable::Hash
       base.class_eval do
         include Representable::Hash
         extend ClassMethods
-        representable_attrs.add(:_self, {:collection => true})
+        property(:_self, {:collection => true})
       end
     end
 
@@ -19,14 +19,18 @@ module Representable::Hash
 
 
     def create_representation_with(doc, options, format)
-      bin   = representable_mapper(format, options).bindings(represented, options).first
-      bin.render_fragment(represented, doc)
+      bin   = representable_bindings_for(format, options).first
+
+      Collect[*bin.default_render_fragment_functions].
+        (represented, {doc: doc, fragment: represented, user_options: options, binding: bin, represented: represented})
     end
 
     def update_properties_from(doc, options, format)
-      bin   = representable_mapper(format, options).bindings(represented, options).first
-      #value = bin.deserialize_from(doc)
-      value = Deserializer::Collection.new(bin).call(doc)
+      bin   = representable_bindings_for(format, options).first
+
+      value = Collect[*bin.default_parse_fragment_functions].
+        (doc, fragment: doc, document: doc, user_options: options, binding: bin, represented: represented)
+
       represented.replace(value)
     end
   end

data/lib/representable/hash_methods.rb

@@ -2,17 +2,17 @@ module Representable
   module HashMethods
     def create_representation_with(doc, options, format)
       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   = representable_map(options, format).first
 
-      bin.render_fragment(hash, doc) # TODO: Use something along Populator, which does
+      Collect::Hash[*bin.default_render_fragment_functions].extend(Pipeline::Debug).(hash, {doc: doc, user_options: options, binding: bin, represented: represented, decorator: self})
     end
 
     def update_properties_from(doc, options, format)
       hash  = filter_keys_for!(doc, options)
-      bin   = representable_mapper(format, options).bindings(represented, options).first
+      bin   = representable_map(options, format).first
+
+      value = Collect::Hash[*bin.default_parse_fragment_functions].(hash, fragment: hash, document: doc, binding: bin, represented: represented, user_options: options, decorator: self)
 
-      value = Deserializer::Hash.new(bin).call(hash)
-      # value = bin.deserialize_from(hash)
       represented.replace(value)
     end
 

data/lib/representable/insert.rb

@@ -0,0 +1,31 @@
+module Representable
+  Pipeline.class_eval do # FIXME: this doesn't define Function in Pipeline.
+    module Function
+      class Insert
+        def call(arr, func, options)
+          arr = arr.dup
+          delete!(arr, func) if options[:delete]
+          replace!(arr, options[:replace], func) if options[:replace]
+          arr
+        end
+
+      private
+        def replace!(arr, old_func, new_func)
+          arr.each_with_index { |func, index|
+            if func.is_a?(Collect)
+              arr[index] = Collect[*Pipeline::Insert.(func, new_func, replace: old_func)]
+            end
+
+            arr[index] = new_func if old_func.is_a?(Proc)? (func==old_func) : old_func.instance_of?(func.class)
+          }
+        end
+
+        def delete!(arr, func)
+          arr.delete(func)
+        end
+      end
+    end
+  end
+
+  Pipeline::Insert = Function::Insert.new
+end

data/lib/representable/json.rb

@@ -1,8 +1,8 @@
-require 'representable/hash'
-require 'representable/json/collection'
+require "representable/hash"
+require "representable/json/collection"
 
 begin
-  require 'multi_json'
+  require "multi_json"
 rescue LoadError => _
   abort "Missing dependency 'multi_json' for Representable::JSON. See dependencies section in README.md for details."
 end
@@ -23,6 +23,10 @@ module Representable
 
 
     module ClassMethods
+      def format_engine
+        Representable::Hash
+      end
+
       def collection_representer_class
         JSON::Collection
       end

data/lib/representable/json/hash.rb

@@ -10,7 +10,7 @@ module Representable::JSON
         extend ClassMethods
         include Representable::JSON
         include Representable::HashMethods
-        representable_attrs.add(:_self, {:hash => true})
+        property(:_self, hash: true)
       end
     end
 

data/lib/representable/object/binding.rb

@@ -1,19 +1,19 @@
 module Representable
   module Object
     class Binding < Representable::Binding
-      def self.build_for(definition, *args)  # TODO: remove default arg.
-        return Collection.new(definition, *args)  if definition.array?
-        new(definition, *args)
+      def self.build_for(definition)  # TODO: remove default arg.
+        return Collection.new(definition)  if definition.array?
+        new(definition)
       end
 
-      def read(hash)
+      def read(hash, as)
         fragment = hash.send(as) # :getter? no, that's for parsing!
 
         return FragmentNotFound if fragment.nil? and typed?
         fragment
       end
 
-      def write(hash, fragment)
+      def write(hash, fragment, as)
         true
       end
 

data/lib/representable/parse_strategies.rb

@@ -1,4 +1,36 @@
 module Representable
+  class Populator
+    FindOrInstantiate = ->(input, options) {
+      AssignFragment.(input, options)
+
+      binding = options[:binding]
+
+      object_class = binding[:class].(input, options)
+      object       = object_class.find_by(id: input["id"]) || object_class.new
+      if options[:binding].array?
+        # represented.songs[i] = model
+        options[:represented].send(binding.getter)[options[:index]] = object
+      else
+        # represented.song = model
+        options[:represented].send(binding.setter, object)
+      end
+
+      object
+     }
+
+    def self.apply!(options)
+      return unless populator = options[:populator]
+
+      options[:parse_pipeline] = ->(input, options) do
+        pipeline = Pipeline[*parse_functions] # TODO: AssignFragment
+        pipeline = Pipeline::Insert.(pipeline, Set, delete: true) # remove the setter function.
+        pipeline = Pipeline::Insert.(pipeline, populator, replace: CreateObject) # let the populator do CreateObject's job.
+      end
+    end
+  end
+
+  FindOrInstantiate = Populator::FindOrInstantiate
+
   # Parse strategies are just a combination of representable's options. They save you from memoizing the
   # necessary parameters.
   #
@@ -7,6 +39,8 @@ module Representable
     def self.apply!(options)
       return unless strategy = options[:parse_strategy]
 
+      warn "[Representable] :parse_strategy is deprecated. Please use a populator."
+
       strategy = :proc if strategy.is_a?(::Proc)
 
       parse_strategies[strategy].apply!(name, options)
@@ -33,11 +67,11 @@ module Representable
 
     class Sync
       def self.apply!(name, options)
-        options[:setter]       = lambda { |*| }
+        options[:setter]       = lambda { |*args| }
         options[:pass_options] = true
         options[:instance]     = options[:collection] ?
-          lambda { |fragment, i, options| options.binding.get[i] } :
-          lambda { |fragment, options|    options.binding.get }
+          lambda { |fragment, i, options| options.binding.get(represented: options.represented)[i] } :
+          lambda { |fragment, options|    options.binding.get(represented: options.represented) }
       end
     end
 

data/lib/representable/pipeline.rb

@@ -1,14 +1,46 @@
 module Representable
   # Allows to implement a pipeline of filters where a value gets passed in and the result gets
   # passed to the next callable object.
-  #
-  # Note: this is still experimental.
   class Pipeline < Array
     include Uber::Callable
-    # include Representable::Cloneable
 
-    def call(context, value, *args)
-      inject(value) { |memo, block| block.call(memo, *args) }
+    Stop = Class.new
+
+    # options is mutuable.
+    def call(input, options)
+      inject(input) do |memo, block|
+        res = evaluate(block, memo, options)
+        return(Stop)if Stop == res
+        res
+      end
+    end
+
+  private
+    def evaluate(block, input, options)
+      block.call(input, options)
+    end
+  end
+
+
+  # Collect applies a pipeline to each element of input.
+  class Collect < Pipeline
+    # when stop, the element is skipped. (should that be Skip then?)
+    def call(input, options)
+      arr = []
+      input.each_with_index do |item_fragment, i|
+        result = super(item_fragment, options.merge(index: i)) # DISCUSS: NO :fragment set.
+        Pipeline::Stop == result ? next : arr << result
+      end
+      arr
+    end
+
+    class Hash < Pipeline
+      def call(input, options)
+        {}.tap do |hsh|
+          input.each { |key, item_fragment|
+            hsh[key] = super(item_fragment, options) }# DISCUSS: NO :fragment set.
+        end
+      end
     end
   end
 end

data/lib/representable/pipeline_factories.rb

@@ -0,0 +1,88 @@
+# NOTE: this might become a separate class, that's why it's in a separate file.
+module Representable
+  module Binding::Factories
+    def pipeline_for(name, input, options)
+      return yield unless proc = @definition[name]
+      # proc.(self, options)
+      instance_exec(input, options, &proc)
+    end
+
+    # i decided not to use polymorphism here for the sake of clarity.
+    def collect_for(item_functions)
+      return [Collect[*item_functions]] if array?
+      return [Collect::Hash[*item_functions]] if self[:hash]
+      item_functions
+    end
+
+    def parse_functions
+      [*default_parse_init_functions, *collect_for(default_parse_fragment_functions), *default_post_functions]
+    end
+
+    # DISCUSS: StopOnNil, before collect
+    def render_functions
+      [*default_render_init_functions, *collect_for(default_render_fragment_functions), WriteFragment]
+    end
+
+    def default_render_fragment_functions
+      functions = []
+      functions << SkipRender if self[:skip_render]
+      if typed? # TODO: allow prepare regardless of :extend, which makes it independent of typed?
+        if self[:prepare]
+          functions << Prepare
+        end
+        # functions << (self[:prepare] ? Prepare : Decorate)
+      end
+      functions << Decorate if self[:extend] and !self[:prepare]
+      if representable?
+        functions << (self[:serialize] ? Serializer : Serialize)
+      end
+      functions
+    end
+
+    def default_render_init_functions
+      functions = []
+      functions << Stop if self[:readable]==false
+      functions << StopOnExcluded
+      functions << If if self[:if]
+      functions << (self[:getter] ? Getter : Get)
+      functions << Writer if self[:writer]
+      functions << RenderFilter if self[:render_filter].any?
+      functions << RenderDefault if has_default?
+      functions << StopOnSkipable
+      functions << (self[:as] ? AssignAs : AssignName)
+    end
+
+    def default_parse_init_functions
+      functions = []
+      functions << Stop if self[:writeable]==false
+      functions << StopOnExcluded
+      functions << If if self[:if]
+      functions << (self[:as] ? AssignAs : AssignName)
+      functions << (self[:reader] ? Reader : ReadFragment)
+      functions << (has_default? ? Default : StopOnNotFound)
+      functions << OverwriteOnNil # include StopOnNil if you don't want to erase things.
+    end
+
+    def default_parse_fragment_functions
+      functions = []
+      functions << SkipParse if self[:skip_parse]
+
+      if typed?
+        functions << CreateObject
+        functions << Prepare     if self[:prepare]
+        functions << Decorate    if self[:extend]
+        if representable?
+          functions << (self[:deserialize] ? Deserializer : Deserialize)
+        end
+      end
+
+      functions
+    end
+
+    def default_post_functions
+      funcs = []
+      funcs << ParseFilter if self[:parse_filter].any?
+      funcs << (self[:setter] ? Setter : Set)
+    end
+  end
+end

data/lib/representable/serializer.rb

@@ -1,60 +1,54 @@
-require "representable/deserializer"
-
 module Representable
-  # serialize -> serialize! -> marshal. # TODO: same flow in deserialize.
-  class Serializer < Deserializer
-    def call(object, &block)
-      return object if object.nil? # DISCUSS: move to Object#serialize ?
+  Getter = ->(input, options) do
+    options[:binding].evaluate_option(:getter, input, options)
+  end
 
-      serialize(object, @binding.user_options, &block)
-    end
+  Get = ->(input, options) { options[:binding].send(:exec_context, options).send(options[:binding].getter) }
 
-  private
-    def serialize(object, user_options, &block)
-      return yield if @binding.evaluate_option(:skip_render, object) # this will jump out of #render_fragment. introduce Skip object here.
+  Writer = ->(input, options) do
+    options[:binding].evaluate_option(:writer, input, options)
+    Pipeline::Stop
+  end
 
-      serialize!(object, user_options)
-    end
+  # TODO: evaluate this, if we need this.
+  RenderDefault = ->(input, options) do
+    binding = options[:binding]
 
-    # Serialize one object by calling to_json etc. on it.
-    def serialize!(object, user_options)
-      object = prepare(object)
+    binding.skipable_empty_value?(input) ? binding[:default] : input
+  end
 
-      return object unless @binding.representable?
+  StopOnSkipable = ->(input, options) do
+    options[:binding].send(:skipable_empty_value?, input) ? Pipeline::Stop : input
+  end
 
-      @binding.evaluate_option(:serialize, object) do
-        marshal(object, user_options)
-      end
-    end
+  RenderFilter = ->(input, options) do
+    options[:binding][:render_filter].(input, options)
+  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)
-    end
+  SkipRender = ->(input, options) do
+    options[:binding].evaluate_option(:skip_render, input, options) ? Pipeline::Stop : input
+  end
 
+  Serializer = ->(input, options) do
+    return if input.nil? # DISCUSS: how can we prevent that?
 
-    class Collection < self
-      def serialize(array, *args)
-        collection = [] # TODO: unify with Deserializer::Collection.
+    options[:binding].evaluate_option(:serialize, input, options)
+  end
 
-        array.each do |item|
-          next if @binding.evaluate_option(:skip_render, item) # TODO: allow skipping entire collections? same for deserialize.
+  Serialize = ->(input, options) do
+    return if input.nil? # DISCUSS: how can we prevent that?
+    binding, user_options = options[:binding], options[:user_options]
 
-          collection << serialize!(item, *args)
-        end # TODO: i don't want Array but Forms here - what now?
+    user_options = user_options.merge(wrap: binding[:wrap]) unless binding[:wrap].nil? # DISCUSS: can we leave that here?
 
-        collection
-      end
-    end
+    input.send(binding.serialize_method, user_options)
+  end
 
+  WriteFragment = ->(input, options) { options[:binding].write(options[:doc], input, options[:as]) }
 
-    class Hash < self
-      def serialize(hash, *args)
-        {}.tap do |hsh|
-          hash.each { |key, obj| hsh[key] = super(obj, *args) }
-        end
-      end
-    end
-  end
+  As = ->(input, options) { options[:binding].evaluate_option(:as, input, options) }
+
+  # 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