rabl 0.11.1 → 0.11.2

data/lib/rabl/cache_engine.rb

@@ -21,7 +21,7 @@ module Rabl
       end
     end
 
-    def write(key, value, options={})
+    def write(key, value, options = {})
       if defined?(Rails)
         Rails.cache.write(key, value, options)
       end

data/lib/rabl/configuration.rb

@@ -80,7 +80,7 @@ module Rabl
       @replace_nil_values_with_empty_strings        = false
       @replace_empty_string_values_with_nil_values  = false
       @exclude_nil_values                           = false
-      @exclude_empty_values_in_collections   = false
+      @exclude_empty_values_in_collections          = false
     end
 
     # @return The JSON engine used to encode Rabl templates into JSON

data/lib/rabl/engine.rb

@@ -1,124 +1,158 @@
 module Rabl
   class Engine
-    include Rabl::Partials
-    include Rabl::Helpers::Escaper
+    include Helpers
+    include Partials
+    include Helpers::Escaper
 
     # List of supported rendering formats
     FORMATS = [:json, :xml, :plist, :bson, :msgpack]
 
     # Constructs a new ejs engine based on given vars, handler and declarations
     # Rabl::Engine.new("...source...", { :format => "xml", :root => true, :view_path => "/path/to/views" })
-    def initialize(source, options={})
-      @_source = source
-      @_options = options
-      @_view_path = options[:view_path]
+    def initialize(source, options = {})
+      @_source        = source
+      @_settings      = {}
+      @_options       = options
+
+      @_view_path     = options[:view_path]
+      @_context_scope = options[:scope]
+      
+      @_cache_read_on_render = true
     end
 
-    def source=(string)
-      @_source = string
+    def source=(source)
+      @_source = source
     end
 
-    # Renders the representation based on source, object, scope and locals
-    # Rabl::Engine.new("...source...", { :format => "xml" }).apply(scope, { :foo => "bar", :object => @user })
-    def apply(scope, locals, &block)
-      reset_options!(scope)
-      set_instance_variables!(scope, locals, &block)
+    # Renders the representation based on source, object, context_scope and locals
+    # Rabl::Engine.new("...source...", { :format => "xml" }).apply(context_scope, { :foo => "bar", :object => @user })
+    def apply(context_scope, locals, &block)
+      set_instance_variables!(context_scope, locals)
+
+      reset_settings!
+      reset_options!
+
+      eval_source(locals, &block)
+
       instance_exec(root_object, &block) if block_given?
 
       self
     end
 
     # Renders the representation based on a previous apply
-    # Rabl::Engine.new("...source...", { :format => "xml" }).apply(scope, { :foo => "bar", :object => @user }).render
-    def render(scope = nil, locals = nil, &block)
-      apply(scope, locals) if scope || locals
-      cache_results { self.send("to_#{@_options[:format]}", @_options) }
+    # Rabl::Engine.new("...source...", { :format => "xml" }).apply(context_scope, { :foo => "bar", :object => @user }).render
+    def render(context_scope = nil, locals = nil, &block)
+      apply(context_scope, locals, &block) if context_scope || locals || block
+
+      cache_results do
+        send("to_#{@_options[:format]}")
+      end
     end
 
-    # Returns the cache key of the engine
     def cache_key
-      _cache = @_cache if defined?(@_cache)
-      cache_key, _ = *_cache || nil
-      return nil if cache_key.nil?
-      Array(cache_key) + [@_options[:root_name], @_options[:format]]
+      return unless defined?(@_cache_key)
+
+      @_full_cache_key ||= begin
+        cache_key = Array(@_cache_key) + [@_options[:root_name], @_options[:format]]
+
+        if digestor_available? && defined?(lookup_context)
+          template = @_options[:template] || @virtual_path
+
+          digest = \
+            if Gem::Version.new(Rails.version) >= Gem::Version.new('4.1')
+              Digestor.digest(:name => template, :finder => lookup_context)
+            else
+              Digestor.digest(template, :rabl, lookup_context)
+            end
+
+          cache_key << digest
+        end
+
+        cache_key
+      end
     end
 
     # Returns a hash representation of the data object
     # to_hash(:root => true, :child_root => true)
