rabl-rails 0.5.2 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4807b83a2eb921feedfb2b1a183c8cc2a8f27ef6
-  data.tar.gz: 511aa8bd4d1c5c9b034b695545e083dd761e31b6
+SHA256:
+  metadata.gz: ac2d0bc8954f6b27e54002015d71ed0d00f4264c8c1d57411dc789216c627e44
+  data.tar.gz: 98757a9fe142bafb324782725e56e85e3ba83d5a018e76a75cda00c37c73ebf4
 SHA512:
-  metadata.gz: d17c495e276a6344ad8e9bbf2162aebf7e056f575367bcfde60399f683fceb90a5216a3b76155e42386b017411197b80afe7eeff96e8bdb31fc55c47f83ab1fe
-  data.tar.gz: 2cc491b7e1298cb12e25bb4e365d0c86ca87fff0b73f125a1abc11caa80f575ac5d0ac1cb27ebdf42eb4fe1e3fd101a46fe23e0e4a307a3f06982fd7f355585b
+  metadata.gz: d55bc5c73b2add30025cfb41a1735548a236928ca0372c4cbc2aeec731cfbb1db60376c9498570b0ea0a40e9e4c6f79caf32cc474698ad48163845fed5da5d3a
+  data.tar.gz: 4bb4b91c9f4045f94dca99ec126e8fb64389736f675af3ec85466f6c92b75844e1ddc30a8b61633ddce8531ed68d2a7e3b0abf0072a61b48c803f847c6084d28

data/.travis.yml

@@ -3,19 +3,14 @@ cache: bundler
 dist: trusty
 env:
   - "RAILS_VERSION=4.2.6"
-  - "RAILS_VERSION=master"
+  - "RAILS_VERSION=5.2.0"
+  - "RAILS_VERSION=6.1.0"
 rvm:
-  - 2.2.7
-  - 2.3.4
-  - 2.4.1
-  - jruby-9.1.12.0
-  - rbx-3.71
+  - 2.5.3
+  - 2.6.0
+  - 2.7.2
+  - jruby
 before_install:
   - gem update bundler
 matrix:
   fast_finish: true
-  allow_failures:
-    - env: RAILS_VERSION=master
-  exclude:
-    - rvm: 2.1.8
-      env: "RAILS_VERSION=master"

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # CHANGELOG
 
+## 0.6.2
+  * Add `fetch` node
+
+## 0.6.1
+  * Fix bug when template contains double quotes
+
+## 0.6.0 (yanked)
+  * Remove Rails 6+ warnings
+  * Uniformize node options
+  * Refresh README.md
+
+## 0.5.5
+  * Add `lookup` node
+
+## 0.5.4
+  * Relax concurrent-ruby version dependency (javierjulio)
+
+## 0.5.3
+  * Allow `extends` to accept lambdas
+
 ## 0.5.2
   * Add `const` node
 

data/Gemfile

@@ -8,7 +8,7 @@ rails = case rails_version
 when 'master'
   { github: 'rails/rails' }
 when "default"
-  '~> 4.2.5'
+  '~> 5.2.1'
 else
   "~> #{rails_version}"
 end

data/README.md

@@ -1,10 +1,10 @@
-# RABL for Rails [![Build Status](https://travis-ci.org/ccocchi/rabl-rails.png?branch=master)](https://travis-ci.org/ccocchi/rabl-rails)
+# RABL for Rails [![Build Status](https://travis-ci.org/ccocchi/rabl-rails.svg?branch=master)](https://travis-ci.org/ccocchi/rabl-rails)
 
