representable 2.3.0 → 2.4.0.rc1

data/lib/representable/cached.rb

@@ -1,58 +1,22 @@
 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
+    module Property
+      def property(*)
+        super.tap do |property|
+          binding_builder = format_engine::Binding
 
-      def deserializer
-        @__deserializer ||= super.tap do |deserializer|
-          deserializer.extend(Serializer)
+          map << binding_builder.build(property)
         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
+    def self.included(includer)
+      includer.extend(Property)
+    end
 
-      # for Deserializer::Collection.
-      # TODO: this is a temporary solution.
-      def item_deserializer
-        @__item_deserializer ||= super.tap do |deserializer|
-          deserializer.extend(Serializer)
-        end
-      end
+    def representable_map(*)
+      self.class.map
     end
   end
 end

data/lib/representable/coercion.rb

@@ -9,8 +9,8 @@ module Representable
 
       # This gets called when the :render_filter or :parse_filter option is evaluated.
       # Usually the Coercer instance is an element in a Pipeline to allow >1 filters per property.
-      def call(value, doc, options)
-        Virtus::Attribute.build(@type).coerce(value)
+      def call(input, options)
+        Virtus::Attribute.build(@type).coerce(input)
       end
     end
 
@@ -24,13 +24,13 @@ module Representable
 
 
     module ClassMethods
-      def build_definition(name, options, &block) # Representable::Declarative
-        return super unless type = options[:type]
+      def property(name, options={}, &block)
+        super.tap do |definition|
+          return definition unless type = options[:type]
 
-        options[:render_filter] << coercer = Coercer.new(type)
-        options[:parse_filter]  << coercer
-
-        super
+          definition.merge!(render_filter: coercer = Coercer.new(type))
+          definition.merge!(parse_filter: coercer)
+        end
       end
     end
   end

data/lib/representable/config.rb

@@ -1,91 +1,31 @@
-# Caching of Bindings
-# in Decorators, this could be an instance class var. when inherited, it is automatically busted.
-# however, in modules we can't do that. we never know when a module is "finalised", so we don't really know when to bust the cache.
-
 module Representable
-  # Config contains three independent, inheritable directives: features, options and definitions.
-  # It is a hash - just add directives if you need them.
-  #
-  # You may access/alter the property Definitions using #each, #collect, #add, #get.
+  # Stores Definitions from ::property. It preserves the adding order (1.9+).
+  # Same-named properties get overridden, just like in a Hash.
   #
-  # * features, [options]: "horizontally"+"vertically" inherited values (inline representer)
-  # * definitions, [options], wrap: "vertically" inherited (class inheritance, module inclusion)
-  #
-  # Inheritance works via Config#inherit!(parent).
-  class Config < Inheritable::Hash
-    # Keep in mind that performance doesn't matter here as 99.9% of all representers are created
-    # at compile-time.
-
-    # Stores Definitions from ::property. It preserves the adding order (1.9+).
-    # Same-named properties get overridden, just like in a Hash.
-    #
-    # Overwrite definition_class if you need a custom Definition object (helpful when using
-    # representable in other gems).
-    class Definitions < Inheritable::Hash # TODO: cloneable!
-      def initialize(definition_class)
-        @definition_class = definition_class
-        super()
-      end
-
-      def add(name, options, &block)
-        if options[:inherit] and parent_property = get(name) # i like that: the :inherit shouldn't be handled outside.
-          return parent_property.merge!(options, &block)
-        end
-        options.delete(:inherit) # TODO: can we handle the :inherit in one single place?
-
-        self[name.to_s] = definition_class.new(name, options, &block)
-      end
-
-      def get(name)
-        self[name.to_s]
-      end
-
-      def remove(name)
-        delete(name.to_s)
-      end
-
-      extend Forwardable
-      def_delegators :values, :each # so we look like an array. this is only used in Mapper. we could change that so we don't need to hide the hash.
-
-    private
-      attr_reader :definition_class
+  # Overwrite definition_class if you need a custom Definition object (helpful when using
+  # representable in other gems).
+  class Config < ::Declarative::Definitions
+    def remove(name)
+      delete(name.to_s)
     end
 
-
-    def initialize(definition_class=Definition)
-      super()
-      merge!(
-        :features    => @features     = Inheritable::Hash.new,
-        :definitions => @definitions  = Definitions.new(definition_class),
-        :options     => @options      = Inheritable::Hash.new,
-        :wrap        => nil )
+    def options # FIXME: this is not inherited.
+      @options ||= {}
     end