-    def to_hash(options={})
-      options = options.merge(@_options)
+    def to_hash(options = {})
+      options = @_options.merge(options)
+
       data = root_object
-      builder = Rabl::Builder.new(options)
+
       options[:root_name] = determine_object_root(data, root_name, options[:root])
 
-      if is_object?(data) || !data # object @user
-        result = builder.build(data, options)
-      elsif is_collection?(data) # collection @users
-        result = if template_cache_configured? && Rabl.configuration.use_read_multi
-          read_multi(*data, options)
-        else
-          data.map { |object| builder.build(object, options) }
+      result = \
+        if is_object?(data) || !data # object @user
+          Builder.new(data, @_settings, options).to_hash
+        elsif is_collection?(data) # collection @users
+          MultiBuilder.new(data, @_settings, options).to_a
         end
-        result = result.map(&:presence).compact if Rabl.configuration.exclude_empty_values_in_collections
-      end
-      Rabl.configuration.escape_all_output ? escape_output(result) : result
+
+      result = escape_output(result) if Rabl.configuration.escape_all_output
+
+      result
+    end
+
+    def to_dumpable(options = {})
+      options = { 
+        :child_root => Rabl.configuration.include_child_root
+      }.merge(options)
+
+      result = to_hash(options)
+      result = { collection_root_name => result } if collection_root_name
+      result
     end
 
     # Returns a json representation of the data object
     # to_json(:root => true)
-    def to_json(options={})
-      include_root = Rabl.configuration.include_json_root
-      include_child_root = Rabl.configuration.include_child_root
-      options = options.reverse_merge(:root => include_root, :child_root => include_child_root)
-      result = collection_root_name ? { collection_root_name => to_hash(options) } : to_hash(options)
+    def to_json(options = {})
+      options = { :root => Rabl.configuration.include_json_root }.merge(options)
+      result = to_dumpable(options)
       format_json(result)
     end
 
     # Returns a msgpack representation of the data object
     # to_msgpack(:root => true)
-    def to_msgpack(options={})
-      include_root = Rabl.configuration.include_msgpack_root
-      include_child_root = Rabl.configuration.include_child_root
-      options = options.reverse_merge(:root => include_root, :child_root => include_child_root)
-      result = collection_root_name ? { collection_root_name => to_hash(options) } : to_hash(options)
-      Rabl.configuration.msgpack_engine.pack result
+    def to_msgpack(options = {})
+      options = { :root => Rabl.configuration.include_msgpack_root }.merge(options)
+      result = to_dumpable(options)
+      Rabl.configuration.msgpack_engine.pack(result)
     end
     alias_method :to_mpac, :to_msgpack
 
     # Returns a plist representation of the data object
     # to_plist(:root => true)
-    def to_plist(options={})
-      include_root = Rabl.configuration.include_plist_root
-      include_child_root = Rabl.configuration.include_child_root
-      options = options.reverse_merge(:root => include_root, :child_root => include_child_root)
-      result = defined?(@_collection_name) ? { @_collection_name => to_hash(options) } : to_hash(options)
+    def to_plist(options = {})
+      options = { :root => Rabl.configuration.include_plist_root }.merge(options)
+      result = to_dumpable(options)
       Rabl.configuration.plist_engine.dump(result)
     end
 
     # Returns an xml representation of the data object
     # to_xml(:root => true)
