rabl 0.11.1 → 0.11.2

data/lib/rabl/helpers.rb

@@ -10,8 +10,9 @@ module Rabl
     # 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.respond_to?(data) ? @_object.__send__(data) : data
+      data = data.keys.first if data.is_a?(Hash) && data.keys.size == 1
+      data = @_object.__send__(data) if data.is_a?(Symbol) && defined?(@_object) && @_object && @_object.respond_to?(data)
+      data
     end
 
     # data_object_attribute(data) => @_object.send(data)
@@ -28,14 +29,19 @@ module Rabl
     # data_name([]) => "array"
     def data_name(data_token)
       return unless data_token # nil or false
+
       return data_token.values.first if data_token.is_a?(Hash) # @user => :user
+
       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.nil? && data.respond_to?(:first)
           first = data.first
           object_name = data_name(first).to_s.pluralize if first.present?
         end
+
         object_name ||= data_token if data_token.is_a?(Symbol)
         object_name
       elsif is_object?(data) # data is an object
@@ -54,8 +60,9 @@ module Rabl
     # determine_object_root(@user, :user, true) => "user"
     # determine_object_root(@user, :person) => "person"
     # determine_object_root([@user, @user]) => "user"
-    def determine_object_root(data_token, data_name=nil, include_root=true)
+    def determine_object_root(data_token, data_name = nil, include_root = true)
       return if object_root_name == false
+
       root_name = data_name.to_s if include_root
       if is_object?(data_token) || data_token.nil?
         root_name
@@ -78,13 +85,17 @@ module Rabl
     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 }
+        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
+    # Returns the context_scope wrapping this engine, used for retrieving data, invoking methods, etc
     # In Rails, this is the controller and in Padrino this is the request context
     def context_scope
-      defined?(@_scope) ? @_scope : nil
+      defined?(@_context_scope) ? @_context_scope : nil
+    end
+
+    def view_path
+      defined?(@_view_path) ? @_view_path : nil
     end
 
     # Returns the root (if any) name for an object within a collection
@@ -106,14 +117,34 @@ module Rabl
       val.is_a?(String) || val.is_a?(Symbol)
     end
 
+    # 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_engine(object, options = {}, &block)
+      return if object.nil?
+
+      return [] if is_collection?(object) && object.blank? # empty collection
+
+      options = { 
+        :format     => "hash", 
+        :view_path  => view_path, 
+        :root       => (options[:root] || false)
+      }.merge(options)
+      
+      Engine.new(options[:source], options).apply(context_scope, :object => object, :locals => options[:locals], &block)
+    end
+
     # Fetches a key from the cache and stores rabl template result otherwise
     # fetch_from_cache('some_key') { ...rabl template result... }
-    def fetch_result_from_cache(cache_key, cache_options=nil, &block)
+    def fetch_result_from_cache(cache_key, cache_options = nil, &block)
       expanded_cache_key = ActiveSupport::Cache.expand_cache_key(cache_key, :rabl)
       Rabl.configuration.cache_engine.fetch(expanded_cache_key, cache_options, &block)
     end
 
-    def write_result_to_cache(cache_key, cache_options=nil, &block)
+    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)

data/lib/rabl/multi_builder.rb

@@ -1,23 +1,32 @@
 module Rabl
   class MultiBuilder
+    include Helpers
+    
     # 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 = {}
+    def initialize(data, settings = {}, options = {})
+      @data                 = data
+      @settings             = settings
+      @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) }
+      if template_cache_configured? && Rabl.configuration.use_read_multi
+        map_engines_to_builders
+        read_cache_results
+        replace_engines_with_cache_results
+      end
+
+      result = @builders.map(&:to_hash)
+      result = result.map(&:presence).compact if Rabl.configuration.exclude_empty_values_in_collections
+      result
     end
 
     private
@@ -26,12 +35,13 @@ module Rabl
     # 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
+      @builders = @data.map do |object|
+        Builder.new(object, @settings, @options)
+      end
+    end
 
+    def map_engines_to_builders
+      @builders.each do |builder|
         builder.engines.each do |engine|
           @engine_to_builder[engine] = builder
 

