rabl 0.11.0 → 0.11.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTQ1YmY1YjA4YWM5YmIwNmI1Y2M3NDYzYjg0OWRmOGE3NTRiMjJiMg==
+    NGY4MzA3YzkzMGUxMjA5ZjNhOGYxMzRmZTZmMmY0MmMzMzY3ZDg5Zg==
   data.tar.gz: !binary |-
-    N2QxNDFjMjUwOTk2NTRhYmVmMWNiMjE3ZWQ5MmU4OWEyZTI5YzNlMQ==
+    OGNjZDBkZWYwM2MxYmQ1YmM4NWY3MDkyNzE3MWZhNjZmM2Q5MGIyNQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZmE2N2I2MGZhNWM1ZWM3YTFkMDNmNzMyODhlNGM2NTFiMTRhYWE5MjJlOTlj
-    YjljMzc5YWEzMmJjZjdjNDRkZTAyYjE2NDA1MTMxODg3NzE3NWU2ODZlNTNk
-    MjczY2Y1YjgxNGI0YTBhNzE5NTY3MWQzOGIzZGFlNGQ5OTgxNjc=
+    Y2I5OGZiYjk1NzM3YWVlMjA4NThmYTBiZmJhYzk5YWEwM2JlNzUwNGEyMjVk
+    ZDZjNGY1ODA5OWU2MmNmNGIyMWQ4YzM2ODJjZjk1Nzc2YzNjMDYwYjBmOGUw
+    NjEwNDQwNTg4MzhjZjM5MjBjMGU5ODRlODMxZGE3MWRjNjM0MWQ=
   data.tar.gz: !binary |-
-    MzBjMDE4YjY4ZjBiNmEzODY5NDZlMzI2OTI0ZjY4Mjk0M2YyMjVkYzY3YWZl
-    MWQ1MWMxNjM3NDlmMTc1ZmVmOGRiODkxOTc3YTU4YTM1NWJlNjc5YWVkMjBi
-    ZjNlNDZmNGZmODFiZWI5ZmJlNDAzYmQ3NjgyM2NiZGI2NmEwYzg=
+    ZDNkZGFjOGViN2ZkOWRjNjcwZTU1YzI3MGYxMDNmNGZiYjM2YjM4MmQxNDRk
+    ODNmOWZjNjdhMTIzM2E1YThiYzlmZjZjODdlMzFlODkwOWMyNmNiNmE3ZDM4
+    MjgwNjYzMmJmNzkzNGMzOTM5ZDE4Yjc0ODEzMWQ0YzYyY2IyZmY=

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 0.11.1 (October 19th)
+
+* NEW #417 Major rewrite caching layer to be much faster using read_multi (@ahlatimer, @DouweM)
+* FIX #589 Use set to speed up is_collection method check (@ccocchi)
+* FIX #584 Fix issues with newer releases of oj gem (@DouweM)
+
 ## 0.11.0 (August 16th)
 
 * Restore ruby 1.8 compatibility (@s01ipsist, @patrickdavey)

data/fixtures/rails3_2/test/functional/posts_controller_test.rb

@@ -126,7 +126,7 @@ context "PostsController" do
     asserts("contains post body")  { topic['body'] }.equals { @post1.body }
 
     # Attributes (custom name)
-    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.utc.to_s }
+    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.iso8601 }
 
     # Child
     asserts("contains post user child username") { topic["user"]["username"] }.equals { @post1.user.username }

data/fixtures/rails3_2/test/functional/users_controller_test.rb

@@ -35,7 +35,7 @@ context "UsersController" do
     # Attributes (custom name)
     asserts("contains registered_at") do
       json_output.map { |u| u["user"]["registered_at"] }
-    end.equals { @users.map(&:created_at).map(&:utc).map(&:to_s) }
+    end.equals { @users.map(&:created_at).map { |t| t.iso8601 } }
 
     # Node (renders based on attribute)
     asserts("contains role") do
@@ -64,7 +64,7 @@ context "UsersController" do
     asserts("contains email") { json_output["person"]["email"] }.equals { @user1.email }
     asserts("contains location") { json_output["person"]["location"] }.equals { @user1.location }
     # Attributes (custom name)
-    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.utc.to_s }
+    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.iso8601 }
     # Node (renders based on attribute)
     asserts("contains role node") { json_output["person"]["role"] }.equals "normal"
 