-RABL (Ruby API Builder Language) is a ruby templating system for rendering resources in different format (JSON, XML, BSON, ...). You can find documentation [here](http://github.com/nesquena/rabl).
+`rabl-rails` is a ruby templating system for rendering your objects in different format (JSON, XML, PLIST).
 
-rabl-rails is **faster** and uses **less memory** than the standard rabl gem while letting you access the same features. There are some slight changes to do on your templates to get this gem to work but it should't take you more than 5 minutes.
+This gem aims for speed and little memory footprint while letting you build complex response with a very intuitive DSL.
 
-rabl-rails only targets **Rails 4.2+ application** and is compatible with mri 2.2+, jRuby and rubinius.
+`rabl-rails` targets **Rails 4.2/5/6 application** and have been testing with MRI and jRuby.
 
 ## Installation
 
@@ -17,23 +17,18 @@ gem install rabl-rails
 or add directly to your `Gemfile`
 
 ```
-gem 'rabl-rails'
+gem 'rabl-rails', '~> 0.6.0'
 ```
 
-And that's it !
-
 ## Overview
 
-Once you have installed rabl-rails, you can directly used RABL-rails templates to render your resources without changing anything to you controller. As example,
-assuming you have a `Post` model filled with blog posts, and a `PostController` that look like this :
+The gem enables you to build responses using views like you would using HTML/erb/haml.
+As example, assuming you have a `Post` model filled with blog posts, and a `PostController` that look like this:
 
 ```ruby
 class PostController < ApplicationController
-  respond_to :html, :json, :xml
-
   def index
 	 @posts = Post.order('created_at DESC')
-	  respond_with(@posts)
   end
 end
 ```
@@ -43,6 +38,7 @@ You can create the following RABL-rails template to express the API output of `@
 ```ruby
 # app/views/post/index.rabl
 collection :@posts
+
 attributes :id, :title, :subject
 child(:user) { attributes :full_name }
 node(:read) { |post| post.read_by?(@user) }
@@ -58,15 +54,13 @@ This would output the following JSON when visiting `http://localhost:3000/posts.
 }]
 ```
 
-That's a basic overview but there is a lot more to see such as partials, inheritance or fragment caching.
-
 ## How it works
 
-As opposed to standard RABL gem, this gem separate compiling (a.k.a transforming a RABL-rails template into a Ruby hash) and the actual rendering of the object or collection. This allow to only compile the template once and only Ruby hashes.
+This gem separates compiling, ie. transforming a RABL-rails template into a Ruby hash, and the actual rendering of the object or collection. This allows to only compile the template once (when template caching is enabled) which is the slow part, and only use hashes during rendering.
 
-The fact of compiling the template outside of any rendering context prevent us to use any instances variables (with the exception of node) in the template because they are rendering objects. So instead, you'll have to use symbols of these variables.For example, to render the collection `@posts` inside your `PostController`, you need to use `:@posts` inside of the template.
+The drawback of compiling the template outside of any rendering context is that we can't access instance variables like usual. Instead, you'll mostly use symbols representing your variables and the gem will retrieve them when needed.
 
-The only places where you can actually used instance variables  are into Proc (or lambda) or into custom node (because they are treated as Proc).
+There are places where the gem allows for "dynamic code" -- code that is evaluated at each rendering, such as within `node` or `condition` blocks.
 
 ```ruby
 # We reference the @posts varibles that will be used at rendering time
@@ -79,7 +73,7 @@ node(:read) { |post| post.read_by?(@user) }
 
 The same rule applies for view helpers such as `current_user`
 
-After the template is compiled into a hash, Rabl-rails will use a renderer to do the actual output. Actually, only JSON and XML formats are supported.
+After the template is compiled into a hash, `rabl-rails` will use a renderer to create the actual output. Currently, JSON, XML and PList formats are supported.
 
 ## Configuration
 
@@ -87,6 +81,7 @@ RablRails works out of the box, with default options and fastest engine availabl
 
 ```ruby
 # config/initializers/rabl_rails.rb
+
 RablRails.configure do |config|
   # These are the default
   # config.cache_templates = true
@@ -125,7 +120,7 @@ collection :@posts => :articles
 # => { "articles" : [{...}, {...}] }
 ```
 
-There are rares cases when the template doesn't map directly to any object. In these cases, you can set data to false or skip data declaration altogether.
+There are rares cases when the template doesn't map directly to any object. In these cases, you can set data to false.
 
 ```ruby
 object false
@@ -133,27 +128,15 @@ node(:some_count) { |_| @user.posts.count }
 child(:@user) { attribute :name }
 ```
 
-If you use gem like *decent_exposure* or *focused_controller*, you can use your variable directly without the leading `@`
+If you use gems like *decent_exposure* or *focused_controller*, you can use your variable directly without the leading `@`
 
 ```ruby
 object :object_exposed
 ```
 
-You can even skip data declaration at all. If you used `respond_with`, rabl-rails will render the data you passed to it.
-As there is no name, you can set a root via the `root` macro. This allow you to use your template without caring about variables passed to it.
-
-```ruby
-# in controller
-respond_with(@post)
-
-# in rabl-rails template
-root :article
-attribute :title
-```
-
 ### Attributes / Methods
 
-Basic usage is to declared attributes to include in the response. These can be database attributes or any instance method.
+Adds a new field to the response object, calling the method on the object being rendered. Methods called this way should return natives types from the format you're using (such as `String`, `integer`, etc for JSON). For more complex objects, see `child` nodes.
 
 ```ruby
 attributes :id, :title, :to_s
@@ -162,64 +145,108 @@ attributes :id, :title, :to_s
 You can aliases these attributes in your response
 
 ```ruby
-attributes title: :foo, to_s: :bar
-# => { "foo" : <title value>, "bar" : <to_s value> }
+attributes :my_custom_method, as: :title
+# => { "title" : <result of my_custom_method> }
 ```
 
-or show attributes only if a condition is true
+or show attributes based on a condition. The currently rendered object is given to the `proc` condition.
+
 ```ruby
 attributes :published_at, :anchor, if: ->(post) { post.published? }
 ```
 
 ### Child nodes
 
-You can include informations from data associated with the parent model or arbitrary data. These informations can be grouped under a node or directly merged into current node.
+Changes the object being rendered for the duration of the block. Depending on if you use `node` or `glue`, the result will be added as a new field or merged respectively.
+
+Data passed can be a method or a reference to an instance variable.
 
-For example if you have a `Post` model that belongs to a `User`
+For example if you have a `Post` model that belongs to a `User` and want to add the user's name to your response.
 
 ```ruby
 object :@post
-child(user: :author) do
+
+child(:user, as: :author) do
 	attributes :name
 end
-# => { "post" : { "author" : { "name" : "John D." } } }
+# => { "post": { "author" : { "name" : "John D." } } }
 ```
 
-You can also use arbitrary data source with child nodes
+If instead of having an `author` node in your response you wanted the name at the root level, you can use `glue`:
+
 ```ruby
-child(:@users) do
-	attributes :id, :name
+object :@post
+
+glue(:user) do
+  attributes :name, as: :author_name
 end
+# => { "post": { "author_name" : "John D." } }
 ```
 
-If you want to merge directly into current node, you can use the `glue` keywork
+Arbitrary data source can also be passed:
 
 ```ruby
-attribute :title
-glue(:user) do
-  attributes :name => :author_name
+# in your controller
+# @custom_data = [...]
+
+# in the view
+child(:@custom_data) do
+	attributes :id, :name
 end
-# => { "post" : { "title" : "Foo", "author_name" : "John D." } }
+# => { "custom_data": [...] }
 ```
 
-### Custom nodes
-
-You can create custom node in your response, based on the result of a given block
+You can use a Hash-like data source, as long as keys match a method or attribute of your main resource, using the `fetch` keyword:
 
 ```ruby
-object :@user
-node(:full_name) { |u| u.first_name + " " + u.last_name }
-# => { "user" : { "full_name" : "John Doe" } }
+# assuming you have something similar in your controller
+# @users_hash = { 1 => User.new(pseudo: 'Batman') }
+
+# in the view
+object :@post
+
+fetch(:@users_hash, as: :user, field: :user_id) do
+  attributes :pseudo
+end
+# => { user: { pseudo: 'Batman' } }
 ```
 
-or with an assigned constant
+This comes very handy when adding attributes from external queries not really bound to a relation, like statistics.
+
+### Constants
+
+Adds a new field to the response using an immutable value.
 
 ```ruby
 const(:api_version, API::VERSION)
 const(:locale, 'fr_FR')
 ```
 
-You can add condition on your custom nodes (if the condition is evaluated to false, the node will not be included).
+### Lookups
+
+Adds a new field to the response, using rendered resource's id by default or any method to fetch a value from the given hash variable.
+
+```ruby
+collection :@posts
+
+lookup(:comments_count, :@comments_count, field: :uuid, cast: false)
+# => [{ "comments_count": 3 }, { "comments_count": 6 }]
+```
+
+In the example above, for each post it will fetch the value from `@comments_count` using the post's `uuid` as key. When the `cast` value is set to `true` (it is `false` by default), the value will be casted to a boolean using `!!`.
+
+
+### Custom nodes
+
+Adds a new field to the response with block's result as value.
+
+```ruby
+object :@user
+node(:full_name) { |u| u.first_name + " " + u.last_name }
+# => { "user" : { "full_name" : "John Doe" } }
+```
+
+You can add condition on your custom nodes. If the condition evaluates to a falsey value, the node will not added to the response at all.
 
 ```ruby
 node(:email, if: ->(u) { u.valid_email? }) do |u|
@@ -227,13 +254,13 @@ node(:email, if: ->(u) { u.valid_email? }) do |u|
 end
 ```
 
-Nodes are evaluated at the rendering time, so you can use any instance variables or view helpers inside them
+Nodes are evaluated at rendering time, so you can use any instance variables or view helpers within them
 
 ```ruby
 node(:url) { |post| post_url(post) }
 ```
 
-If you want to include directly the result into the current node, use the `merge` keyword (result returned from the block should be a hash)
+If the result of the block is a Hash, it can be directly merge into the response using `merge` instead of `node`
 
 ```ruby
 object :@user
@@ -241,33 +268,42 @@ merge { |u| { name: u.first_name + " " + u.last_name } }
 # => { "user" : { "name" : "John Doe" } }
 ```
 
-Custom nodes are really usefull to create flexible representations of your resources.
-
 ### Extends & Partials
 
 Often objects have a basic representation that is shared accross different views and enriched according to it. To avoid code redundancy you can extend your template from any other RABL template.
 
 ```ruby
-# app/views/users/base.json.rabl
+# app/views/shared/_user.rabl
 attributes :id, :name
 
-# app/views/users/private.json.rabl
+# app/views/users/show.rabl
+object :@user
+
+extends('shared/_user')
 attributes :super_secret_attribute
 
-extends 'users/base'
-# or using partial instead of extends
-# merge { |u| partial('users/base', object: u) }
+#=> { "id": 1, "name": "John", "super_secret_attribute": "Doe" }
+```
+
+When used with child node, if they are the only thing added you can instead use the `partial` option directly.
+
+```ruby
+child(:user, partial: 'shared/_user')
+
+# is equivalent to
+
+child(:user) do
+  extends('shared/_user')
+end
 ```
 
-You can also extends template in child nodes using `partial` option (this is the same as using `extends` in the child block)
+Extends can be used dynamically using rendered object and lambdas.
 
 ```ruby
-collection @posts
-attribute :title
-child(:user, partial: 'users/base')
+extends ->(user) { "shared/_#{user.client_type}_infos" }
 ```
 
-Partials can also be used inside custom nodes. When using partial this way, you MUST declare the object associated to the partial
+Partials can also be used inside custom nodes. When using partial this way, you MUST declare the `object` associated to the partial
 
 ```ruby
 node(:location) do |user|
@@ -275,28 +311,33 @@ node(:location) do |user|
 end
 ```
 
-When used within `node`, partials can take locals variables that can be accessed in the included template.
+When used this way, partials can take locals variables that can be accessed in the included template.
+
 ```ruby
-# base.json.rabl
+# _credit_card.rabl
 node(:credit_card, if: ->(u) { locals[:display_credit_card] }) do |user|
   user.credit_card_info
 end
 
 # user.json.rabl
-merge { |u| partial('users/base', object: u, locals: { display_credit_card: true }) }
+merge { |u| partial('_credit_card', object: u, locals: { display_credit_card: true }) }
 ```
 
-### Nesting
+### Putting it all together
 
-Rabl allow you to define easily your templates, even with hierarchy of 2 or 3 levels. Let's suppose your have a `thread` model that has many `posts` and that each post has many `comments`. We can display a full thread in a few lines
+`rabl-rails` allows you to format your responses easily, from simple objects to hierarchy of 2 or 3 levels.
 
 ```ruby
 object :@thread
-attribute :caption
-child :posts do
-  attribute :title
-	child :comments do
-		extends 'comments/base'
+
+attribute :caption, as: :title
+
+child(:@sorted_posts, as: :posts) do
+  attributes :title, :slug
+
+  child :comments do
+		extends 'shared/_comment'
+    lookup(:upvotes, :@upvotes_per_comment)
 	end
 end
 ```
@@ -328,4 +369,4 @@ Want to make another change ? Just fork and contribute, any help is very much ap
 
 ## Copyright
 
-Copyright © 2012-2017 Christopher Cocchi-Perrier. See [MIT-LICENSE](http://github.com/ccocchi/rabl-rails/blob/master/MIT-LICENSE) for details.
+Copyright © 2012-2020 Christopher Cocchi-Perrier. See [MIT-LICENSE](http://github.com/ccocchi/rabl-rails/blob/master/MIT-LICENSE) for details.

data/lib/rabl-rails/compiler.rb

@@ -62,14 +62,15 @@ module RablRails
     # Creates a child node to be included in the output.
     # name_or data can be an object or collection or a method to call on the data. It
     # accepts :root and :partial options.
-    # Notes that partial and blocks are not compatible
+    # Note that partial and blocks are not compatible
     # Example:
     #   child(:@posts, :root => :posts) { attribute :id }
     #   child(:posts, :partial => 'posts/base')
     #
     def child(name_or_data, options = {})
       data, name  = extract_data_and_name(name_or_data)
-      name        = options[:root] if options.has_key? :root
+      name        = options[:root]  if options.has_key? :root
+      name        = options[:as]    if options.has_key? :as
       template    = partial_or_block(data, options) { yield }
       @template.add_node Nodes::Child.new(name, template)
     end
@@ -84,6 +85,21 @@ module RablRails
       @template.add_node Nodes::Glue.new(template)
     end
 
+    #
+    # Creates a node to be added to the output by fetching an object using
+    # current resource's field as key to the data, and appliying given
+    # template to said object
+    # Example:
+    #   fetch(:@stats, field: :id) { attributes :total }
+    #
+    def fetch(name_or_data, options = {})
+      data, name  = extract_data_and_name(name_or_data)
+      name        = options[:as] if options.key?(:as)
+      field       = options.fetch(:field, :id)
+      template    = partial_or_block(data, options) { yield }
+      @template.add_node Nodes::Fetch.new(name, template, field)
+    end
+
     #
     # Creates an arbitrary node in the json output.
     # It accepts :if option to create conditionnal nodes. The current data will
@@ -107,6 +123,16 @@ module RablRails
       @template.add_node Nodes::Const.new(name, value)
     end
 
+    #
+    # Create a node `name` by looking the current resource being rendered in the
+    # `object` hash using, by default, the resource's id.
+    # Example:
+    #   lookup(:favorite, :@user_favorites, cast: true)
+    #
+    def lookup(name, object, field: :id, cast: false)
+      @template.add_node Nodes::Lookup.new(name, object, field, cast)
+    end
+
     #
     # Merge arbitrary data into json output. Given block should
     # return a hash.
@@ -122,10 +148,16 @@ module RablRails
     # Extends an existing rabl template
     # Example:
     #   extends 'users/base'
+    #   extends ->(item) { "v1/#{item.class}/_core" }
     #   extends 'posts/base', locals: { hide_comments: true }
     #
-    def extends(path, options = nil)
-      other = Library.instance.compile_template_from_path(path, @view)
+    def extends(path_or_lambda, options = nil)
+      if path_or_lambda.is_a?(Proc)
+        @template.add_node Nodes::Polymorphic.new(path_or_lambda)
+        return
+      end
+
+      other = Library.instance.compile_template_from_path(path_or_lambda, @view)
 
       if options && options.is_a?(Hash)
         @template.add_node Nodes::Extend.new(other.nodes, options[:locals])
@@ -154,7 +186,7 @@ module RablRails
     protected
 
     def partial_or_block(data, options)
-      if options.key?(:partial)
+      if options&.key?(:partial)
         template = Library.instance.compile_template_from_path(options[:partial], @view)
         template.data = data
         template

data/lib/rabl-rails/configuration.rb

@@ -33,9 +33,9 @@ module RablRails
     def result_flags
       @result_flags ||= begin
         result = 0
-        result |= 0b01  if @replace_nil_values_with_empty_strings
-        result |= 0b10  if @replace_empty_string_values_with_nil
-        result |= 0b100 if @exclude_nil_values
+        result |= 0b001   if @replace_nil_values_with_empty_strings
+        result |= 0b010   if @replace_empty_string_values_with_nil
+        result |= 0b100   if @exclude_nil_values
         result
       end
     end

data/lib/rabl-rails/handler.rb

@@ -3,12 +3,12 @@ require 'active_support/core_ext/class/attribute'
 module RablRails
   module Handlers
     class Rabl
-      def self.call(template)
+      def self.call(template, source = nil)
         %{
           RablRails::Library.instance.
-            get_rendered_template(#{template.source.inspect}, self, local_assigns)
+            get_rendered_template(#{(source || template.source).inspect}, self, local_assigns)
         }
       end
     end
   end
-end
+end

data/lib/rabl-rails/library.rb

@@ -25,7 +25,7 @@ module RablRails
 
     def get_rendered_template(source, view, locals = nil)
       compiled_template = compile_template_from_source(source, view)
-      format = view.lookup_context.rendered_format || :json
+      format = view.lookup_context.formats.first || :json
       raise UnknownFormat, "#{format} is not supported in rabl-rails" unless RENDERER_MAP.key?(format)
       RENDERER_MAP[format].render(compiled_template, view, locals)
     end

data/lib/rabl-rails/nodes.rb

@@ -5,3 +5,6 @@ require 'rabl-rails/nodes/child'
 require 'rabl-rails/nodes/code'
 require 'rabl-rails/nodes/condition'
 require 'rabl-rails/nodes/extend'
+require 'rabl-rails/nodes/polymorphic'
+require 'rabl-rails/nodes/lookup'
+require 'rabl-rails/nodes/fetch'

data/lib/rabl-rails/nodes/fetch.rb

@@ -0,0 +1,12 @@
+module RablRails
+  module Nodes
+    class Fetch < Child
+      attr_reader :field
+
+      def initialize(name, template, field)
+        super(name, template)
+        @field = field
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/lookup.rb

@@ -0,0 +1,23 @@
+module RablRails
+  module Nodes
+    class Lookup
+      attr_reader :name, :data, :field
+
+      def initialize(name, data, field, cast = false)
+        @name   = name
+        @data   = data
+        @field  = field
+        @cast   = cast
+        @is_var = @data.to_s.start_with?('@')
+      end
+
+      def instance_variable_data?
+        @is_var
+      end
+
+      def cast_to_boolean?
+        @cast
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/polymorphic.rb

@@ -0,0 +1,11 @@
+module RablRails
+  module Nodes
+    class Polymorphic
+      attr_reader :template_lambda
+
+      def initialize(template_lambda)
+        @template_lambda = template_lambda
+      end
+    end
+  end
+end

data/lib/rabl-rails/version.rb

@@ -1,3 +1,3 @@
 module RablRails
-  VERSION = '0.5.2'
+  VERSION = '0.6.2'
 end

data/lib/rabl-rails/visitors/to_hash.rb

@@ -39,6 +39,18 @@ module Visitors
       @_result.merge!(sub_visit(object, n.nodes)) if object
     end
 
+    def visit_Fetch n
+      hash   = object_from_data(_resource, n)
+      key    = _resource.public_send(n.field)
+      object = hash[key]
+
+      @_result[n.name] = if object
+        collection?(object) ? object.map { |o| sub_visit(o, n.nodes) } : sub_visit(object, n.nodes)
+      else
+        nil
+      end
+    end
+
     def visit_Code n
       if !n.condition || instance_exec(_resource, &(n.condition))
         result = instance_exec _resource, &(n.block)
@@ -56,6 +68,15 @@ module Visitors
       @_result[n.name] = n.value
     end
 
+    def visit_Lookup n
+      object  = object_from_data(_resource, n)
+      key     = _resource.public_send(n.field)
+      value   = object[key]
+      value   = !!value if n.cast_to_boolean?
+
+      @_result[n.name] = value
+    end
+
     def visit_Condition n
       @_result.merge!(sub_visit(_resource, n.nodes)) if instance_exec _resource, &(n.condition)
     end
@@ -67,6 +88,12 @@ module Visitors
       @_locals = {}
     end
 
+    def visit_Polymorphic n
+      template_path = n.template_lambda.call(_resource)
+      template = RablRails::Library.instance.compile_template_from_path(template_path, @_context)
+      @_result.merge!(sub_visit(_resource, template.nodes))
+    end
+
     def result
       case RablRails.configuration.result_flags
       when 0

data/rabl-rails.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activesupport', '>= 4.2'
   s.add_dependency 'railties', '>= 4.2'
-  s.add_dependency 'concurrent-ruby', '~> 1.0.0'
+  s.add_dependency 'concurrent-ruby', '~> 1.0', ">= 1.0.2"
 
   s.add_development_dependency 'actionpack', '>= 4.2'
   s.add_development_dependency 'actionview', '>= 4.2'

data/test/helper.rb

@@ -49,8 +49,8 @@ class Context
       @format = format
     end
 
-    def rendered_format
-      @format.to_sym
+    def formats
+      [@format]
     end
   end
 

data/test/test_compiler.rb

@@ -11,13 +11,20 @@ class TestCompiler < Minitest::Test
     }
   end
 
+  @@view_class = if ActionView::Base.respond_to?(:with_empty_template_cache)
+    # From Rails 6.1
+    ActionView::Base.with_empty_template_cache
+  else
+    ActionView::Base
+  end
+
   describe 'compiler' do
     def extract_attributes(nodes)
       nodes.map(&:hash)
     end
 
     before do
-      @view     = ActionView::Base.new(@@tmp_path, {})
+      @view     = @@view_class.new(ActionView::LookupContext.new(@@tmp_path), {}, nil)
       @compiler = RablRails::Compiler.new(@view)
     end
 
@@ -156,6 +163,14 @@ class TestCompiler < Minitest::Test
       assert_equal(:user, child_node.data)
     end
 
+    it "compiles child with root name defined with `as` option" do
+      t = @compiler.compile_source(%{ child(:user, as: :author) do attributes :foo end })
+      child_node = t.nodes.first
+
+      assert_equal(:author, child_node.name)
+      assert_equal(:user, child_node.data)
+    end
+
     it "compiles child with arbitrary source" do
       t = @compiler.compile_source(%{ child :@user => :author do attribute :name end })
       child_node = t.nodes.first
@@ -165,8 +180,6 @@ class TestCompiler < Minitest::Test
     end
 
     it "compiles child with inline partial notation" do
-
-
       t = @compiler.compile_source(%{child(:user, :partial => 'user') })
       child_node = t.nodes.first
 
@@ -217,6 +230,29 @@ class TestCompiler < Minitest::Test
       assert_equal([{ :id => :id }], extract_attributes(glue_node.nodes))
     end
 
+    it "compiles fetch with record association" do
+      t = @compiler.compile_source(%{ fetch :address do attributes :foo end})
+
+      assert_equal(1, t.nodes.size)
+      fetch_node = t.nodes.first
+
+      assert_equal(:address, fetch_node.name)
+      assert_equal(:address, fetch_node.data)
+      assert_equal(:id, fetch_node.field)
+      assert_equal([{ foo: :foo }], extract_attributes(fetch_node.nodes))
+    end
+
+    it "compiles fetch with options" do
+      t = @compiler.compile_source(%{
+        fetch(:user, as: :author, field: :uid) do attributes :foo end
+      })
+
+      fetch_node = t.nodes.first
+      assert_equal(:author, fetch_node.name)
+      assert_equal(:user, fetch_node.data)
+      assert_equal(:uid, fetch_node.field)
+    end
+
     it "compiles constant node" do
       t = @compiler.compile_source(%{
         const(:locale, 'fr_FR')
@@ -227,11 +263,30 @@ class TestCompiler < Minitest::Test
       assert_equal 'fr_FR', const_node.value
     end
 
+    it "compiles lookup node" do
+      t = @compiler.compile_source(%{
+        lookup(:favorite, :@user_favorites, cast: true)
+      })
+
+      lookup_node = t.nodes.first
+      assert_equal :favorite, lookup_node.name
+      assert_equal :@user_favorites, lookup_node.data
+      assert_equal :id, lookup_node.field
+      assert lookup_node.cast_to_boolean?
+    end
+
     it "extends other template" do
       t = @compiler.compile_source(%{ extends 'user' })
       assert_equal([{ :id => :id }], extract_attributes(t.nodes))
     end
 
+    it "extends with a lambda" do
+      t = @compiler.compile_source(%{ extends -> { 'user' } })
+      node = t.nodes.first
+      assert_instance_of(RablRails::Nodes::Polymorphic, node)
+      assert_equal('user', node.template_lambda.call)
+    end
+
     it "compiles extend without overwriting nodes previously defined" do
       File.open(@@tmp_path + 'xtnd.rabl', 'w') do |f|
         f.puts %q{

data/test/test_hash_visitor.rb

@@ -105,6 +105,17 @@ class TestHashVisitor < Minitest::Test
       assert_equal({ name: 'Marty'}, visitor_result)
     end
 
+    it 'renders fetch node' do
+      template = RablRails::CompiledTemplate.new
+      template.add_node(RablRails::Nodes::Attribute.new(name: :name))
+      template.data = :@users_hash
+
+      @nodes << RablRails::Nodes::Fetch.new(:user, template, :id)
+      @context.assigns['users_hash'] = { @resource.id => @resource }
+
+      assert_equal({ user: { name: 'Marty' } }, visitor_result)
+    end
+
     describe 'with a code node' do
       before do
         @proc = ->(object) { object.name }
@@ -141,6 +152,20 @@ class TestHashVisitor < Minitest::Test
       assert_equal({ locale: 'fr_FR' }, visitor_result)
     end
 
+    it 'renders a positive lookup node' do
+      @nodes << RablRails::Nodes::Lookup.new(:favorite, :@user_favorites, :id, true)
+      @context.assigns['user_favorites'] = { 1 => true }
+
+      assert_equal({ favorite: true }, visitor_result)
+    end
+
+    it 'renders a negative lookup node' do
+      @nodes << RablRails::Nodes::Lookup.new(:favorite, :@user_favorites, :id, false)
+      @context.assigns['user_favorites'] = { 2 => true }
+
+      assert_equal({ favorite: nil }, visitor_result)
+    end
+
     describe 'with a condition node' do
       before do
         @ns = [RablRails::Nodes::Attribute.new(name: :name)]
@@ -185,6 +210,20 @@ class TestHashVisitor < Minitest::Test
       library.verify
     end
 
+    it 'renders partial defined in node' do
+      template = RablRails::CompiledTemplate.new
+      template.add_node(RablRails::Nodes::Attribute.new(name: :name))
+      library = MiniTest::Mock.new
+      library.expect :compile_template_from_path, template, ['users/base', @context]
+
+      @nodes << RablRails::Nodes::Polymorphic.new(->(_) { 'users/base' })
+      RablRails::Library.stub :instance, library do
+        assert_equal({ name: 'Marty' }, visitor_result)
+      end
+
+      library.verify
+    end
+
     it 'allows uses of locals variables with partials' do
       template = RablRails::CompiledTemplate.new
       template.add_node(RablRails::Nodes::Code.new(:hide_comments, ->(u) { locals[:hide_comments] }, ->(u) { locals.key?(:hide_comments) }))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabl-rails
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.2
 platform: ruby
 authors:
 - Christopher Cocchi-Perrier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-25 00:00:00.000000000 Z
+date: 2021-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -44,14 +44,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +114,10 @@ files:
 - lib/rabl-rails/nodes/condition.rb
 - lib/rabl-rails/nodes/const.rb
 - lib/rabl-rails/nodes/extend.rb
+- lib/rabl-rails/nodes/fetch.rb
 - lib/rabl-rails/nodes/glue.rb
+- lib/rabl-rails/nodes/lookup.rb
+- lib/rabl-rails/nodes/polymorphic.rb
 - lib/rabl-rails/railtie.rb
 - lib/rabl-rails/renderers/hash.rb
 - lib/rabl-rails/renderers/json.rb
@@ -150,8 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Fast Rails 4+ templating system with JSON, XML and PList support