-    def to_xml(options={})
-      include_root = Rabl.configuration.include_xml_root
-      include_child_root = include_root && Rabl.configuration.include_child_root
-      options = options.reverse_merge(:root => include_root, :child_root => include_child_root)
+    def to_xml(options = {})
+      options = {
+        :root       => (include_root = Rabl.configuration.include_xml_root), 
+        :child_root => include_root && Rabl.configuration.include_child_root
+      }.merge(options)
+
       xml_options = Rabl.configuration.default_xml_options.merge(:root => collection_root_name || root_name)
+
       result = to_hash(options)
+
       result.to_xml(xml_options)
     end
 
     # Returns a bson representation of the data object
     # to_bson(:root => true)
-    def to_bson(options={})
-      include_root = Rabl.configuration.include_bson_root
-      include_child_root = Rabl.configuration.include_child_root
-      options = options.reverse_merge(:root => include_root, :child_root => include_child_root)
-      result = if collection_root_name
-                 { collection_root_name => to_hash(options) }
-               elsif is_collection?(root_object) && root_object.is_a?(Array)
-                 { root_name => to_hash(options) }
-               else
-                 to_hash(options)
-               end
+    def to_bson(options = {})
+      options = { :root => Rabl.configuration.include_bson_root }.merge(options)
+      result = to_dumpable(options)
+
+      if !collection_root_name && is_collection?(root_object) && root_object.is_a?(Array)
+        result = { root_name => result }
+      end
+
       Rabl.configuration.bson_engine.serialize(result).to_s
     end
 
@@ -130,6 +164,7 @@ module Rabl
       current_data  = (@_locals[:object].nil? || template_data == false) ? template_data : @_locals[:object]
       @_data_object = data_object(current_data)
       @_data_name   = data_name(template_data.is_a?(Hash) && !current_data.is_a?(Hash) ? template_data : current_data)
+
       if @_data_name == false
         @_object_root_name = false
         @_collection_name = false
@@ -142,7 +177,7 @@ module Rabl
     def root_object
       return @_data_object if defined?(@_data_object)
 
-      data = @_locals[:object].nil? ? self.default_object : @_locals[:object]
+      data = @_locals[:object].nil? ? default_object : @_locals[:object]
       @_data_object = data_object(data)
     end
 
@@ -160,11 +195,13 @@ module Rabl
     # collection @users => :people
     # collection @users, :root => :person
     # collection @users, :object_root => :person
-    def collection(data, options={})
+    def collection(data, options = {})
       @_collection_name = options[:root] if options[:root]
-      @_collection_name ||= data.values.first if data.respond_to?(:each_pair)
+      @_collection_name ||= data.values.first if data.is_a?(Hash)
+
       @_object_root_name = options[:object_root] if options.has_key?(:object_root)
-      self.object(Array(data_object(data)))
+
+      object(Array(data_object(data)))
     end
 
     # Sets the cache key to be used by ActiveSupport::Cache.expand_cache_key
@@ -176,7 +213,8 @@ module Rabl
     # options is passed through to the cache store
     def cache(key = nil, options = nil)
       key ||= root_object # if called but missing, use object
-      @_cache = [key, options]
+      @_cache_key     = key
+      @_cache_options = options
     end
 
     # Indicates an attribute or method should be included in the json output
@@ -185,11 +223,17 @@ module Rabl
     # attribute :foo => :bar, :bar => :baz, :if => lambda { |r| r.foo }
     def attribute(*args)
       if args.first.is_a?(Hash) # :foo => :bar, :bar => :baz
-        attr_aliases, conds = args.first.except(:if, :unless), args.first.slice(:if, :unless)
-        attr_aliases.each_pair { |k,v| self.attribute(k, conds.merge(:as => v)) }
+        attr_aliases  = args.first.except(:if, :unless)
+        conditions    = args.first.slice(:if, :unless)
+
+        attr_aliases.each do |key, as| 
+          attribute(key, conditions.merge(:as => as))
+        end
       else # array of attributes i.e :foo, :bar, :baz