data/fixtures/rails4/Gemfile

@@ -8,6 +8,8 @@ gem 'sqlite3'
 gem 'rabl', :path => File.expand_path(File.dirname(__FILE__) + "/../../")
 gem 'riot', :group => "test"
 
+gem "oj"
+
 # Use SCSS for stylesheets
 gem 'sass-rails', '~> 4.0.0'
 

data/fixtures/rails4/test/functional/posts_controller_test.rb

@@ -111,7 +111,7 @@ context "PostsController" do
     asserts("contains post body")  { topic['body'] }.equals { @post1.body }
 
     # Attributes (custom name)
-    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.utc.to_s }
+    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.iso8601(3) }
 
     # Child
     asserts("contains post user child username") { topic["user"]["username"] }.equals { @post1.user.username }

data/fixtures/rails4/test/functional/users_controller_test.rb

@@ -35,7 +35,7 @@ context "UsersController" do
     # Attributes (custom name)
     asserts("contains registered_at") do
       json_output.map { |u| u["user"]["registered_at"] }
-    end.equals { @users.map(&:created_at).map(&:utc).map(&:to_s) }
+    end.equals { @users.map(&:created_at).map { |t| t.iso8601(3) } }
 
     # Node (renders based on attribute)
     asserts("contains role") do
@@ -64,7 +64,7 @@ context "UsersController" do
     asserts("contains email") { json_output["person"]["email"] }.equals { @user1.email }
     asserts("contains location") { json_output["person"]["location"] }.equals { @user1.location }
     # Attributes (custom name)
-    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.utc.to_s }
+    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.iso8601(3) }
     # Node (renders based on attribute)
     asserts("contains role node") { json_output["person"]["role"] }.equals "normal"
 

data/lib/rabl.rb

@@ -10,6 +10,7 @@ require 'rabl/helpers'
 require 'rabl/partials'
 require 'rabl/engine'
 require 'rabl/builder'
+require 'rabl/multi_builder'
 require 'rabl/configuration'
 require 'rabl/renderer'
 require 'rabl/cache_engine'

data/lib/rabl/builder.rb

@@ -23,24 +23,70 @@ module Rabl
     # build(@user, :format => "json", :attributes => { ... }, :root_name => "user")
     def build(object, options={})
       @_object = object
+      compile_engines
 
-      cache_results do
-        compile_hash(options)
+      unless options[:keep_engines]
+        cache_results { compile_hash(options) }
       end
     end
 
+    def engines
+      @_engines ||= []
+    end
+
+    def replace_engine(engine, value)
+      engines[engines.index(engine)] = value
+    end
+
+    def to_hash(options={})
+      cache_results { compile_hash(options) }
+    end
+
     protected
 
+    # Returns the builder with all engine-producing options evaluated.
+    # (extends, node, children, glues)
+    def compile_engines
+      @_engines = []
+
+      update_settings(:extends)
+      update_settings(:child)
+      update_settings(:glue)
+    end
+
     # Returns a hash representation of the data object
     # compile_hash(:root_name => false)
     # compile_hash(:root_name => "user")
     def compile_hash(options={})
       @_result = {}
-      update_settings(:extends)
+
       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
+
+        @_result.merge!(engine) if engine.is_a?(Hash)
+      end
+
+      @_engines = []
+
       update_settings(:node)
-      update_settings(:child)
-      update_settings(:glue)
 
       wrap_result(options[:root_name])
 
@@ -148,7 +194,7 @@ module Rabl
       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
-      @_result[name.to_sym] = self.object_to_hash(object, engine_options, &block)
+      @_engines << { name.to_sym => self.object_to_engine(object, engine_options, &block) }
     end
 
     # Glues data from a child node to the json_output
@@ -156,8 +202,7 @@ module Rabl
     def glue(data, options={}, &block)
       return false unless data.present? && resolve_condition(options)
       object = data_object(data)
-      glued_attributes = self.object_to_hash(object, :root => false, &block)
-      @_result.merge!(glued_attributes) if glued_attributes
+      @_engines << self.object_to_engine(object, :root => false, &block)
     end
 
     # Extends an existing rabl template with additional attributes in the block
@@ -165,8 +210,7 @@ module Rabl
     def extends(file, options={}, &block)
       return unless resolve_condition(options)
       options = @options.slice(:child_root).merge(:object => @_object).merge(options)
