jbuilder-jpartial 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a65d95a34e52d2bfbba166e44f08f537342ff7e6
-  data.tar.gz: 8bc8ffd3a466815047991e8484a937d850bc3dbc
+  metadata.gz: 484a3494bea19dd423cd1bfec8942c5e47475541
+  data.tar.gz: 1dc470a7f1a92377a054fe33031757b8398f4e08
 SHA512:
-  metadata.gz: 98a6bfcbb32d121bb3a154745a65d1b0879dc21c46746ebdecb4ee8745f96512b9de3513206f5872e736889faeaa90b83167045c4fc110183d7bc29d4e569537
-  data.tar.gz: bb6c0bd057fd945894fb1275fa8614b2eee1b34a674eed14fffb6b5f33cd1ba4322a3d334dc5471b16d30ba7a95489b653bf2fb606eb6f16975adabbc6406797
+  metadata.gz: f0611e2298872183b2458663ece24039a8b3b205944ddd7dfa586ebfb38d562ece8fed535038d81a36dffa1f4a18d115231348de395aa7fbac542bfb227d4c3d
+  data.tar.gz: 792df2214b9d1869cb3d55b97da7a6c4b0506511d1a1ffbf864f32c7f699535a0391603e345f330932b6cf462d0083e80fecdb35b897cc5efe51bce1e8d8901a

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+1.1
+-----
+* Do less monkey patching on the original Jbuilder class. Only add the partial methods defined by the user, otherwise leave Jbuilder alone and leave the rest to a proxy class.
+* Make sure all view helper methods are available in partials, not just route helpers.
+* Add Rails generator for initializer file.

data/README.md

@@ -1,5 +1,8 @@
 # Jbuilder::Jpartial
 