-        attr_options = args.extract_options!
-        args.each { |name| @_options[:attributes][name] = attr_options }
+        options = args.extract_options!
+        args.each do |name| 
+          @_settings[:attributes] << { :name => name, :options => options }
+        end
       end
     end
     alias_method :attributes, :attribute
@@ -197,193 +241,181 @@ module Rabl
     # Creates an arbitrary node that is included in the json output.
     # node(:foo) { "bar" }
     # node(:foo, :if => lambda { ... }) { "bar" }
-    def node(name = nil, options={}, &block)
-      @_options[:node].push({ :name => name, :options => options, :block => block })
+    def node(name = nil, options = {}, &block)
+      @_settings[:node] << { :name => name, :options => options, :block => block }
     end
     alias_method :code, :node
 
     # Creates a child node that is included in json output
     # child(@user) { attribute :full_name }
-    def child(data, options={}, &block)
-      @_options[:child].push({ :data => data, :options => options, :block => block })
+    def child(data, options = {}, &block)
+      @_settings[:child] << { :data => data, :options => options, :block => block }
     end
 
     # Glues data from a child node to the json_output
     # glue(@user) { attribute :full_name => :user_full_name }
-    def glue(data, options={}, &block)
-      @_options[:glue].push({ :data => data, :options => options, :block => block })
+    def glue(data, options = {}, &block)
+      @_settings[:glue] << { :data => data, :options => options, :block => block }
     end
 
     # Extends an existing rabl template with additional attributes in the block
     # extends("users/show", :object => @user) { attribute :full_name }
-    def extends(file, options={}, &block)
-      extend_ops = options.merge(:view_path => options.fetch(:view_path, @_options[:view_path]))
-      @_options[:extends].push({ :file => file, :options => extend_ops, :block => block })
+    def extends(file, options = {}, &block)
+      options = { :view_path => options[:view_path] || view_path }.merge(options)
+
+      @_settings[:extends] << { :file => file, :options => options, :block => block }
     end
 
     # Includes a helper module with a RABL template
     # helper ExampleHelper
-    def helper(*klazzes)
-      klazzes.each { |klazz| self.class.__send__(:include, klazz) }
+    def helper(*klasses)
+      klasses.each { |klass| self.class.__send__(:include, klass) }
     end
     alias_method :helpers, :helper
 
+    # Returns a hash representing the partial
+    # partial("users/show", :object => @user)
+    # options must have :object
+    # options can have :view_path, :child_root, :root
+    def partial(file, options = {}, &block)
+      engine = partial_as_engine(file, options, &block)
+      engine = engine.render if engine.is_a?(Engine)
+      engine
+    end
+
     # Disables reading (but not writing) from the cache when rendering.
-    def cache_read_on_render=(c)
-      @_cache_read_on_render = c
+    def cache_read_on_render=(read)
+      @_cache_read_on_render = read
+    end
+
+    def cache_read_on_render?
+      @_cache_read_on_render
     end
 
     protected
+      # Returns a guess at the default object for this template
+      # default_object => @user
+      def default_object
+        return unless context_scope.respond_to?(:controller)
 
-    # Returns a guess at the default object for this template
-    # default_object => @user
-    def default_object
-      if context_scope.respond_to?(:controller)
         controller_name = context_scope.controller.controller_name
         stripped_name = controller_name.split(%r{::|\/}).last
         ivar_object = instance_variable_get("@#{stripped_name}")
         ivar_object if is_object?(ivar_object)
       end
-    end
 
-    # Returns a guess at the format in this scope
-    # request_format => "xml"
-    def request_format
-      format = self.request_params.has_key?(:format) ? context_scope.params[:format] : nil
-      if request = context_scope.respond_to?(:request) && context_scope.request
-        format ||= request.format.to_sym.to_s if request.respond_to?(:format)
+      # Returns a guess at the format in this context_scope
+      # request_format => "xml"
+      def request_format
+        format = request_params[:format]
+
+        if format.nil? && context_scope.respond_to?(:request)
+          request = context_scope.request
+          format = request.format.to_sym.to_s if request.respond_to?(:format)
+        end
+
+        format = "json" unless format && respond_to?("to_#{format}")
+
+        format
       end