-      result = self.partial(file, options, &block)
-      @_result.merge!(result) if result.is_a?(Hash)
+      @_engines << self.partial_as_engine(file, options, &block)
     end
 
     # Evaluate conditions given a symbol to evaluate

data/lib/rabl/cache_engine.rb

@@ -21,5 +21,19 @@ module Rabl
       end
     end
 
+    def write(key, value, options={})
+      if defined?(Rails)
+        Rails.cache.write(key, value, options)
+      end
+    end
+
+    def read_multi(*keys)
+      options = keys.extract_options!
+      if defined?(Rails)
+        Rails.cache.read_multi(*keys, options)
+      else
+        keys.inject({}) { |hash, key| hash[key] = nil; hash }
+      end
+    end
   end
 end

data/lib/rabl/configuration.rb

@@ -19,7 +19,7 @@ end
 # Set default options for Oj json parser (if exists)
 begin
   require 'oj'
-  Oj.default_options =  { :mode => :compat, :time_format => :ruby }
+  Oj.default_options =  { :mode => :compat, :time_format => :ruby, :use_to_json => true }
 rescue LoadError
 end
 
@@ -47,6 +47,7 @@ module Rabl
     attr_accessor :cache_engine
     attr_accessor :raise_on_missing_attribute
     attr_accessor :perform_caching
+    attr_accessor :use_read_multi
     attr_accessor :replace_nil_values_with_empty_strings
     attr_accessor :replace_empty_string_values_with_nil_values
     attr_accessor :exclude_nil_values
@@ -75,6 +76,7 @@ module Rabl
       @view_paths                                   = []
       @cache_engine                                 = Rabl::CacheEngine.new
       @perform_caching                              = false
+      @use_read_multi                               = true
       @replace_nil_values_with_empty_strings        = false
       @replace_empty_string_values_with_nil_values  = false
       @exclude_nil_values                           = false

data/lib/rabl/engine.rb

@@ -19,12 +19,28 @@ module Rabl
     end
 
     # Renders the representation based on source, object, scope and locals
-    # Rabl::Engine.new("...source...", { :format => "xml" }).render(scope, { :foo => "bar", :object => @user })
-    def render(scope, locals, &block)
+    # 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)
       instance_exec(root_object, &block) if block_given?
-      cache_results { self.send("to_" + @_options[:format].to_s, @_options) }
+
+      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) }
+    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]]
     end
 
     # Returns a hash representation of the data object
@@ -38,7 +54,11 @@ module Rabl
       if is_object?(data) || !data # object @user
         result = builder.build(data, options)
       elsif is_collection?(data) # collection @users
-        result = data.map { |object| builder.build(object, options) }
+        result = if template_cache_configured? && Rabl.configuration.use_read_multi
+          read_multi(*data, options)
+        else
+          data.map { |object| builder.build(object, options) }
+        end
         result = result.map(&:presence).compact if Rabl.configuration.exclude_empty_values_in_collections
       end
       Rabl.configuration.escape_all_output ? escape_output(result) : result
@@ -208,6 +228,11 @@ module Rabl
     end
     alias_method :helpers, :helper
 
+    # Disables reading (but not writing) from the cache when rendering.
+    def cache_read_on_render=(c)
+      @_cache_read_on_render = c
+    end
+
     protected
 
     # Returns a guess at the default object for this template
@@ -263,6 +288,10 @@ module Rabl
       vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
     end
 
+    def cache_read_on_render
+      @_cache_read_on_render = @_cache_read_on_render.nil? ? true : @_cache_read_on_render
+    end
+
     private
 
     # Resets the options parsed from a rabl template.
@@ -273,6 +302,7 @@ module Rabl
       @_options[:glue] = []
       @_options[:extends] = []
       @_options[:root_name]  = nil
+      @_options[:read_multi] = false
       @_options[:scope] = scope
     end
 
@@ -287,12 +317,25 @@ module Rabl
         else # fallback for Rails 3, and Non-Rails app
           cache_key_simple(cache_key)
         end
