jbuilder-jpartial 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75e8c4257f48d6ef56dcaaf8047bef63df892137
-  data.tar.gz: 4f22e415d52ea9f82f097f5e05e2a42c22200c9a
+  metadata.gz: 29f17aa56ad6436b58ce9ae71dec2f5bcecf03bf
+  data.tar.gz: 21924849d686e532c9ace096a0036295bb0a1a50
 SHA512:
-  metadata.gz: da10106742ea3e98614392ee921e09caf4d8f77d6047632e4b1d4a9a065b01253d704c7409c8045dfb84d5804e411ba97a14b47eb61194e24499a94f0af70238
-  data.tar.gz: 118c304e9eca4ac54df216e59bc8146ca10e427b6dbae58a9e46ed807557cd53b8eea1942cd3e4a04e2487384f257e1d2c992dda09ec627ac1c3af9812acee33
+  metadata.gz: ea006e37c63c21f57e17786017e27c272212fb3059b4f5f5ee1f90394a58234dbf095bcdb1b1cfb4c66af5b3fd9379ad0565b1c1252543e767b827defa8b7340
+  data.tar.gz: 021b55c1ba1436e5feb0421a5069d8e78e81f2dfaa643341fb78b1e2d0185c7e2b03ca2d4d14d8967d57258ab017b725f2e0f60a6de254a1407cee594ba82419

data/README.md

@@ -22,29 +22,32 @@ Or install it yourself as:
 
 ## Usage
 
-#### In `config/initializers/jbuilder-jpartial.rb`
+#### In `app/views/posts/_post.jbuilder`
 
 ```ruby
-Jbuilder::Jpartial.configure do
-  jpartial :_post do |post|
-    json.title post.title
-    json.author post.author.name
-    json.content post.content
-    json.set! 'comments', post.comments do |comment|
-      json._comment comment
-    end
-  end
-  
-  jpartial :_comment do |comment|
-    json.content comment.content
-    json.author comment.author.name
+jpartial._post do |post|
+  json.title post.title
+  json.author post.author.name
+  json.content post.content
+  json.partial! 'comments/comment'
+  json.set! 'comments', post.comments do |comment|
+    json._comment comment
   end
 end
 ```
 
+#### In `app/views/comments/_comment.jbuilder`
+```ruby
+jpartial._comment do |comment|
+  json.content comment.content
+  json.author comment.author.name
+end
+```
+
 #### In `app/views/posts/index.jbuilder`
 
 ```ruby
+json.partial! 'post'
 json.set! 'posts', @posts do |post|
   json._post post
 end
@@ -67,60 +70,102 @@ end
 }
 ```
 #### Why?
-When traditional partials are used with `Jbuilder`, with each partial in a different file using standard Rails conventions, render times and memory usage can skyrocket quickly with the number of records, i.e. the number of partials rendered.
+When partials are used with `Jbuilder` render times and memory usage can skyrocket quickly with the number of records, i.e. the number of partials rendered.
 
-Using a simple DSL, `Jbuilder::Jpartial` lets you define all partials in one initializer file and call them wherever you need them: from within other partial definitions or anywhere you use `Jbuilder` in your views.
+Using a simple DSL, `Jbuilder::Jpartial` lets you define your partials in a familiar way while dramatically reducing overhead. 
 
-The result is faster rendering and lower memory usage, while still being able to leverage the advantages of Jbuilder. In the above example, if we had used traditional partials (defined in `app/views/posts/_post.jbuilder` and `app/views/comments/_comment.jbuilder`) those templates would have to be rendered once for each `post` and/or `comment`. If you have 50 posts, each with 50 comments, that's 2,500 templates rendered! Using `Jbuilder::Jpartial`, only one file (`app/views/posts/index.jbuilder`) is rendered. All of the partial rendering is taken care of in the abstract.
+The result is faster rendering and lower memory usage, while still being able to leverage the advantages of Jbuilder. In the above example, if we had used standard Jbuilder partials those templates would have to be rendered once for each `post` and/or `comment`. If you have 50 posts, each with 50 comments, that's 2,500 templates rendered! Using `Jbuilder::Jpartial`, the partial files are each only called once, to define the partial. After that, all of the partial rendering is taken care of in the abstract from the original file. In our example, you can cut 2,500 template renders down to 3.
+
+Alternatively you can define all partials in one initializer file and call them wherever you need them: from within other partial definitions or anywhere you use `Jbuilder` in your views. The advantage here is fewer files, all partials in one place, and since they're initialized at start up, you don't need to call any additional view templates to render the partials. Using the same example as above:
+
+#### In `app/config/initializers/jbuilder-jpartial.rb`
+```ruby
+Jbuilder::Jpartial.configure do |jpartial|
+  jpartial._post do |post|
+    json.title post.title
+    json.author post.author.name
+    json.content post.content
+    json.set! 'comments', post.comments do |comment|
+      json._comment comment
+    end
+  end
+  
+  jpartial._comment do |comment|
+    json.content comment.content
+    json.author comment.author.name
+  end
+end
+```
+
+#### In `app/views/posts/index.jbuilder`
+```ruby
+json.set! 'posts', @posts do |post|
+  json._post post
+end
+```
+
+Notice that when using this method, we don't make any calls like `json.partial! 'post'` at any point to define the partial before using it. All of the partials are already defined in the initializer file.
+
+The advantage is a couple fewer renders. The disadvantage is that helper methods that are available in the views are not available in the configuration file.
 
 #### How?