data/lib/rabl/partials.rb

@@ -1,113 +1,18 @@
 module Rabl
   module Partials
-    include Rabl::Helpers
+    include Helpers
+    include Sources
 
-    # 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)
+    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_engine(object, engine_options, &block)
-    end
-
-    # 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_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).apply(@_scope, :object => object, :locals => options[:locals], &block)
-    end
 
-    # Returns source for a given relative file
-    # fetch_source("show", :view_path => "...") => "...contents..."
-    def fetch_source(file, options={})
-      view_paths = Array(options[:view_path]) + Array(Rabl.configuration.view_paths)
-      Rabl.source_cache(file, view_paths) do
-        file_path = if defined?(Padrino) && context_scope.respond_to?(:settings) && context_scope.respond_to?(:resolve_template)
-          fetch_padrino_source(file, options)
-        elsif defined?(Rails) && context_scope.respond_to?(:view_paths)
-          _view_paths = view_paths + Array(context_scope.view_paths.to_a)
-          fetch_rails_source(file, options) || fetch_manual_template(_view_paths, file)
-        elsif defined?(Sinatra) && context_scope.respond_to?(:settings)
-          fetch_sinatra_source(file, options)
-        else # generic template resolution
-          fetch_manual_template(view_paths, file)
-        end
+      object    = options.delete(:object)
+      view_path = options[:view_path] || view_path
 
-        unless File.exist?(file_path.to_s)
-          raise "Cannot find rabl template '#{file}' within registered (#{view_paths.map(&:to_s).inspect}) view paths!"
-        end
+      source, location = fetch_source(file, :view_path => view_path)
 
-        [File.read(file_path.to_s), file_path.to_s]
-      end
+      options = options.merge(:source => source, :source_location => location, :template => file)
+      object_to_engine(object, options, &block)
     end
-
-    private
-
-    # Returns the rabl template path for padrino views using configured views
-    def fetch_padrino_source(file, options={})
-      view_path = Array(options[:view_path] || context_scope.settings.views)
-      # use Padrino's own template resolution mechanism
-      file_path, _ = context_scope.instance_eval { resolve_template(file) }
-      # Padrino chops the extension, stitch it back on
-      File.join(view_path.first.to_s, (file_path.to_s + ".rabl"))
-    end
-
-    # Returns the rabl template path for Rails, including special lookups for Rails 2 and 3
-    def fetch_rails_source(file, options={})
-      # use Rails template resolution mechanism if possible (find_template)
-      source_format = request_format if defined?(request_format)
-      if source_format && context_scope.respond_to?(:lookup_context) # Rails 3
-        lookup_proc = lambda { |partial|
-          if ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR < 2
-            context_scope.lookup_context.find(file, [], partial)
-          else # Rails 3.2 and higher
-            # pull format directly from rails unless it is html
-            request_format = context_scope.request.format.to_sym
-            source_format = request_format unless request_format == :html
-            context_scope.lookup_context.find(file, [], partial, [], {:formats => [source_format]})
-          end }
-        template = lookup_proc.call(false) rescue nil
-        template ||= lookup_proc.call(true) rescue nil
-        template.identifier if template
-      elsif source_format && context_scope.respond_to?(:view_paths) # Rails 2
-        template = context_scope.view_paths.find_template(file, source_format, false)
-        template.filename if template
-      end
-    end
-
-    # Returns the rabl template path for sinatra views using configured views
-    def fetch_sinatra_source(file, options={})
-      view_path = Array(options[:view_path] || context_scope.settings.views)
-      fetch_manual_template(view_path, file)
-    end
-
-    # Returns the rabl template by looking up files within the view_path and specified file path
-    def fetch_manual_template(view_path, file)
-      Dir[File.join("{#{view_path.join(",")}}", "{#{file},#{partialized(file)}}" + ".{*.,}rabl")].first
-    end
-
-    # Returns a partialized version of a file path
-    # partialized("v1/variants/variant") => "v1/variants/_variant"
-    def partialized(file)
-      partial_file = file.split(File::SEPARATOR)
-      partial_file[-1] = "_#{partial_file[-1]}" unless partial_file[-1].start_with?("_")
-      partial_file.join(File::SEPARATOR)
-    end
-
-  end # Partials
-end # Rabl
+  end
+end