-        fetch_result_from_cache(result_cache_key, cache_options, &block)
+
+        if self.cache_read_on_render
+          fetch_result_from_cache(result_cache_key, cache_options, &block)
+        else
+          write_result_to_cache(result_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

data/lib/rabl/helpers.rb

@@ -1,21 +1,24 @@
 require 'active_support/inflector' # for the sake of pluralizing
+require 'set'
 
 module Rabl
   module Helpers
     # Set of class names known to be objects, not collections
-    KNOWN_OBJECT_CLASSES = ['Struct', 'Hashie::Mash']
+    KNOWN_OBJECT_CLASSES = Set.new(['Struct', 'Hashie::Mash'])
 
     # data_object(data) => <AR Object>
     # data_object(@user => :person) => @user
     # data_object(:user => :person) => @_object.send(:user)
     def data_object(data)
       data = (data.is_a?(Hash) && data.keys.size == 1) ? data.keys.first : data
-      data.is_a?(Symbol) && defined?(@_object) && @_object ? @_object.__send__(data) : data
+      data.is_a?(Symbol) && defined?(@_object) && @_object && @_object.respond_to?(data) ? @_object.__send__(data) : data
     end
 
     # data_object_attribute(data) => @_object.send(data)
     def data_object_attribute(data)
-      @_object.__send__(data)
+      attribute = @_object.__send__(data)
+      attribute = attribute.as_json if is_collection?(attribute, false) && attribute.respond_to?(:as_json)
+      attribute
     end
 
     # data_name(data) => "user"
@@ -29,7 +32,7 @@ module Rabl
       data = data_object(data_token)
       if is_collection?(data) # data is a collection
         object_name = data.table_name if data.respond_to?(:table_name)
-        if !object_name && data.respond_to?(:first)
+        if object_name.nil? && data.respond_to?(:first)
           first = data.first
           object_name = data_name(first).to_s.pluralize if first.present?
         end
@@ -65,17 +68,17 @@ module Rabl
     # is_object?(@user) => true
     # is_object?([]) => false
     # is_object?({}) => false
-    def is_object?(obj)
-      obj && (!data_object(obj).respond_to?(:map) || !data_object(obj).respond_to?(:each) ||
-       (KNOWN_OBJECT_CLASSES & obj.class.ancestors.map(&:name)).any?)
+    def is_object?(obj, follow_symbols = true)
+      obj && !is_collection?(obj, follow_symbols)
     end
 
     # Returns true if the obj is a collection of items
     # is_collection?(@user) => false
     # is_collection?([]) => true
-    def is_collection?(obj)
-      obj && data_object(obj).respond_to?(:map) && data_object(obj).respond_to?(:each) &&
-        (KNOWN_OBJECT_CLASSES & obj.class.ancestors.map(&:name)).empty?
+    def is_collection?(obj, follow_symbols = true)
+      data_obj = follow_symbols ? data_object(obj) : obj
+      data_obj && data_obj.respond_to?(:map) && data_obj.respond_to?(:each) &&
+        obj.class.ancestors.none? { |a| KNOWN_OBJECT_CLASSES.include? a.name }
     end
 
     # Returns the scope wrapping this engine, used for retrieving data, invoking methods, etc
@@ -110,6 +113,13 @@ module Rabl
       Rabl.configuration.cache_engine.fetch(expanded_cache_key, cache_options, &block)
     end
 
+    def write_result_to_cache(cache_key, cache_options=nil, &block)
+      expanded_cache_key = ActiveSupport::Cache.expand_cache_key(cache_key, :rabl)
+      result = yield
+      Rabl.configuration.cache_engine.write(expanded_cache_key, result, cache_options)
+      result
+    end
+
     # Returns true if the cache has been enabled for the application
     def template_cache_configured?
       if defined?(Rails)

data/lib/rabl/multi_builder.rb

@@ -0,0 +1,89 @@
+module Rabl
+  class MultiBuilder
+    # Constructs a new MultiBuilder given the data and options.
+    # The options will be re-used for all Rabl::Builders.
+    # Rabl::MultiBuilder.new([#<User ...>, #<User ...>, ...], { :format => 'json', :child_root => true })   
+    def initialize(data, options={})
+      @data = data
+      @options = options
+      @builders = []
+      @engine_to_builder = {}
+      @cache_key_to_engine = {}
+    end
+
+    # Returns the result of all of the builders as an array
+    def to_a
+      generate_builders
+      read_cache_results
+      replace_engines_with_cache_results
+
+      @builders.map { |builder| builder.to_hash(@options) }
+    end
+
+    private
+
+    # Creates a builder for each of the data objects
+    # and maps the cache keys for each of the engines
+    # the builders generated
+    def generate_builders
+      @data.each do |object|
+        builder = Rabl::Builder.new(@options)
+        builder.build(object, @options.merge(:keep_engines => true))
+
+        @builders << builder
+
+        builder.engines.each do |engine|
+          @engine_to_builder[engine] = builder
+
+          map_cache_key_to_engine(engine)
+        end
+      end
+    end
+
+    # Maps a cache key to an engine
+    def map_cache_key_to_engine(engine)
+      if cache_key = cache_key_for(engine)
+        result_cache_key = ActiveSupport::Cache.expand_cache_key(cache_key, :rabl)
+        @cache_key_to_engine[result_cache_key] = engine
+        disable_cache_read_on_render(engine)
+      end
+    end
+
+    def disable_cache_read_on_render(engine)
+      if engine.is_a?(Hash)
+        disable_cache_read_on_render(engine.values.first)
+      else
+        engine.cache_read_on_render = false
+      end
+    end
+
+    def cache_key_for(engine)
+      if engine.is_a?(Hash)
+        cache_key_for(engine.values.first)
+      else
+        engine.cache_key
+      end
+    end
+
+    # Returns the items that were found in the cache
+    def read_cache_results
+      @cache_results ||= begin
+        mutable_keys = @cache_key_to_engine.keys.map { |k| k.dup }
+        if mutable_keys.empty?
+          {}
+        else
+          Rabl.configuration.cache_engine.read_multi(*mutable_keys)
+        end
+      end
+    end
+
+    # Maps the results from the cache back to the builders
+    def replace_engines_with_cache_results
+      @cache_results.each do |key, value|
+        engine = @cache_key_to_engine[key]
+        builder = @engine_to_builder[engine]
+        builder.replace_engine(engine, value) if value
+      end
+    end
+  end
+end

data/lib/rabl/partials.rb

@@ -2,29 +2,34 @@ module Rabl
   module Partials
     include Rabl::Helpers
 
-    # Renders a partial hash based on another rabl template
+    # 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 = self.partial_as_engine(file, options, &block)
+      engine.is_a?(Rabl::Engine) ? engine.render : engine
+    end
+
+    def partial_as_engine(file, options={}, &block)
       raise ArgumentError, "Must provide an :object option to render a partial" unless options.has_key?(:object)
       object, view_path = options.delete(:object), options[:view_path] || @_view_path
       source, location = self.fetch_source(file, :view_path => view_path)
       engine_options = options.merge(:source => source, :source_location => location, :template => file)
-      self.object_to_hash(object, engine_options, &block)
+      self.object_to_engine(object, engine_options, &block)
     end
 
-    # Returns a hash based representation of any data object given ejs template block
+    # Returns an Engine based representation of any data object given ejs template block
     # object_to_hash(@user) { attribute :full_name } => { ... }
     # object_to_hash(@user, :source => "...") { attribute :full_name } => { ... }
     # object_to_hash([@user], :source => "...") { attribute :full_name } => { ... }
     # options must have :source (rabl file contents)
     # options can have :source_location (source filename)
-    def object_to_hash(object, options={}, &block)
-      return object if object.nil?
+    def object_to_engine(object, options={}, &block)
+      return object unless !object.nil?
       return [] if is_collection?(object) && object.blank? # empty collection
       engine_options = options.reverse_merge(:format => "hash", :view_path => @_view_path, :root => (options[:root] || false))
-      Rabl::Engine.new(options[:source], engine_options).render(@_scope, :object => object, :locals => options[:locals], &block)
+      Rabl::Engine.new(options[:source], engine_options).apply(@_scope, :object => object, :locals => options[:locals], &block)
     end
 
     # Returns source for a given relative file

data/lib/rabl/renderer.rb

@@ -47,7 +47,7 @@ module Rabl
       context_scope = context_scope ? context_scope : options.delete(:scope) || self
       set_instance_variable(object) if context_scope == self
       locals = options.fetch(:locals, {}).reverse_merge(:object => object)
-      engine.render(context_scope, locals)
+      engine.apply(context_scope, locals).render
     end
 
     protected

data/lib/rabl/template.rb

@@ -12,7 +12,7 @@ if defined?(Tilt)
     end
 
     def evaluate(scope, locals, &block)
-      @engine.render(scope, locals, &block)
+      @engine.apply(scope, locals, &block).render
     end
   end
 
@@ -52,11 +52,12 @@ if defined?(ActionView) && defined?(Rails) && Rails.version.to_s =~ /^[34]/
           source = template.source
 
           %{ ::Rabl::Engine.new(#{source.inspect}).
-              render(self, assigns.merge(local_assigns)) }
+              apply(self, assigns.merge(local_assigns)).
+              render }
         end # call
       end # rabl class
     end # handlers
   end
 
   ActionView::Template.register_template_handler :rabl, ActionView::Template::Handlers::Rabl
-end
+end

data/lib/rabl/version.rb

@@ -1,3 +1,3 @@
 module Rabl
-  VERSION = "0.11.0"
+  VERSION = "0.11.1"
 end

data/test/builder_test.rb

@@ -178,29 +178,37 @@ context "Rabl::Builder" do
 
     asserts "that it generates with an object" do
       b = builder :child => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name } }]
