rabl 0.11.1 → 0.11.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NGY4MzA3YzkzMGUxMjA5ZjNhOGYxMzRmZTZmMmY0MmMzMzY3ZDg5Zg==
+    MmEyODQ2MGU5MWRhYzc1YjU2YWI2YWMxMTQ2ZGJhYTBhYWJiYTgzNg==
   data.tar.gz: !binary |-
-    OGNjZDBkZWYwM2MxYmQ1YmM4NWY3MDkyNzE3MWZhNjZmM2Q5MGIyNQ==
+    OWI4ZWQwNDZiOGIyZWMzOTQ5ZGFhNDAwMjQ3ZjRlNTg5YTViNjM2OA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    Y2I5OGZiYjk1NzM3YWVlMjA4NThmYTBiZmJhYzk5YWEwM2JlNzUwNGEyMjVk
-    ZDZjNGY1ODA5OWU2MmNmNGIyMWQ4YzM2ODJjZjk1Nzc2YzNjMDYwYjBmOGUw
-    NjEwNDQwNTg4MzhjZjM5MjBjMGU5ODRlODMxZGE3MWRjNjM0MWQ=
+    NDk5OTc0ZjU5ZDM4OTBiYWJhOWNmMzg0MjdlYjk2NTdiNjc0MzdkODhmMTNi
+    YTQyNmE1NDczYjU5N2VlMzU1NjQwYWY4ZWU4NGJhNjljNzhiNzY0MzQ3MzI1
+    MjVjMGViNzE2NTNhOWIzNjE1Y2RlOWNmYzFiYTM3NzA5OGEyZGQ=
   data.tar.gz: !binary |-
-    ZDNkZGFjOGViN2ZkOWRjNjcwZTU1YzI3MGYxMDNmNGZiYjM2YjM4MmQxNDRk
-    ODNmOWZjNjdhMTIzM2E1YThiYzlmZjZjODdlMzFlODkwOWMyNmNiNmE3ZDM4
-    MjgwNjYzMmJmNzkzNGMzOTM5ZDE4Yjc0ODEzMWQ0YzYyY2IyZmY=
+    MWJmZGNkMWIyZGZiYmE0ZGE1NDhlZTRkNDJiNzQwN2YwNGQwNmU2NjQ5OTAx
+    NzE4ZmQ5NDcxZDE0YzIyZDFkYjViOGEzNGVlY2VjYmFhYjEyNmM3OGFlMDY0
+    M2RmMmZmMjI1ZDY4NDEzNzRkN2EyMjFkMzliYjE5Yzc3MTBlNTk=

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 0.11.2 (October 26th)
+
+* FIX Don't put nil into builder engines when glueing nil object (@DouweM)
+
 ## 0.11.1 (October 19th)
 
 * NEW #417 Major rewrite caching layer to be much faster using read_multi (@ahlatimer, @DouweM)

data/README.md