-      format && self.respond_to?("to_#{format}") ? format : "json"
-    end
 
-    # Returns the request parameters if available in the scope
-    # request_params => { :foo => "bar" }
-    def request_params
-      (context_scope.params if context_scope.respond_to?(:params)) || {}
-    end
+      # Returns the request parameters if available in the context_scope
+      # request_params => { :foo => "bar" }
+      def request_params
+        (context_scope.params if context_scope.respond_to?(:params)) || {}
+      end
 
-    # Returns data as json embraced with callback when detected
-    # format_json({ :foo => "bar" }) => "test({ foo : 'bar' })"
-    # format_json("{ foo : "bar" }") => "test({ foo : 'bar' })"
-    def format_json(json_output)
-      json_engine = Rabl.configuration.json_engine
-      json_method = json_engine.respond_to?(:dump) ? 'dump' : 'encode'
-      json_output = json_engine.send(json_method, json_output) unless json_output.is_a?(String)
-      use_callback = Rabl.configuration.enable_json_callbacks && request_params[:callback].present?
-      use_callback ? "#{request_params[:callback]}(#{json_output})" : json_output
-    end
+      # Returns data as json embraced with callback when detected
+      # format_json({ :foo => "bar" }) => "test({ foo : 'bar' })"
+      # format_json("{ foo : "bar" }") => "test({ foo : 'bar' })"
+      def format_json(json_output)
+        unless json_output.is_a?(String)
+          json_engine = Rabl.configuration.json_engine
+          json_output = if json_engine.respond_to?(:dump)
+            json_engine.dump(json_output)
+          else
+            json_engine.encode(json_output)
+          end
+        end
 
-    # Augments respond to supporting scope methods
-    def respond_to?(name, include_private=false)
-      context_scope.respond_to?(name, include_private) ? true : super
-    end
+        use_callback = Rabl.configuration.enable_json_callbacks && request_params[:callback].present?
+        json_output = "#{request_params[:callback]}(#{json_output})" if use_callback
 
-    # Supports calling helpers defined for the template scope using method_missing hook
-    def method_missing(name, *args, &block)
-      context_scope.respond_to?(name, true) ? context_scope.__send__(name, *args, &block) : super
-    end
+        json_output
+      end
 
-    def copy_instance_variables_from(object, exclude = []) #:nodoc:
-      vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
-      vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
-    end
+      # Augments respond to supporting context_scope methods
+      def respond_to?(name, include_private = false)
+        context_scope.respond_to?(name, include_private) || super
+      end
 
-    def cache_read_on_render
-      @_cache_read_on_render = @_cache_read_on_render.nil? ? true : @_cache_read_on_render
-    end
+      # Supports calling helpers defined for the template context_scope using method_missing hook
+      def method_missing(name, *args, &block)
+        context_scope.respond_to?(name, true) ? context_scope.__send__(name, *args, &block) : super
+      end
 
-    private
-
-    # Resets the options parsed from a rabl template.
-    def reset_options!(scope)
-      @_options[:attributes] = {}
-      @_options[:node] = []
-      @_options[:child] = []
-      @_options[:glue] = []
-      @_options[:extends] = []
-      @_options[:root_name]  = nil
-      @_options[:read_multi] = false
-      @_options[:scope] = scope
-    end
+      def copy_instance_variables_from(object, exclude = []) #:nodoc:
+        vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
+        vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
+      end
 