+      e = Rabl::Engine.new('')
       mock(b).data_name(@user) { :user }
-      mock(b).object_to_hash(@user, { :root => false }).returns('xyz').subject
+      mock(e).render.returns('xyz')
+      mock(b).object_to_engine(@user, { :root => false }).returns(e).subject
       b.build(@user)
     end.equivalent_to({ :user => 'xyz'})
 
     asserts "that it generates with an collection and child_root" do
       b = builder :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }], :child_root => true
+      e = Rabl::Engine.new('')
       mock(b).data_name(@users) { :users }
-      mock(b).object_to_hash(@users, { :root => true, :child_root => true }).returns('xyz').subject
+      mock(e).render.returns('xyz')
+      mock(b).object_to_engine(@users, { :root => true, :child_root => true }).returns(e).subject
       b.build(@user)
     end.equivalent_to({ :users => 'xyz'})
 
     asserts "that it generates with an collection and no child root" do
       b = builder :child => [{ :data => @users, :options => {}, :block => lambda { |u| attribute :name } }], :child_root => false
+      e = Rabl::Engine.new('')
       mock(b).data_name(@users) { :users }
-      mock(b).object_to_hash(@users, { :root => false, :child_root => false }).returns('xyz').subject
+      mock(e).render.returns('xyz')
+      mock(b).object_to_engine(@users, { :root => false, :child_root => false }).returns(e).subject
       b.build(@user)
     end.equivalent_to({ :users => 'xyz'})
 
     asserts "that it generates with an collection and a specified object_root_name and root" do
       ops = { :object_root => "person", :root => :people }
       b = builder :child => [{ :data => @users, :options => ops, :block => lambda { |u| attribute :name } }], :child_root => true
