rabl 0.5.5.e → 0.5.5.f

data/CHANGELOG.md

@@ -1,11 +1,14 @@
 # CHANGELOG
 
-## 0.5.5.a-e
+## 0.5.5.a-f
 
  * Change engine to only instantiate one builder when rendering a collection
  * Alias to\_msgpack to to\_mpac
  * Cache template sources for faster partial lookups (thanks cj)
  * Adds BSON format support (thanks Antiarchitect)
+ * Use template lookup mechanism to find templates in Rails 3 (thanks blakewatters)
+ * Adds a 'object_root' option to collection (thanks blakewatters)
+ * Adds a 'root_name' option to collection
 
 ## 0.5.4
 

data/README.md

@@ -165,7 +165,9 @@ To enable, include the bson gem in your project's Gemfile. Then use Rabl as norm
 # Gemfile
 gem 'bson', '~> 1.5.2'
 ```
-To use it with Rails just register bson mime type format.
+
+To use it with Rails, also register the bson mime type format:
+
 ```ruby
 # config/initializers/mime_types.rb
 Mime::Type.register "application/bson", :bson
@@ -214,13 +216,20 @@ collection @users
 # => [ { "user" : { ... } } ]
 ```
 
-or even specify a root node label for the collection:
+or specify a root node label for the collection:
 
 ```ruby
 collection @users => :people
 # => { "people" : [ { "person" : { ... } } ] }
 ```
 
+or even specify both the child and root labels for a collection:
+
+```ruby
+collection @users, :root_name => "people", :object_root => "user"
+# => { "people" : [ { "user" : { ... } } ] }
+```
+
 and this will be used as the default data for the rendering.
 
 There can also be odd cases where the root-level of the response doesn't map directly to any object:

data/lib/rabl/builder.rb

@@ -3,25 +3,26 @@ module Rabl
     include Rabl::Partials
 
     # Constructs a new rabl hash based on given object and options
-    # options = { :format => "json", :attributes, :root => true,
-    #   :child_root => true, :node, :child, :glue, :extends }
+    # options = { :format => "json", :root => true, :child_root => true,
+    #   :attributes, :node, :child, :glue, :extends }
+    #
     def initialize(options={}, &block)
       @options    = options
       @_scope     = options[:scope]
     end
 
     # Given an object and options, returns the hash representation
-    # build(@user, :format => "json", :attributes => { ... })
-    def build(data, options={})
-      @_data      = data
-      @_object    = data_object(data)
+    # build(@user, :format => "json", :attributes => { ... }, :root_name => "user")
+    def build(object, options={})
+      @_object = object
       compile_hash(options)
     end
 
     protected
 
     # Returns a hash representation of the data object
-    # compile_hash(:root => true)
+    # compile_hash(:root_name => false)
+    # compile_hash(:root_name => "user")
     def compile_hash(options={})
       @_result = {}
       # Extends
@@ -46,8 +47,8 @@ module Rabl
       end if @options.has_key?(:glue)
 
       # Wrap result in root
-      if @options[:root] || options[:root]
-        @_root_name ||= data_name(@_data)
+      if options[:root_name].present?
+        @_root_name = options[:root_name]
       else # no root
         @_root_name = nil
       end

data/lib/rabl/engine.rb

@@ -31,17 +31,15 @@ module Rabl
     # to_hash(:root => true, :child_root => true)
     def to_hash(options={})
       options = @_options.merge(options)
-      data = data_object(@_data)
+      data, root_name = data_object(@_data), data_name(@_data)
       builder = Rabl::Builder.new(options)
       if is_object?(data) || !data # object @user
-        builder.build(@_data, options)
+        options[:root_name] = root_name if options[:root]
+        builder.build(data, options)
       elsif is_collection?(data) # collection @users
-        if options[:root] # only calculate root name if needed
-          object_name = data_name(@_data).to_s.singularize # @users => :users
-          data.map { |object| builder.build({ object => object_name }, options) }
-        else # skip root name
-          data.map { |object| builder.build(object, options) }
-        end
+        options[:root_name] = object_root_name if object_root_name
+        options[:root_name] ||= root_name.to_s.singularize if options[:root]
+        data.map { |object| builder.build(object, options) }
       end
     end
 
@@ -50,7 +48,7 @@ module Rabl
     def to_json(options={})
       include_root = Rabl.configuration.include_json_root
       options = options.reverse_merge(:root => include_root, :child_root => include_root)
-      result = defined?(@_collection_name) ? { @_collection_name => to_hash(options) } : to_hash(options)
+      result = collection_root_name ? { collection_root_name => to_hash(options) } : to_hash(options)
       format_json(result)
     end
 
@@ -59,7 +57,7 @@ module Rabl
     def to_msgpack(options={})
       include_root = Rabl.configuration.include_msgpack_root
       options = options.reverse_merge(:root => include_root, :child_root => include_root)
-      result = defined?(@_collection_name) ? { @_collection_name => to_hash(options) } : to_hash(options)
+      result = collection_root_name ? { collection_root_name => to_hash(options) } : to_hash(options)
       Rabl.configuration.msgpack_engine.pack result
     end
     alias_method :to_mpac, :to_msgpack
@@ -78,8 +76,8 @@ module Rabl
     def to_bson(options={})
       include_root = Rabl.configuration.include_bson_root
       options = options.reverse_merge(:root => include_root, :child_root => include_root)
-      result = if defined?(@_collection_name)
-                 { @_collection_name => to_hash(options) }
+      result = if collection_root_name
+                 { collection_root_name => to_hash(options) }
                elsif is_collection?(@_data) && @_data.is_a?(Array)
                  { data_name(@_data) => to_hash(options) }
                else
@@ -99,8 +97,12 @@ module Rabl
     # Sets the object as a collection casted to a simple array
     # collection @users
     # collection @users => :people
-    def collection(data)
-      @_collection_name = data.values.first if data.respond_to?(:each_pair)
+    # collection @users, :root => :person
+    # collection @users, :object_root => :person
+    def collection(data, options={})
+      @_collection_name = options[:root] if options[:root]
+      @_collection_name ||= data.values.first if data.respond_to?(:each_pair)
+      @_object_root_name = options[:object_root] if options[:object_root]
       self.object(data_object(data).to_a) if data
     end
 
@@ -155,8 +157,8 @@ module Rabl
     # Returns a guess at the default object for this template
     # default_object => @user
     def default_object
-      if @_scope.respond_to?(:controller)
-        full_name = @_scope.controller.controller_name
+      if context_scope.respond_to?(:controller)
+        full_name = context_scope.controller.controller_name
         instance_variable_get("@#{ full_name.split("::").last }")
       end
     end
@@ -164,8 +166,8 @@ module Rabl
     # Returns a guess at the format in this scope
     # request_format => "xml"
     def request_format
-      format = self.request_params.has_key?(:format) ? @_scope.params[:format] : nil
-      if request = @_scope.respond_to?(:request) && @_scope.request
+      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)
       end
       format && self.respond_to?("to_#{format}") ? format : "json"
@@ -174,7 +176,7 @@ module Rabl
     # Returns the request parameters if available in the scope
     # request_params => { :foo => "bar" }
     def request_params
-      @_scope.respond_to?(:params) ? @_scope.params : {}
+      context_scope.respond_to?(:params) ? context_scope.params : {}
     end
 
     # Returns data as json embraced with callback when detected
@@ -188,12 +190,12 @@ module Rabl
 
     # Augments respond to supporting scope methods
     def respond_to?(name, include_private=false)
-      @_scope.respond_to?(name, include_private) ? true : super
+      context_scope.respond_to?(name, include_private) ? true : super
     end
 
     # Supports calling helpers defined for the template scope using method_missing hook
     def method_missing(name, *args, &block)
-      @_scope.respond_to?(name) ? @_scope.send(name, *args, &block) : super
+      context_scope.respond_to?(name) ? context_scope.send(name, *args, &block) : super
     end
 
     def copy_instance_variables_from(object, exclude = []) #:nodoc:
@@ -210,6 +212,7 @@ module Rabl
       @_options[:child] = []
       @_options[:glue] = []
       @_options[:extends] = []
+      @_options[:root_name]  = nil
     end
   end
 end

data/lib/rabl/helpers.rb

@@ -23,7 +23,8 @@ module Rabl
       if data.respond_to?(:first)
         data_name(data.first).to_s.pluralize if data.first.present?
       else # actual data object
-        object_name = @_collection_name.to_s.singularize if defined? @_collection_name
+        object_name = object_root_name if object_root_name
+        object_name ||= collection_root_name.to_s.singularize if collection_root_name
         object_name ||= data.class.respond_to?(:model_name) ? data.class.model_name.element : data.class.to_s.downcase
         object_name
       end
@@ -42,5 +43,25 @@ module Rabl
       obj && data_object(obj).respond_to?(:each)
     end
 
+    # Returns the 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
+    end
+
+    # Returns the root (if any) name for an object within a collection
+    # Sets the name of the object i.e "person"
+    # => { "users" : [{ "person" : {} }] }
+    def object_root_name
+      defined?(@_object_root_name) ? @_object_root_name : nil
+    end
+
+    # Returns the root for the collection
+    # Sets the name of the collection i.e "people"
+    #  => { "people" : [] }
+    def collection_root_name
+      defined?(@_collection_name) ? @_collection_name : nil
+    end
+
   end
 end

data/lib/rabl/partials.rb

@@ -7,6 +7,7 @@ module Rabl
     # options must have :object
     # options can have :view_path, :child_root, :root
     def partial(file, options={}, &block)
+      raise ArgumentError, "Must provide an :object option to render a partial" unless options[:object]
       object, view_path = options.delete(:object), options.delete(:view_path)
       source, location = self.fetch_source(file, :view_path => view_path)
       engine_options = options.merge(:source => source, :source_location => location)
@@ -35,9 +36,16 @@ module Rabl
           # Padrino chops the extension, stitch it back on
           file_path = File.join(@_scope.settings.views, (file_path.to_s + ".rabl"))
         elsif defined? Rails
-          root_path = Rails.root
-          view_path = options[:view_path] || File.join(root_path, "app/views/")
-          file_path = Dir[File.join(view_path, file + ".{*.,}rabl")].first
+          if defined?(@_scope) && @_scope.respond_to?(:find_template)
+            # use Rails's own template resolution mechanism (partials and no partial)
+            lookup_proc = lambda { |partial| @_scope.find_template(file, [], partial) }
+            template = lookup_proc.call(false) rescue lookup_proc.call(true)
+            file_path = File.join(Rails.root.to_s, template.inspect) if template
+          else # fallback to manual
+            root_path = Rails.root
+            view_path = options[:view_path] || File.join(root_path, "app/views/")
+            file_path = Dir[File.join(view_path, file + ".{*.,}rabl")].first
+          end
         elsif defined? Sinatra
           view_path = options[:view_path] || @_scope.settings.views
           file_path = Dir[File.join(view_path, file + ".{*.,}rabl")].first

data/lib/rabl/version.rb

@@ -1,3 +1,3 @@
 module Rabl
-  VERSION = "0.5.5.e"
+  VERSION = "0.5.5.f"
 end

data/test/builder_test.rb

@@ -28,7 +28,7 @@ context "Rabl::Builder" do
 
       setup { builder({ :attributes => { :name => :name } }) }
       asserts "that the object is set properly" do
-        topic.build(User.new, :root => true)
+        topic.build(User.new, :root_name => "user")
       end.equivalent_to({ "user" => { :name => "rabl" } })
 
     end
@@ -37,7 +37,7 @@ context "Rabl::Builder" do
 
      setup { builder({ :attributes => { :name => :name } }) }
       asserts "that the object is set properly" do
-        topic.build({ User.new => "person" }, :root => true)
+        topic.build(User.new, :root_name => "person")
       end.equivalent_to({ "person" => { :name => "rabl" } })
 
     end

data/test/engine_test.rb

@@ -263,15 +263,32 @@ context "Rabl::Engine" do
         template.render(scope)
       end.equals "[{},{}]"
 
-      asserts "that it sets root node for objects" do
+      asserts "that it sets root node for objects using hash" do
         template = rabl %{
-          collection @users => :person
+          collection @users => :people
         }
         scope = Object.new
         scope.instance_variable_set :@users, [User.new, User.new]
         template.render(scope)
-      end.equals "{\"person\":[{},{}]}"
+      end.equals "{\"people\":[{},{}]}"
 
+    asserts "that it sets root node for objects using root option" do
+        template = rabl %{
+          collection @users, :root => :people
+        }
+        scope = Object.new
+        scope.instance_variable_set :@users, [User.new, User.new]
+        template.render(scope)
+      end.equals "{\"people\":[{},{}]}"
+
+      asserts "that it sets root node for objects using object_root option" do
+        template = rabl %{
+          collection @users, :root => :humans, :object_root => :person
+        }
+        scope = Object.new
+        scope.instance_variable_set :@users, [User.new, User.new]
+        template.render(scope)
+      end.equals %Q^{"humans":[{"person":{}},{"person":{}}]}^
     end
 
     context "#attribute" do

metadata

@@ -2,7 +2,7 @@
 name: rabl
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.5.5.e
+  version: 0.5.5.f
 platform: ruby
 authors: 
 - Nathan Esquenazi