data/lib/rabl/railtie.rb

@@ -1,6 +1,5 @@
 module Rabl
   class Railtie < Rails::Railtie
-
     initializer "rabl.initialize" do |app|
       ActiveSupport.on_load(:action_view) do
         Rabl.register!
@@ -12,6 +11,5 @@ module Rabl
         end
       end
     end
-
   end # Railtie
 end # Rabl

data/lib/rabl/renderer.rb

@@ -11,6 +11,8 @@ module Rabl
       CODE
     end
 
+    attr_reader :object, :options
+
     # Public: Instantiate a new renderer
     # This is a standalone class used for rendering rabl templates
     # outside of a framework like Rails. You may want to use
@@ -21,69 +23,77 @@ module Rabl
     #   renderer = Rabl::Renderer.new('template_name', user, { :format => 'json', :view_path => 'app/views' })
     #   renderer.render # => '{"user":{"name": "ivan" }}'
     #
-    attr_reader :object, :options
     def initialize(source, object = nil, options = {})
       options = {
-        :format => :json,
-        :scope => self,
-        :view_path => [],
-        :template => source
-      }.update(options)
+        :format     => :json,
+        :scope      => self,
+        :view_path  => [],
+        :template   => source
+      }.merge(options)
 
-      @options = options
-      @object = object
+      @options  = options
+      @object   = object
 
-      engine.source = self.process_source(source)
+      engine.source = process_source(source)
     end
 
     # Public: Actually render the template to the requested output format.
     #
     # - context_scope:
-    #     Override the render scope to the 'scope' object. Defaults to self.
+    #     Override the render context_scope to the 'context_scope' object. Defaults to self.
     #
     # Returns: And object representing the tranformed object in the requested format.
     #   e.g. json, xml, bson, plist
     def render(context_scope = nil)
-      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)
+      context_scope ||= options[:scope] || self
+
+      set_object_instance_variable if context_scope == self
+
+      locals = { :object => object }.merge(options.fetch(:locals, {}))
+
       engine.apply(context_scope, locals).render
     end
 
     protected
+      def engine
+        @engine ||= Rabl::Engine.new(nil, options)
+      end
 
-    def engine
-      @engine ||= Rabl::Engine.new(nil, options)
-    end
+      # Returns the source given a relative template path
+      def process_source(source)
+        return source if source.is_a?(String) && source =~ /\n/
 
-    # Returns the source given a relative template path
-    def process_source(source)
-      return source if source.is_a?(String) && source =~ /\n/
-      source, _ = engine.fetch_source(source, { :view_path => options[:view_path] })
-      source
-    end
+        source, _ = engine.fetch_source(source, { :view_path => options[:view_path] })
+        source
+      end
 
-    # Internal: Sets an instance variable named after the class of `object`
-    #
-    # Example:
-    #   object.class.name # => User
-    #   set_instance_variable(object) # => @user
-    #
-    def set_instance_variable(object)
-      name = model_name(object).split('/').last
-      instance_variable_set(:"@#{name}", object)
-    end
+      # Internal: Sets an instance variable named after the class of `object`
+      #
+      # Example:
+      #   object.class.name # => User
+      #   set_object_instance_variable # => @user == object
+      #
+      def set_object_instance_variable
+        instance_variable_set(:"@#{object_model_name}", object)
+      end
 
-    # Internal: Returns the model name for an object
-    #
-    # Example:
-    #  model_name(@post) => "@post"
-    #
-    def model_name(object)
-      item = object.is_a?(Array) ? object.first : object
-      name = item.class.name.underscore
-      object.is_a?(Array) ? name.pluralize : name
-    end
+      # Internal: Returns the model name for an object
+      #
+      # Example:
+      #   object.class.name # => User
+      #   object_model_name => "user"
+      #
+      def object_model_name
+        item = object
+
+        is_collection = item.is_a?(Array)
+        item = item.first if is_collection
+
+        name = item.class.name.underscore
 