-      mock(b).object_to_hash(@users, { :root => "person", :object_root_name => "person", :child_root => true }).returns('xyz').subject
+      e = Rabl::Engine.new('')
+      mock(e).render.returns('xyz')
+      mock(b).object_to_engine(@users, { :root => "person", :object_root_name => "person", :child_root => true }).returns(e).subject
       b.build(@user)
     end.equivalent_to({ :people => 'xyz'})
 
@@ -225,7 +233,9 @@ context "Rabl::Builder" do
 
     asserts "that it generates the glue attributes" do
       b = builder :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name }}]
-      mock(b).object_to_hash(@user, { :root => false }).returns({:user => 'xyz'}).subject
+      e = Rabl::Engine.new('')
+      mock(e).render.returns({:user => 'xyz'})
+      mock(b).object_to_engine(@user, { :root => false }).returns(e).subject
       b.build(@user)
     end.equivalent_to({ :user => 'xyz' })
 
@@ -236,27 +246,35 @@ context "Rabl::Builder" do
 
     asserts "that it does not generate new attributes if no glue attributes are present" do
       b = builder :glue => [{ :data => @user, :options => {}, :block => lambda { |u| attribute :name }}]
-      mock(b).object_to_hash(@user,{ :root => false }).returns({}).subject
+      e = Rabl::Engine.new('')
+      mock(e).render.returns({})
+      mock(b).object_to_engine(@user,{ :root => false }).returns(e).subject
       b.build(@user)
     end.equals({})
   end
 
-  context "#extend" do
-    asserts "that it does not genereate if no data is present" do
+  context "#extends" do
+    asserts "that it does not generate if no data is present" do
       b = builder :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