-    attr_reader :options
-
-    def features
-      @features.keys
-    end
-
-    # delegate #collect etc to Definitions instance.
-    extend Forwardable
-    def_delegators :@definitions, :get, :add, :each, :size, :remove
-    # #collect comes from Hash and then gets delegated to @definitions. don't like that.
 
     def wrap=(value)
       value = value.to_s if value.is_a?(Symbol)
-      self[:wrap] = Uber::Options::Value.new(value)
+      @wrap = Uber::Options::Value.new(value)
     end
 
     # Computes the wrap string or returns false.
-    def wrap_for(name, context, *args, &block)
-      return unless self[:wrap]
-
-      value = self[:wrap].evaluate(context, *args)
+    def wrap_for(represented, *args, &block)
+      return unless @wrap
 
-      name = yield if block_given? # DISCUSS: deprecate/restructure the entire wrapping flow.
+      value = @wrap.evaluate(represented, *args)
 
-      return infer_name_for(name) if value === true
-      value
+      return value if value != true
+      infer_name_for(represented.class.name)
     end
 
   private

data/lib/representable/debug.rb

@@ -1,36 +1,26 @@
 module Representable
   module Debug
-    def self.extended(represented)
-      represented.extend Representable
+    def update_properties_from(doc, options, format)
+      puts
+      puts "[Deserialize]........."
+      puts "[Deserialize] document #{doc.inspect}"
+      super
     end
 
-    module Representable
-      def update_properties_from(doc, options, format)
-        puts
-        puts "[Deserialize]........."
-        puts "[Deserialize] document #{doc.inspect}"
-        super
-      end
-
-      def create_representation_with(doc, options, format)
-        puts
-        puts "[Serialize]........."
-        puts "[Serialize]"
-        super
-      end
+    def create_representation_with(doc, options, format)
+      puts
+      puts "[Serialize]........."
+      puts "[Serialize]"
+      super
+    end
 
-      def representable_mapper(*args)
-        super.extend(Mapper)
+    def representable_map(*)
+      super.tap do |arr|
+        arr.collect { |bin| bin.extend(Binding) }
       end
     end
 
     module Binding
-      def read(doc)
-        value = super
-        puts "                #read --> #{value.inspect}"
-        value
-      end
-
       def evaluate_option(name, *args, &block)
         puts "=====#{self[name]}" if name ==:prepare
         puts (evaled = self[name]) ?
@@ -42,54 +32,46 @@ module Representable
         value
       end
 
-      def populator
-        super.extend(Populator)
+      def parse_pipeline(*)
+        super.extend(Pipeline::Debug)
       end
 
-      def serializer
-        super.extend(Serializer)
+      def render_pipeline(*)
+        super.extend(Pipeline::Debug)
       end
     end
+  end
 
-    module Populator
-      def deserialize(fragment)
-        puts "                  Populator#deserialize: #{fragment.inspect}"
-        puts "                                       : typed? is false, skipping Deserializer." if ! @binding.typed?
-        super
-      end
 
-      def deserializer
-        super.extend(Deserializer)
-      end
+  module Pipeline::Debug
+    def call(input, options)
+      puts "Pipeline#call: #{inspect}"
+      puts "               input: #{input.inspect}"
+      super
     end
 
-    module Deserializer
-      def create_object(fragment, *args)
-        value = super
-          puts "                    Deserializer#create_object: --> #{value.inspect}"
-        value
-      end
-    end
+    def evaluate(block, memo, options)
+      block.extend(Pipeline::Debug) if block.is_a?(Collect)
 
-    module Serializer
-      def marshal(object, user_options)
-        puts "                    Serializer#marshal: --> #{object.inspect}"
-        super
+      puts "  Pipeline   :   -> #{_inspect_function(block)} "
+      super.tap do |res|
+        puts "  Pipeline   :     result: #{res.inspect}"
       end
     end
 
-    module Mapper
-      def uncompile_fragment(bin, doc)
-        bin.extend(Binding)
-        puts "              uncompile_fragment: #{bin.name}"
-        super
-      end
+    def inspect
+      functions = collect do |func|
+        _inspect_function(func)
+      end.join(", ")
+      "#{self.class.to_s.split("::").last}[#{functions}]"
+    end
 