@@ -664,11 +664,18 @@ Check out the [Issues](https://github.com/nesquena/rabl/issues) tab for a full l
 
 ## Authors and Contributors ##
 
+Active Maintainers:
+
+ * [Douwe Maan](https://github.com/DouweM)
+ * [Nathan Esquenazi](https://github.com/nesquena)
+
 Thanks to [Miso](http://gomiso.com) for allowing me to create this for our applications and release this project!
 
 * [Nathan Esquenazi](https://github.com/nesquena) - Creator of the project
 * [Arthur Chiu](https://github.com/achiu) - Core Maintainer, Riot Testing Guru
 * [Tim Lee](https://github.com/timothy1ee) - RABL was a great name chosen by the Miso CTO.
+* [Douwe Maan](https://github.com/DouweM) - Multi support for caching, fixed test suite
+* [Andrew Latimer](https://github.com/ahlatimer) - Multi support for caching
 * [David Sommers](https://github.com/databyte) - Template resolution, caching support, and much more
 * [Rick Thomas](https://github.com/rickthomasjr) - Added options for extends and Sinatra testing
 * [Benjamin Yu](https://github.com/byu) - Added msgpack format support
@@ -709,4 +716,3 @@ Thanks again for all of these great projects.
 ## Copyright ##
 
 Copyright © 2011-2013 Nathan Esquenazi. See [MIT-LICENSE](https://github.com/nesquena/rabl/blob/master/MIT-LICENSE) for details.
-

data/lib/rabl.rb

@@ -7,6 +7,7 @@ require 'active_support/core_ext/hash/slice'
 
 require 'rabl/version'
 require 'rabl/helpers'
+require 'rabl/sources'
 require 'rabl/partials'
 require 'rabl/engine'
 require 'rabl/builder'
@@ -58,13 +59,11 @@ module Rabl
     def source_cache(file, view_path, &block)
       return yield unless Rabl.configuration.cache_sources
 
-      @_source_cache ||= {}
       cache_key = [file, view_path].compact.join(":")
-      if cached_result = @_source_cache[cache_key]
-        cached_result
-      else # store result of block
-        @_source_cache[cache_key] = yield
-      end
+
+      @_source_cache ||= {}
+
+      @_source_cache[cache_key] ||= yield
     end
 
     # Resets the RABL source cache
@@ -77,7 +76,6 @@ module Rabl
     def render(object, source, options = {})
       Rabl::Renderer.new(source, object, options).render
     end
-
   end
 end
 

data/lib/rabl/builder.rb

@@ -1,279 +1,273 @@
 module Rabl
   class Builder
-    include Rabl::Partials
+    include Helpers
+    include Partials
 
     SETTING_TYPES = {
-      :extends => :file,
-      :node    => :name,
-      :child   => :data,
-      :glue    => :data
-    } unless const_defined? :SETTING_TYPES
+      :attributes => :name,
+      :node       => :name,
+      :child      => :data,
+      :glue       => :data,
+      :extends    => :file
+    } unless const_defined?(:SETTING_TYPES)
 
     # Constructs a new rabl hash based on given object and options
     # options = { :format => "json", :root => true, :child_root => true,
     #   :attributes, :node, :child, :glue, :extends }
     #
-    def initialize(options={}, &block)
-      @options    = options
-      @_scope     = options[:scope]
-      @_view_path = options[:view_path]
-    end
-
-    # Given an object and options, returns the hash representation
-    # build(@user, :format => "json", :attributes => { ... }, :root_name => "user")
-    def build(object, options={})
+    def initialize(object, settings = {}, options = {}, &block)
       @_object = object
-      compile_engines
 
-      unless options[:keep_engines]
-        cache_results { compile_hash(options) }
-      end
+      @settings       = settings
+      @options        = options
+      @_context_scope = options[:scope]
+      @_view_path     = options[:view_path]
     end
 
     def engines
-      @_engines ||= []
+      return @_engines if defined?(@_engines)
+
+      @_engines = []
+
+      # Append onto @_engines
+      compile_settings(:extends)
+      compile_settings(:child)
+      compile_settings(:glue)
+
+      @_engines
     end
 
     def replace_engine(engine, value)
       engines[engines.index(engine)] = value
     end
 
-    def to_hash(options={})
-      cache_results { compile_hash(options) }
-    end
+    def to_hash(object = nil, settings = {}, options = {})
+      @_object = object           if object
+      @options.merge!(options)    if options
+      @settings.merge!(settings)  if settings
+      
+      cache_results do
+        @_result = {}
 
-    protected
+        # Merges directly into @_result
+        compile_settings(:attributes)
 
-    # Returns the builder with all engine-producing options evaluated.
-    # (extends, node, children, glues)
-    def compile_engines
-      @_engines = []
+        merge_engines_into_result
 
-      update_settings(:extends)
-      update_settings(:child)
-      update_settings(:glue)
-    end
+        # Merges directly into @_result
+        compile_settings(:node)
 
-    # Returns a hash representation of the data object
-    # compile_hash(:root_name => false)
-    # compile_hash(:root_name => "user")
-    def compile_hash(options={})
-      @_result = {}
-
-      update_attributes
-
-      # Turn engines into hashes
-      @_engines.each do |engine|
-        # engine was stored in the form { name => #<Rabl::Engine> }
-        if engine.is_a?(Hash)
-          engine.each do |key, value|
-            if value.is_a?(Rabl::Engine)
-              value = value.render
-
-              if value
-                engine[key] = value
-              else
-                engine.delete(key)
-              end
-            end
-          end
-        elsif engine.is_a?(Rabl::Engine)
-          engine = engine.render
-        end
+        replace_nil_values          if Rabl.configuration.replace_nil_values_with_empty_strings
+        replace_empty_string_values if Rabl.configuration.replace_empty_string_values_with_nil_values
+        remove_nil_values           if Rabl.configuration.exclude_nil_values
 
-        @_result.merge!(engine) if engine.is_a?(Hash)
+        result = @_result
+        result = { @options[:root_name] => result } if @options[:root_name].present?
+        result
       end
+    end
 
-      @_engines = []
-
-      update_settings(:node)
+    protected
+      def replace_nil_values
+        @_result = deep_replace_nil_values(@_result)
+      end
 
-      wrap_result(options[:root_name])
+      def deep_replace_nil_values(hash)
+        hash.inject({}) do |new_hash, (k, v)|
+          new_hash[k] = if v.is_a?(Hash)
+            deep_replace_nil_values(v)
+          else
+            v.nil? ? '' : v
+          end
+          new_hash
+        end
+      end
 
-      replace_nil_values          if Rabl.configuration.replace_nil_values_with_empty_strings
-      replace_empty_string_values if Rabl.configuration.replace_empty_string_values_with_nil_values
-      remove_nil_values           if Rabl.configuration.exclude_nil_values
+      def replace_empty_string_values
+        @_result = deep_replace_empty_string_values(@_result)
+      end
 
-      # Return Results
-      @_root_name ? { @_root_name => @_result } : @_result
-    end
+      def deep_replace_empty_string_values(hash)
+        hash.inject({}) do |new_hash, (k, v)|
+          new_hash[k] = if v.is_a?(Hash)
+            deep_replace_empty_string_values(v)
+          else
+            (!v.nil? && v != "") ? v : nil
+          end
 
-    def replace_nil_values
-      @_result = deep_replace_nil_values(@_result)
-    end
+          new_hash
+        end
+      end
 
-    def deep_replace_nil_values(hash)
-      hash.inject({}) do |hsh, (k, v)|
-        hsh[k] = if v.is_a?(Hash)
-          deep_replace_nil_values(v)
-        else
-          v.nil? ? '' : v
+      def remove_nil_values
+        @_result = @_result.inject({}) do |new_hash, (k, v)|
+          new_hash[k] = v unless v.nil?
+          new_hash
         end
-        hsh
       end
-    end
 
-    def replace_empty_string_values
-      @_result = deep_replace_empty_string_values(@_result)
-    end
+      def compile_settings(type)
+        return unless @settings.has_key?(type)
 
-    def deep_replace_empty_string_values(hash)
-      hash.inject({}) do |hsh, (k, v)|
-        hsh[k] = if v.is_a?(Hash)
-          deep_replace_empty_string_values(v)
-        else
-          (!v.nil? && v != "") ? v : nil
+        settings_type = SETTING_TYPES[type]
+        @settings[type].each do |setting|
+          send(type, setting[settings_type], setting[:options] || {}, &setting[:block])
         end
-        hsh
       end
-    end
 
-    def remove_nil_values
-      @_result = @_result.inject({}) do |hash, (k, v)|
-        hash[k] = v unless v.nil?
-        hash
-      end
-    end
+      def merge_engines_into_result
+        engines.each do |engine|
+          # engine was stored in the form { name => #<Engine> }
+          if engine.is_a?(Hash)
+            engine.each do |key, value|
+              if value.is_a?(Engine)
+                value = value.render
+
+                if value
+                  engine[key] = value
+                else
+                  engine.delete(key)
+                end
+              end
+            end
+          elsif engine.is_a?(Engine)
+            engine = engine.render
+          end
 
-    def wrap_result(root_name)
-      if root_name.present?
-        @_root_name = root_name
-      else # no root
-        @_root_name = nil
+          @_result.merge!(engine) if engine.is_a?(Hash)
+        end
       end
-    end
 
-    def update_settings(type)
-      settings_type = SETTING_TYPES[type]
-      @options[type].each do |settings|
-        send(type, settings[settings_type], settings[:options], &settings[:block])
-      end if @options.has_key?(type)
-    end
-
-    def update_attributes
-      @options[:attributes].each_pair do |attribute, settings|
-        attribute(attribute, settings)
-      end if @options.has_key?(:attributes)
-    end
+      # Indicates an attribute or method should be included in the json output
+      # attribute :foo, :as => "bar"
+      # attribute :foo, :as => "bar", :if => lambda { |m| m.foo }
+      def attribute(name, options = {})
+        return unless @_object && attribute_present?(name) && resolve_condition(options)
 
-    # Indicates an attribute or method should be included in the json output
-    # attribute :foo, :as => "bar"
-    # attribute :foo, :as => "bar", :if => lambda { |m| m.foo }
-    def attribute(name, options={})
-      if @_object && attribute_present?(name) && resolve_condition(options)
         attribute = data_object_attribute(name)
         name = (options[:as] || name).to_sym
         @_result[name] = attribute
       end
-    end
-    alias_method :attributes, :attribute
-
-    # Creates an arbitrary node that is included in the json output
-    # node(:foo) { "bar" }
-    # node(:foo, :if => lambda { |m| m.foo.present? }) { "bar" }
-    def node(name, options={}, &block)
-      return unless resolve_condition(options)
-      result = block.call(@_object)
-      if name.present?
-        @_result[name.to_sym] = result
-      elsif result.respond_to?(:each_pair) # merge hash into root hash
-        @_result.merge!(result)
+      alias_method :attributes, :attribute
+
+      # Creates an arbitrary node that is included in the json output
+      # node(:foo) { "bar" }
+      # node(:foo, :if => lambda { |m| m.foo.present? }) { "bar" }
+      def node(name, options = {}, &block)
+        return unless resolve_condition(options)
+
+        result = block.call(@_object)
+        if name.present?
+          @_result[name.to_sym] = result
+        elsif result.is_a?(Hash) # merge hash into root hash
+          @_result.merge!(result)
+        end
       end
-    end
-    alias_method :code, :node
-
-    # Creates a child node that is included in json output
-    # child(@user) { attribute :full_name }
-    # child(@user => :person) { ... }
-    # child(@users => :people) { ... }
-    def child(data, options={}, &block)
-      return false unless data.present? && resolve_condition(options)
-      name   = is_name_value?(options[:root]) ? options[:root] : data_name(data)
-      object = data_object(data)
-      include_root = is_collection?(object) && options.fetch(:object_root, @options[:child_root]) # child @users
-      engine_options = @options.slice(:child_root).merge(:root => include_root)
-      engine_options.merge!(:object_root_name => options[:object_root]) if is_name_value?(options[:object_root])
-      object = { object => name } if data.respond_to?(:each_pair) && object # child :users => :people
-      @_engines << { name.to_sym => self.object_to_engine(object, engine_options, &block) }
-    end
+      alias_method :code, :node
 
-    # Glues data from a child node to the json_output
-    # glue(@user) { attribute :full_name => :user_full_name }
-    def glue(data, options={}, &block)
-      return false unless data.present? && resolve_condition(options)
-      object = data_object(data)
-      @_engines << self.object_to_engine(object, :root => false, &block)
-    end
+      # Creates a child node that is included in json output
+      # child(@user) { attribute :full_name }
+      # child(@user => :person) { ... }
+      # child(@users => :people) { ... }
+      def child(data, options = {}, &block)
+        return unless data.present? && resolve_condition(options)
 
-    # Extends an existing rabl template with additional attributes in the block
-    # extends("users/show") { attribute :full_name }
-    def extends(file, options={}, &block)
-      return unless resolve_condition(options)
-      options = @options.slice(:child_root).merge(:object => @_object).merge(options)
-      @_engines << self.partial_as_engine(file, options, &block)
-    end
+        name   = is_name_value?(options[:root]) ? options[:root] : data_name(data)
+        object = data_object(data)
+
+        include_root = is_collection?(object) && options.fetch(:object_root, @options[:child_root]) # child @users
+        engine_options = @options.slice(:child_root).merge(:root => include_root)
+        engine_options.merge!(:object_root_name => options[:object_root]) if is_name_value?(options[:object_root])
+
+        object = { object => name } if data.is_a?(Hash) && object # child :users => :people
 
-    # Evaluate conditions given a symbol to evaluate
-    def call_condition_proc(condition, object, &blk)
-      blk = lambda { |v| v } unless block_given?
-      if condition.respond_to?(:call)
-        # condition is a block to pass to the block
-        blk.call(condition.call(object))
-      elsif condition.is_a?(Symbol) && object.respond_to?(condition)
-        # condition is a property of the object
-        blk.call(object.send(condition))
-      else
-        false
+        engines << { name.to_sym => object_to_engine(object, engine_options, &block) }
       end
-    end
 
-    # resolve_condition(:if => true) => true
-    # resolve_condition(:if => lambda { |m| false }) => false
-    # resolve_condition(:unless => lambda { |m| true }) => true
-    def resolve_condition(options)
-      return true if options[:if].nil? && options[:unless].nil?
-      result = nil
-      if options.has_key?(:if)
-        result = options[:if] == true || call_condition_proc(options[:if], @_object)
+      # Glues data from a child node to the json_output
+      # glue(@user) { attribute :full_name => :user_full_name }
+      def glue(data, options = {}, &block)
+        return unless data.present? && resolve_condition(options)
+
+        object = data_object(data)
+        engine = object_to_engine(object, :root => false, &block)
+        engines << engine if engine
       end
-      if options.has_key?(:unless)
-        inverse_proc = lambda { |r| !r }
-        result = options[:unless] == false || call_condition_proc(options[:unless], @_object, &inverse_proc)
+
+      # Extends an existing rabl template with additional attributes in the block
+      # extends("users/show") { attribute :full_name }
+      def extends(file, options = {}, &block)
+        return unless resolve_condition(options)
+
+        options = @options.slice(:child_root).merge(:object => @_object).merge(options)
+        engines << partial_as_engine(file, options, &block)
       end
-      result
-    end
 
-    private
+      # Evaluate conditions given a symbol to evaluate
+      def call_condition_proc(condition, object, &block)
+        block = lambda { |v| v } unless block_given?
 
-    # Checks if an attribute is present. If not, check if the configuration specifies that this is an error
-    # attribute_present?(created_at) => true
-    def attribute_present?(name)
-      if @_object.respond_to?(name)
-        return true
-      elsif Rabl.configuration.raise_on_missing_attribute
-        raise "Failed to render missing attribute #{name}"
-      else
-        return false
+        if condition.respond_to?(:call)
+          # condition is a block to pass to the block
+          block.call(condition.call(object))
+        elsif condition.is_a?(Symbol) && object.respond_to?(condition)
+          # condition is a property of the object
+          block.call(object.send(condition))
+        else
+          false
+        end
       end
-    end
 
-    # Returns a guess at the format in this scope
-    # request_format => "xml"
-    def request_format
-      format = @options[:format]
-      format && format != "hash" ? format : 'json'
-    end
+      # resolve_condition(:if => true) => true
+      # resolve_condition(:if => lambda { |m| false }) => false
+      # resolve_condition(:unless => lambda { |m| true }) => true
+      def resolve_condition(options)
+        return true if options[:if].nil? && options[:unless].nil?
+
+        result = nil
+        if options.has_key?(:if)
+          result = options[:if] == true || call_condition_proc(options[:if], @_object)
+        end
+
+        if options.has_key?(:unless)
+          inverse_proc = lambda { |r| !r }
+          result = options[:unless] == false || call_condition_proc(options[:unless], @_object, &inverse_proc)
+        end
 
-    # Caches the results of the block based on object cache_key
-    # cache_results { compile_hash(options) }
-    def cache_results(&block)
-      if template_cache_configured? && Rabl.configuration.cache_all_output && @_object.respond_to?(:cache_key)
-        result_cache_key = [@_object, @options[:root_name], @options[:format]]
-        fetch_result_from_cache(result_cache_key, &block)
-      else # skip cache
-        yield
+        result
       end
-    end
 
+    private
+      # Checks if an attribute is present. If not, check if the configuration specifies that this is an error
+      # attribute_present?(created_at) => true
+      def attribute_present?(name)
+        if @_object.respond_to?(name)
+          true
+        elsif Rabl.configuration.raise_on_missing_attribute
+          raise "Failed to render missing attribute #{name}"
+        else
+          false
+        end
+      end
+
+      # Returns a guess at the format in this context_scope
+      # request_format => "xml"
+      def request_format
+        format = @options[:format]
+        format = "json" if !format || format == "hash"
+        format
+      end
+
+      # Caches the results of the block based on object cache_key
+      # cache_results { compile_hash(options) }
+      def cache_results(&block)
+        if template_cache_configured? && Rabl.configuration.cache_all_output && @_object.respond_to?(:cache_key)
+          cache_key = [@_object, @options[:root_name], @options[:format]]
+
+          fetch_result_from_cache(cache_key, &block)
+        else # skip cache
+          yield
+        end
+      end
   end
 end