-      mock(b).partial('users/show',{ :object => @user }).returns({}).subject
+      e = Rabl::Engine.new('users/show')
+      mock(b).partial_as_engine('users/show',{ :object => @user}).returns(e)
+      mock(e).render.returns({}).subject
       b.build(@user)
     end.equals({})
 
     asserts "that it generates if data is present" do
       b = builder :extends => [{ :file => 'users/show', :options => {}, :block => lambda { |u| attribute :name  }}]
-      mock(b).partial('users/show', { :object => @user }).returns({:user => 'xyz'}).subject
+      e = Rabl::Engine.new('users/show')
+      mock(b).partial_as_engine('users/show',{ :object => @user}).returns(e)
+      mock(e).render.returns({:user => 'xyz'}).subject
       b.build(@user)
     end.equivalent_to({:user => 'xyz'})
 
     asserts "that it generates if local data is present but object is false" do
       b = builder :extends => [{ :file => 'users/show', :options => { :object => @user }, :block => lambda { |u| attribute :name  }}]
-      mock(b).partial('users/show', { :object => @user }).returns({:user => 'xyz'}).subject
+      e = Rabl::Engine.new('users/show')
+      mock(b).partial_as_engine('users/show',{ :object => @user}).returns(e)
+      mock(e).render.returns({:user => 'xyz'}).subject
       b.build(false)
     end.equivalent_to({:user => 'xyz'})
   end

data/test/engine_test.rb

@@ -442,9 +442,12 @@ context "Rabl::Engine" do
         scope = Object.new
         @user = User.new(:name => 'leo', :city => 'LA', :age => 12)
         scope.instance_variable_set :@user, @user
+        e = Rabl::Engine.new(nil)
+        mock(e).render.returns({ :name => 'leo', :city => 'LA', :age => 12 })
+
         any_instance_of(Rabl::Engine) do |b|
           mock(b).fetch_source("foo/bar", :view_path => nil).once
-          mock(b).object_to_hash(@user, :locals => { :foo => "bar" }, :source => nil, :source_location => nil, :template => 'foo/bar').returns({ :name => 'leo', :city => 'LA', :age => 12 })
+          mock(b).object_to_engine(@user, :locals => { :foo => "bar" }, :source => nil, :source_location => nil, :template => 'foo/bar').returns(e)
         end
         JSON.parse(template.render(scope))
       end.equals JSON.parse("{ \"foo\" : {\"name\":\"leo\",\"city\":\"LA\",\"age\":12} }")

data/test/integration/rails3_2/posts_controller_test.rb

@@ -126,7 +126,7 @@ context "PostsController" do
     asserts("contains post body")  { topic['body'] }.equals { @post1.body }
 
     # Attributes (custom name)
-    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.utc.to_s }
+    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.iso8601 }
 
     # Child
     asserts("contains post user child username") { topic["user"]["username"] }.equals { @post1.user.username }

data/test/integration/rails3_2/users_controller_test.rb

@@ -35,7 +35,7 @@ context "UsersController" do
     # Attributes (custom name)
     asserts("contains registered_at") do
       json_output.map { |u| u["user"]["registered_at"] }
-    end.equals { @users.map(&:created_at).map(&:utc).map(&:to_s) }
+    end.equals { @users.map(&:created_at).map { |t| t.iso8601 } }
 
     # Node (renders based on attribute)
     asserts("contains role") do
@@ -64,7 +64,7 @@ context "UsersController" do
     asserts("contains email") { json_output["person"]["email"] }.equals { @user1.email }
     asserts("contains location") { json_output["person"]["location"] }.equals { @user1.location }
     # Attributes (custom name)
-    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.utc.to_s }
+    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.iso8601 }
     # Node (renders based on attribute)
     asserts("contains role node") { json_output["person"]["role"] }.equals "normal"
 

data/test/integration/rails4/posts_controller_test.rb

@@ -111,7 +111,7 @@ context "PostsController" do
     asserts("contains post body")  { topic['body'] }.equals { @post1.body }
 
     # Attributes (custom name)
-    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.utc.to_s }
+    asserts("contains post posted_at") { topic['posted_at'] }.equals { @post1.created_at.iso8601(3) }
 
     # Child
     asserts("contains post user child username") { topic["user"]["username"] }.equals { @post1.user.username }

data/test/integration/rails4/users_controller_test.rb

@@ -35,7 +35,7 @@ context "UsersController" do
     # Attributes (custom name)
     asserts("contains registered_at") do
       json_output.map { |u| u["user"]["registered_at"] }