+        name = name.pluralize if is_collection
+
+        name.split("/").last
+      end
   end
 end

data/lib/rabl/sources.rb

@@ -0,0 +1,87 @@
+module Rabl
+  module Sources
+    include Helpers
+
+    # Returns source for a given relative file
+    # fetch_source("show", :view_path => "...") => "...contents..."
+    def fetch_source(file, options = {})
+      view_paths = Array(options[:view_path]) + Array(Rabl.configuration.view_paths)
+
+      Rabl.source_cache(file, view_paths) do
+        file_path = \
+          if defined?(Padrino) && context_scope.respond_to?(:settings) && context_scope.respond_to?(:resolve_template)
+            fetch_padrino_source(file, options)
+          elsif defined?(Rails) && context_scope.respond_to?(:view_paths)
+            _view_paths = view_paths + Array(context_scope.view_paths.to_a)
+            fetch_rails_source(file, options) || fetch_manual_template(_view_paths, file)
+          elsif defined?(Sinatra) && context_scope.respond_to?(:settings)
+            fetch_sinatra_source(file, options)
+          else # generic template resolution
+            fetch_manual_template(view_paths, file)
+          end
+
+        unless File.exist?(file_path.to_s)
+          raise "Cannot find rabl template '#{file}' within registered (#{view_paths.map(&:to_s).inspect}) view paths!"
+        end
+
+        [File.read(file_path.to_s), file_path.to_s]
+      end
+    end
+
+    private
+      # Returns the rabl template path for padrino views using configured views
+      def fetch_padrino_source(file, options = {})
+        view_path = Array(options[:view_path] || context_scope.settings.views)
+
+        # use Padrino's own template resolution mechanism
+        file_path, _ = context_scope.instance_eval { resolve_template(file) }
+
+        # Padrino chops the extension, stitch it back on
+        File.join(view_path.first.to_s, (file_path.to_s + ".rabl"))
+      end
+
+      # Returns the rabl template path for Rails, including special lookups for Rails 2 and 3
+      def fetch_rails_source(file, options = {})
+        # use Rails template resolution mechanism if possible (find_template)
+        source_format = request_format if defined?(request_format)
+
+        if source_format && context_scope.respond_to?(:lookup_context) # Rails 3
+          lookup_proc = lambda do |partial|
+            if ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR < 2
+              context_scope.lookup_context.find(file, [], partial)
+            else # Rails 3.2 and higher
+              # pull format directly from rails unless it is html
+              request_format = context_scope.request.format.to_sym
+              source_format = request_format unless request_format == :html
+              context_scope.lookup_context.find(file, [], partial, [], { :formats => [source_format] })
+            end
+          end
+          template = lookup_proc.call(false) rescue nil
+          template ||= lookup_proc.call(true) rescue nil
+          template.identifier if template
+        elsif source_format && context_scope.respond_to?(:view_paths) # Rails 2
+          template = context_scope.view_paths.find_template(file, source_format, false)
+          template.filename if template
+        end
+      end
+
+      # Returns the rabl template path for sinatra views using configured views
+      def fetch_sinatra_source(file, options = {})
+        view_path = Array(options[:view_path] || context_scope.settings.views)
+        fetch_manual_template(view_path, file)
+      end
+
+      # Returns the rabl template by looking up files within the view_path and specified file path
+      def fetch_manual_template(view_path, file)
+        Dir[File.join("{#{view_path.join(",")}}", "{#{file},#{partialized(file)}}" + ".{*.,}rabl")].first
+      end
+
+      # Returns a partialized version of a file path
+      # partialized("v1/variants/variant") => "v1/variants/_variant"
+      def partialized(file)
+        partial_file = file.split(File::SEPARATOR)
+        partial_file[-1] = "_#{partial_file[-1]}" unless partial_file[-1].start_with?("_")
+        partial_file.join(File::SEPARATOR)
+      end
+  end # Partials
+end # Rabl