-Each `jpartial` block in your initializer file defines a Jbuilder method named after whatever symbol you pass as an argument. The objects you will pass to that method are yielded to the block. Inside the block you can use plain old Jbuilder syntax.
+Each method you call on `jpartial`  defines a Jbuilder method of the same name. The objects you will pass to that method are yielded to the block. Inside the block you can use plain old Jbuilder syntax.
 
 e.g.
 
 ```ruby
-Jbuilder::Jpartial.configure do
-  jpartial :_post do |post|
-    json.title post.title
-  end
+jpartial._post do |post|
+  json.title post.title
 end
 ```
 
 Now in your `.jbuilder` templates you can call `json._post @post`.
 
-You can specify multiple arguments and even use keyword arguments if you need to pass more than one local variable to the partial. You can also call partial methods from within other partial methods.
+You can specify multiple arguments and even use keyword options if you need to pass more than one local variable to the partial. You can also call partial methods from within other partial methods.
+
+The rule of thumb when defining your partials in views is you need to make sure the partial is initialized by making a call to the template, outside of your render logic and/or any loops/iteration.
 
 e.g.
 
+#### `app/views/authors/_author.jbuilder`
 ```ruby
-Jbuilder::Jpartial.configure do
-  jpartial :_post do |post, author:|
-    json.title post.title
-    json._author author
-  end
-  
-  jpartial :_author do |author|
-    json.name author.name
-  end
+jpartial._author do |author|
+  json.name author.name
 end
 ```
 
-Now you can call `json._post @post, author: @author`
+#### `app/views/posts/_post.jbuilder`
+```ruby
+jpartial._post do |post, author:|
+  json.title post.title
+  json.partial! 'authors/author'
+  json._author author
+end
+```
 
-Route helpers that are available within the views can also be used in the configuration file.
+Now you can call `json._post @post, author: @author`
 
-e.g.
+Again, if you're defining all of your partials in one config file, the extra call to a partial template is not necessary.
 
 ```ruby
-Jbuilder::Jpartial.configure do
-  jpartial :_post do |post|
-    json.href post_url(post)
+Jbuilder::Jpartial.configure do |jpartial|
+  jpartial._post do |post, author:|
     json.title post.title
+    json._author author
+  end
+  
+  jpartial._author do |author|
+    json.name author.name
   end
 end
 ```
 
-However unlikely, if you try to name a partial with the same name as a method already defined by Jbuilder it will throw an error at start up. Just pick a different name, like `#set_partial!` instead of `#set!`.
+However unlikely, if you try to name a partial with the same name as a method already defined by Jbuilder it will throw an error at start up. Just pick a different name, like `#whatever_partial` instead of `#whatever`.
+
+One method taken by this library is `Jbuilder#json`. This method returns the `self` of the receiver, which will be the instance of `Jbuilder` doing the encoding. If you have or need any fields with the key `"json"` use `Jbuilder#set!`, e.g.
+```ruby
+json.set! 'json', 'some value'
+```
 
 
 ## Development

data/lib/jbuilder/jpartial/version.rb

@@ -1,5 +1,5 @@
 class Jbuilder
   module Jpartial
-    VERSION = '0.1.3'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/lib/jbuilder/jpartial.rb

@@ -6,16 +6,6 @@ class Jbuilder
     self
   end
 
-  alias_method :old_method_missing, :method_missing
-
-  def method_missing(method_name, *args, &block)
-    if method_name.to_s =~ /(.*)_(url|path)/ && defined? @context
-      @context.send(method_name, *args, &block)
-    else
-      old_method_missing(method_name, *args, &block)
-    end
-  end
-
   # Jpartial module
   module Jpartial
     DangerousMethodName = Class.new(ArgumentError)
@@ -40,14 +30,22 @@ class Jbuilder
         Jbuilder.private_method_defined?(name)
     end
 
-    def self.configure(&block)
-      module_eval(&block)
+    def self.configure
+      yield Template.new
     end
 
-    # Sends all method calls to Jpartial.jpartial for definition
-    class Template
-      def method_missing(method_name, &block)
-        Jpartial.jpartial(method_name, &block)
+    # Proxy object that sends all method calls to Jpartial.jpartial
+    Template = Class.new(begin
+                           require 'active_support/proxy_object'
+                           ActiveSupport::ProxyObject
+                         rescue LoadError
+                           require 'active_support/basic_object'
+                           ActiveSupport::BasicObject
+                         end) do
+
+      def method_missing(name, *args, &block)
+        name = name.to_s == 'send' ? args.first.to_sym : name
+        Jpartial.jpartial(name, &block)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jbuilder-jpartial
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - M. Simon Borg