-    end.equals { @users.map(&:created_at).map(&:utc).map(&:to_s) }
+    end.equals { @users.map(&:created_at).map { |t| t.iso8601(3) } }
 
     # Node (renders based on attribute)
     asserts("contains role") do
@@ -64,7 +64,7 @@ context "UsersController" do
     asserts("contains email") { json_output["person"]["email"] }.equals { @user1.email }
     asserts("contains location") { json_output["person"]["location"] }.equals { @user1.location }
     # Attributes (custom name)
-    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.utc.to_s }
+    asserts("contains registered_at") { json_output["person"]["registered_at"] }.equals { @user1.created_at.iso8601(3) }
     # Node (renders based on attribute)
     asserts("contains role node") { json_output["person"]["role"] }.equals "normal"
 

data/test/multi_builder_test.rb

@@ -0,0 +1,70 @@
+require 'json'
+require File.expand_path('../teststrap', __FILE__)
+require 'rabl/template'
+require File.expand_path('../models/ormless', __FILE__)
+
+context "Rabl::MultiBuilder" do
+  helper(:multi_builder) { |objects, options| Rabl::MultiBuilder.new(objects, options) }
+  helper(:builder)       {                    Rabl::Builder.new({}) }
+  helper(:engine)        { |object|           Rabl::Engine.new("").apply(nil, :object => object) }
+
+  context "#initialize" do
+    setup do
+      Rabl::MultiBuilder.new([], {})
+    end
+
+    asserts_topic.assigns :options
+    asserts_topic.assigns :data
+    asserts_topic.assigns :engine_to_builder
+    asserts_topic.assigns :cache_key_to_engine
+  end
+
+  context "#to_a" do
+    setup do
+      Rabl::MultiBuilder.new([], {})
+    end
+
+    asserts "returns an array" do
+      topic.to_a
+    end.is_a?(Array)
+  end
+
+  context "#map_cache_key_to_engine" do
+    asserts "maps the cache keys to the engines" do
+      mb = multi_builder [], {}
+      b = builder
+      e = engine User.new
+      mock(e).cache_key.returns(['cache key'])
+      mb.send(:map_cache_key_to_engine, e)
+      mb.instance_variable_get('@cache_key_to_engine').values.include?(e)
+    end.equals(true)
+  end
+
+  context "#read_cache_results" do
+    setup do
+      mb = multi_builder [], {}
+      mb.instance_variable_set('@cache_key_to_engine', { 'cache_key' => engine(User.new) })
+      mb
+    end
+
+    asserts "uses read_multi to find all of the cached values with keys" do
+      mock(Rabl.configuration.cache_engine).read_multi('cache_key').returns({})
+      topic.send(:read_cache_results)
+    end
+  end
+
+  context "replace_engines_with_cache_results" do
+    asserts "replaces the builders' engines with the cache results" do
+      mb = multi_builder [], {}
+      e = engine User.new
+      b = builder
+      mb.instance_variable_set('@cache_key_to_engine', { 'cache_key' => e })
+      mb.instance_variable_set('@engine_to_builder', { e => b })
+      b.instance_variable_set('@_engines', [e])
+      mb.instance_variable_set('@cache_results', { 'cache_key' => '{}' })
+
+      mock(b).replace_engine(e, '{}')
+      mb.send(:replace_engines_with_cache_results)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabl
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Nathan Esquenazi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-17 00:00:00.000000000 Z
+date: 2014-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -415,6 +415,7 @@ files:
 - lib/rabl/digestor.rb
 - lib/rabl/engine.rb
 - lib/rabl/helpers.rb
+- lib/rabl/multi_builder.rb
 - lib/rabl/partials.rb
 - lib/rabl/railtie.rb
 - lib/rabl/renderer.rb
@@ -438,6 +439,7 @@ files:
 - test/models/ormless.rb
 - test/models/user.rb
 - test/msgpack_engine_test.rb
+- test/multi_builder_test.rb
 - test/partials_test.rb
 - test/plist_engine_test.rb
 - test/renderer_test.rb
@@ -485,6 +487,7 @@ test_files:
 - test/models/ormless.rb
 - test/models/user.rb
 - test/msgpack_engine_test.rb
+- test/multi_builder_test.rb
 - test/partials_test.rb
 - test/plist_engine_test.rb
 - test/renderer_test.rb