+[![Gem Version](https://badge.fury.io/rb/jbuilder-jpartial.svg)](https://badge.fury.io/rb/jbuilder-jpartial)
+[![Build Status](https://travis-ci.org/msimonborg/jbuilder-jpartial.svg?branch=master)](https://travis-ci.org/msimonborg/jbuilder-jpartial)
+
 A lightweight library that provides a simple DSL for faster partial rendering with Jbuilder.
 
 ## Installation
@@ -17,7 +20,7 @@ And then execute:
 Or install it yourself as:
 
     $ gem install jbuilder-jpartial
-    
+
     require 'jbuilder/jpartial'
 
 ## Usage
@@ -72,13 +75,18 @@ end
 #### Why?
 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 your partials in a familiar way while dramatically reducing overhead. 
+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 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,550 templates rendered! Using `Jbuilder::Jpartial`, the partial files are each only called when the partial is initialized. After that, all of the partial rendering is taken care of in the abstract from the original file. In our example, we hit `json.partial! 'post'` once and `json.partial! 'comments/comment'` only once for each `post`, cutting 2,550 template renders down to 51.
 
 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 big advantage here is 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/jpartial.rb`
+#### First generate the file
+
+    $ rails generate jpartial
+
+
+#### Then in `app/config/initializers/jpartial.rb`
 ```ruby
 Jbuilder::Jpartial.configure do |jpartial|
   jpartial._post do |post|
@@ -89,7 +97,7 @@ Jbuilder::Jpartial.configure do |jpartial|
       json._comment comment
     end
   end
-  
+
   jpartial._comment do |comment|
     json.content comment.content
     json.author comment.author.name
@@ -109,13 +117,13 @@ Notice that when using this method, we don't make any calls like `json.partial!
 We've now cut our template renders down to only 1 from the original 2,550. The only real disadvantage is it bucks the regular Rails file structure conventions for partials. C'est la vie.
 
 #### How?
-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.
+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, and access any of the helper methods available in your views.
 
 e.g.
 
 ```ruby
 jpartial._post do |post|
-  json.title post.title
+  json.post_url post_url(post)
 end
 ```
 
@@ -145,15 +153,16 @@ end
 
 Now you can call `json._post @post, author: @author`
 
-Again, if you're defining all of your partials in one config file, the extra call to a partial template is not necessary.
+Again, if you're defining all of your partials in one config file (best performance), the extra call to a partial template is not necessary.
 
+#### `config/initializers/jpartial.rb`
 ```ruby
 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
@@ -161,11 +170,6 @@ 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 `#whatever_partial` instead of `#whatever`.
-
-Methods taken by this library are `Jbuilder#json` and any valid route helpers defined by your app e.g. `Jbuilder#post_url`. If you have or need any fields with keys like `"json"` or `"post_url"` use `Jbuilder#set!`, e.g.
-```ruby
-json.set! 'json', 'some value'
-json.set! 'post_url', 'some url'
 ```
 
 
@@ -183,4 +187,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/msimon
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/generators/jpartial_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module Jpartial
+  module Generators
+    # Generate a configuration template for partials.
+    class JpartialGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_config_file
+        template 'jpartial.rb.erb', 'config/initializers/jpartial.rb'
+      end
+    end
+  end
+end

data/lib/generators/templates/jpartial.rb.erb

@@ -0,0 +1,19 @@
+<%= "# frozen_string_literal: true" %>
+
+<%= "Jbuilder::Jpartial.configure do |jpartial|" %>
+<%= "#   jpartial._post do |post|" %>
+<%= "#     json.post_url post_url(post)" %>
+<%= "#     json.title post.title" %>
+<%= "#     json.author_name post.author.name" %>
+<%= "#   end" %>
+<%= "end" %>
+
+<%= "# In `app/views/posts/show.jbuilder`" %>
+<%= "#   json._post @post" %>
+<%= "#" %>
+<%= "# Result:" %>
+<%= "#   {" %>
+<%= "#     \"post_url\": \"http://www.app.com/posts/12345\"," %>
+<%= "#     \"title\": \"The Number One Post\"," %>
+<%= "#     \"author\": \"M. Simon Borg\"" %>
+<%= "#   }" %>

data/lib/jbuilder/jpartial.rb

@@ -3,25 +3,6 @@ require 'jbuilder/jpartial/version'
 
 # Top level Jbuilder class
 class Jbuilder
-  def json
-    self
-  end
-
-  alias_method :old_method_missing, :method_missing
-
-  def method_missing(method_name, *args, &block)
-    if _method_is_a_route_helper?(method_name)
-      @context.send(method_name, *args, &block)
-    else
-      old_method_missing(method_name, *args, &block)
-    end
-  end
-
-  def _method_is_a_route_helper?(method_name)
-    method_name.to_s =~ /(.*)_(url|path)/ && !@context.nil? &&
-      @context.respond_to?(method_name)
-  end
-
   # Jpartial module
   module Jpartial
     DangerousMethodName = Class.new(ArgumentError)
@@ -29,18 +10,22 @@ class Jbuilder
     @defined_by_user = []
 
     def self.jpartial(name, &block)
-      if dangerous_method_name?(name)
-        raise DangerousMethodName, "The method `##{name}` is already defined"\
-          ' by Jbuilder. Please choose another name to define your partial'
-      else
-        Jbuilder.class_eval do
-          define_method(name, &block)
+      _raise_dangerous_method_name_error(name) if _dangerous_method_name?(name)
+      JbuilderProxy.class_eval { define_method(name, &block) }
+      Jbuilder.class_eval do
+        define_method(name) do |*args|
+          JbuilderProxy.new(self, @context).__send__(name, *args)
         end
-        @defined_by_user << name unless @defined_by_user.include?(name)
       end
+      @defined_by_user << name unless @defined_by_user.include?(name)
     end
 
-    def self.dangerous_method_name?(name)
+    def self._raise_dangerous_method_name_error(name)
+      raise DangerousMethodName, "The method `##{name}` is already defined"\
+        ' by Jbuilder. Please choose another name to define your partial'
+    end
+
+    def self._dangerous_method_name?(name)
       !@defined_by_user.include?(name) &&
         Jbuilder.method_defined?(name) ||
         Jbuilder.private_method_defined?(name)
@@ -58,12 +43,41 @@ class Jbuilder
                            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
+
+    # Partial method execution is defined here. Jbuilder only knows how to
+    # initialize an instance of the proxy class and send it the right message.
+    # The proxy is initialized with the execution context if there is any
+    # so it can pass along context methods when they're defined.
+    class JbuilderProxy
+      instance_methods.each do |meth|
+        next if [:method_missing, :__send__, :object_id].include?(meth)
+        undef_method(meth)
+      end
+
+      attr_reader :json
+
+      def initialize(json, context = nil)
+        @json    = json
+        @context = context
+      end
+
+      def method_missing(method_name, *args, &block)
+        if _method_defined_in_context?(method_name)
+          @context.send(method_name, *args, &block)
+        else
+          super(method_name, *args, &block)
+        end
+      end
+
+      def _method_defined_in_context?(method_name)
+        !@context.nil? && @context.respond_to?(method_name)
+      end
+    end
   end
 end
 

data/lib/jbuilder/jpartial/version.rb

@@ -6,6 +6,6 @@ end
 
 class Jbuilder
   module Jpartial
-    VERSION = '1.0.2'.freeze
+    VERSION = '1.1.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jbuilder-jpartial
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - M. Simon Borg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-11 00:00:00.000000000 Z
+date: 2017-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jbuilder
@@ -59,8 +59,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/generators/jpartial_generator.rb
+- lib/generators/templates/jpartial.rb.erb
 - lib/jbuilder/jpartial.rb
 - lib/jbuilder/jpartial/railtie.rb
 - lib/jbuilder/jpartial/version.rb