-    # Caches the results of the block based on object cache_key
-    # cache_results { compile_hash(options) }
-    def cache_results(&block)
-      _cache = @_cache if defined?(@_cache)
-      cache_key, cache_options = *_cache || nil
-      if template_cache_configured? && cache_key
-        result_cache_key = if digestor_available?
-          cache_key_with_digest(cache_key)
-        else # fallback for Rails 3, and Non-Rails app
-          cache_key_simple(cache_key)
-        end
+      def reset_settings!
+        @_settings[:attributes]  = []
+        @_settings[:node]        = []
+        @_settings[:child]       = []
+        @_settings[:glue]        = []
+        @_settings[:extends]     = []
+      end
+
+      # Resets the options parsed from a rabl template.
+      def reset_options!
+        @_options[:root_name]   = nil
+        @_options[:read_multi]  = false
+        @_options[:scope]       = context_scope
+      end
 
-        if self.cache_read_on_render
-          fetch_result_from_cache(result_cache_key, cache_options, &block)
+      # Caches the results of the block based on object cache_key
+      # cache_results { compile_hash(options) }
+      def cache_results(&block)
+        return yield unless template_cache_configured? && defined?(@_cache_key)
+
+        if cache_read_on_render?
+          fetch_result_from_cache(cache_key, @_cache_options, &block)
         else
-          write_result_to_cache(result_cache_key, cache_options, &block)
+          write_result_to_cache(cache_key, @_cache_options, &block)
         end
-      else # skip caching
-        yield
       end
-    end
 
-    # Uses read_multi to render a collection of cache keys,
-    # falling back to a normal render in the event of a miss.
-    def read_multi(*data)
-      options = data.extract_options!
-      builder = Rabl::MultiBuilder.new(data, options)
-      builder.to_a
-    end
-
-    def digestor_available?
-      defined?(Rails) && Rails.version =~ /^[4]/
-    end
+      def digestor_available?
+        defined?(Rails) && Rails.version =~ /^[4]/
+      end
 
-    def cache_key_with_digest(cache_key)
-      template = @_options[:template] || @virtual_path
+      def set_instance_variables!(context_scope, locals)
+        @_context_scope = context_scope
+        @_locals        = locals
 
-      if Gem::Version.new(Rails.version) >= Gem::Version.new('4.1')
-        digested =  Digestor.digest(:name => template, :finder => lookup_context)
-      else
-        digested = Digestor.digest(template, :rabl, lookup_context)
-      end
+        copy_instance_variables_from(context_scope, [:@assigns, :@helpers])
 
-      Array(cache_key) + [
-        @_options[:root_name],
-        @_options[:format],
-        digested
-      ]
-    rescue NameError => e # Handle case where lookup_context doesn't exist
-      raise e unless e.message =~ /lookup_context/
-      cache_key_simple(cache_key)
-    end # cache_key_with_digest
-
-    def cache_key_simple(key)
-      Array(key) + [@_options[:root_name], @_options[:format]]
-    end
+        @_options[:format] ||= request_format
 
-    def set_instance_variables!(scope, locals, &block)
-      @_locals, @_scope = locals, scope
-      self.copy_instance_variables_from(@_scope, [:@assigns, :@helpers])
-      @_options[:format] ||= self.request_format
-      set_locals(locals)
-      set_source(locals, &block)
-    end
+        set_locals(locals)
+      end
 
-    def set_locals(locals)
-      locals.merge!(locals.delete(:locals) || {})
-      locals.each { |k,v| instance_variable_set(:"@#{k}", v) }
-    end
+      def set_locals(locals)
+        locals.merge!(locals.delete(:locals) || {})
+        locals.each { |key, value| instance_variable_set(:"@#{key}", value) }
+      end
 
-    def set_source(locals, &block)
-      return unless @_source.present?
+      def eval_source(locals, &block)
+        # Note: locals and block may be used by the eval'ed source
+        
+        return unless @_source.present?
 
-      if @_options[:source_location]
-        instance_eval(@_source, @_options[:source_location])
-      else # without source location
-        instance_eval(@_source)
+        if @_options[:source_location]
+          instance_eval(@_source, @_options[:source_location])
+        else
+          instance_eval(@_source)
+        end
       end
     end
-  end
 end