-      def compile_fragment(bin, doc)
-        bin.extend(Binding)
-        puts "              compile_fragment: #{bin.name}"
-        super
-      end
+    # prints SkipParse instead of <Proc>. i know, i can make this better, but not now.
+    def _inspect_function(func)
+      return func.extend(Pipeline::Debug).inspect if func.is_a?(Collect)
+      return func unless func.is_a?(Proc)
+      File.readlines(func.source_location[0])[func.source_location[1]-1].match(/^\s+(\w+)/)[1]
     end
   end
 end
+

data/lib/representable/declarative.rb

@@ -1,16 +1,13 @@
 module Representable
   module Declarative
-    def representable_attrs
-      @representable_attrs ||= build_config
-    end
-
     def representation_wrap=(name)
-      representable_attrs.wrap = name
+      heritage.record(:representation_wrap=, name)
+
+      definitions.wrap = name
     end
 
     def collection(name, options={}, &block)
-      options[:collection] = true # FIXME: don't override original.
-      property(name, options, &block)
+      property(name, options.merge(collection: true), &block)
     end
 
     def hash(name=nil, options={}, &block)
@@ -20,67 +17,51 @@ module Representable
       property(name, options, &block)
     end
 
-    # Allows you to nest a block of properties in a separate section while still mapping them to the outer object.
+    # Allows you to nest a block of properties in a separate section while still mapping
+    # them to the original object.
     def nested(name, options={}, &block)
       options = options.merge(
-        :use_decorator => true,
-        :getter        => lambda { |*| self },
-        :setter        => lambda { |*| },
-        :instance      => lambda { |*| self }
-      ) # DISCUSS: should this be a macro just as :parse_strategy?
+        getter:   ->(options) { self },
+        setter:   ->(options) { },
+        instance: ->(options) { self },
+      )
+
+      if block
+        options[:_nested_builder] = Decorator.nested_builder
+        options[:_base]           = Decorator.default_nested_class
+      end
 
       property(name, options, &block)
     end
 
-    def property(name, options={}, &block)
-      representable_attrs.add(name, options) do |default_options| # handles :inherit.
-        build_definition(name, default_options, &block)
-      end
-    end
 
-    def build_inline(base, features, name, options, &block) # DISCUSS: separate module?
-      Module.new do
-        include Representable
-        feature *features # Representable::JSON or similar.
-        include base if base # base when :inherit, or in decorator.
+    include ::Declarative::Schema::DSL # ::property
+    include ::Declarative::Schema::Feature
+    include ::Declarative::Heritage::DSL
 
-        module_eval &block
-      end
+    def default_nested_class
+      Module.new # FIXME: make that unnecessary in Declarative
     end
 
-  private
-    # This method is meant to be overridden if you want to add or change DSL options.
-    # The options hash is already initialized, add or change elements as you need.
-    #
-    # Example:
-    #
-    # def build_definition(name, options, &block)
-    #   options[:pass_options] = true
-    #   options[:render_filter] << Sanitizer.new if options[:sanitize]
-    #   options[:setter] << lambda { |fragment, options| send("set_#{options.binding.name}=", fragment) }
-    #   super # don't forget to call super
-    # end
-    def build_definition(name, options, &block)
-      base = nil
-
-      if options[:inherit] # TODO: move this to Definition.
-        base = representable_attrs.get(name).representer_module
-      end # FIXME: can we handle this in super/Definition.new ?
 
-      if block
-        options[:_inline] = true
-        options[:extend]  = inline_representer_for(base, representable_attrs.features, name, options, &block)
+    NestedBuilder = ->(options) do
+      Module.new do
+        include Representable # FIXME: do we really need this?
+        feature *options[:_features]
+        include *options[:_base] # base when :inherit, or in decorator.
+
+        module_eval &options[:_block]
       end
     end
 
-    def inline_representer_for(base, features, name, options, &block)
-      representer = options[:use_decorator] ? Decorator : self
-
-      representer.build_inline(base, features, name, options, &block)
+    def nested_builder
+      NestedBuilder
     end
 
-    def build_config
-      Config.new
+    def definitions
+      @definitions ||= Config.new(Representable::Definition)
     end
-  end # Declarations
+
+    alias_method :representable_attrs, :definitions
+  end
 end