props_template 0.16.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abee2de45e7fc076a1edad8c9d3edd9f13b3335e0946d6d227fcc4e5370a9e60
-  data.tar.gz: 20bb87744d490b3cae705a1514a965b07ec04cfdc99c5f7deafb627c00fb7484
+  metadata.gz: 23e014144b689057bd6e6cc96a007b17263a2eab2a84890dd822056c2a4e258d
+  data.tar.gz: bba7578e983913d2eeeb15fc12026bb66b25c6da5a8df52c4d2003e8615a2eba
 SHA512:
-  metadata.gz: 84b19f30e105c344ea37f0db00524804f998ba01ab84e0cd2f5c47e7c9324061096fd9b089df310a9cfc7a25980b72b01cb2c397649d3ce6ba24e9ca1fc7fd94
-  data.tar.gz: 07257d4609fb4ebbce6621dd804f87abe1b28ab336a41ea1d092611d973d3ea905134b5ad0d690ed9496c62758318825034b1f99b3668b09b3aa7046f49fc9c3
+  metadata.gz: d1adee8973b67e46c8c2169a7664ec92c0ee52e21451108b449888b8a8dd89221b46d2918da2ace75e016530a7654ce03a513f4f761cb2f6fa938dd76d4a18ed
+  data.tar.gz: 2bc87b68c92e21f4755bf4a41c8ea1290bbfcd94f570fa2cf98b86fc2eecaa9ae83eae0f58042c3ae18cfd9c9f0d0c54caa23b5cff4c92814dfd81b3e306baa0

data/README.md

@@ -1,15 +1,29 @@
 # PropsTemplate
 
-PropsTemplate is a direct-to-Oj, JBuilder-like DSL for building JSON. It has support for Russian-Doll caching, layouts, and of course, its most unique feature: your templates are queryable.
+PropsTemplate is a direct-to-Oj, JBuilder-like DSL for building JSON. It has
+support for Russian-Doll caching, layouts, and can be queried by giving the
+root a key path.
 
-PropsTemplate is fast!
+[![Build
+Status](https://circleci.com/gh/thoughtbot/props_template.svg?style=shield)](https://circleci.com/gh/thoughtbot/props_template)
 
-Most libraries would build a hash before feeding it to your serializer of choice, typically Oj. PropsTemplate writes directly to Oj using `Oj::StringWriter` as its rendering your template and skips the need for an intermediate data structure.
+It's fast.
 
-PropsTemplate also improves caching. While other libraries spend time unmarshaling, merging, and then serializing to JSON; PropsTemplate simply takes the cached string and [push_json](http://www.ohler.com/oj/doc/Oj/StringWriter.html#push_json-instance_method).
+PropsTemplate bypasses the steps of hash building and serializing
+that other libraries perform by using Oj's `StringWriter` in `rails` mode.
 
+![benchmarks](docs/benchmarks.png)
 
-Example:
+Caching is fast too.
+
+While other libraries spend time unmarshaling,
+merging hashes, and serializing to JSON; PropsTemplate simply takes
+the cached string and uses Oj's [push_json](http://www.ohler.com/oj/doc/Oj/StringWriter.html#push_json-instance_method).
+
+## Example:
+
+PropsTemplate is very similar to JBuilder, and selectively retains some
+conveniences and magic.
 
 ```ruby
 json.flash flash.to_h
@@ -47,34 +61,50 @@ json.posts do
   json.total @posts.count
 end
 
-
 json.footer partial: 'shared/footer' do
 end
 ```
 
 ## Installation
-If you plan to use PropsTemplate alone just add it to your Gemfile.
 
 ```
 gem 'props_template'
 ```
 
-and run `bundle`
+and run `bundle`.
+
+Add the [core ext](#array-core-extension) to an initializer.
+
+```ruby
+require 'props_template/core_ext'
+```
+
+
+And create a file in your `app/views` folder like so:
+
+```ruby
+# app/views/posts/index.json.props
+
+json.greetings "hello world"
+```
+
+You can also add a [layout](#layouts).
 
 ## API
 
-### json.set! or json.<your key here>
-Defines the attribute or stucture. All keys are automatically camelized lower.
+### json.set! or json.\<your key here\>
+
+Defines the attribute or structure. All keys are automatically camelized lower.
 
 ```ruby
-json.set! :author_details, {..options...} do
+json.set! :author_details, {...options} do
   json.set! :first_name, 'David'
 end
 
 or
 
-json.author_details, {..options...} do
-  json.first_name, 'David'
+json.author_details, {...options} do
+  json.first_name 'David'
 end
 
 
@@ -89,6 +119,7 @@ The inline form defines key and value
 | value | A value |
 
 ```ruby
+
 json.set! :first_name, 'David'
 
 or
@@ -108,39 +139,36 @@ The block form defines key and structure
 
 ```ruby
 json.set! :details do
- ...
+  ...
 end
 
 or
 
 json.details do
- ...
+  ...
 end
 ```
 
 The difference between the block form and inline form is
-1. The block form is an internal node. Partials, Deferement and other [options](#options) are only available on the block form.
-2. The inline form is considered a leaf node, and you can only [search](#traversing) for internal nodes.
+  1. The block form is an internal node. Functionality such as Partials,
+  Deferment and other [options](#options) are only available on the
+  block form.
+  2. The inline form is considered a leaf node, and you can only [search](#traversing)
+  for internal nodes.
 
 ### json.array!
 Generates an array of json objects.
 
 ```ruby
-collection = [
-  {name: 'john'},
-  {name: 'jim'}
-]
+collection = [ {name: 'john'}, {name: 'jim'} ]
 
 json.details do
-  json.array! collection, {....options...} do |person|
+  json.array! collection, {...options} do |person|
     json.first_name person[:name]
   end
 end
 
-# => {"details": [
-  {"firstName": 'john'},
-  {"firstName": 'jim'}
-]}
+# => {"details": [{"firstName": 'john'}, {"firstName": 'jim'} ]}
 ```
 
 | Parameter | Notes |
@@ -148,7 +176,8 @@ end
 | collection | A collection that responds to `member_at` and `member_by` |
 | options | Additional [options](#options)|
 
-To support [traversing nodes](react-redux.md#traversing-nodes), any list passed to `array!` MUST implement `member_at(index)` and `member_by(attr, value)`.
+To support [traversing nodes](#traversing), any list passed
+to `array!` MUST implement `member_at(index)` and `member_by(attr, value)`.
 
 For example, if you were using a delegate:
 
@@ -169,7 +198,10 @@ end
 Then in your template:
 
 ```ruby
-data = ObjectCollection.new([{id: 1, name: 'foo'}, {id: 2, name: 'bar'}])
+data = ObjectCollection.new([
+  {id: 1, name: 'foo'},
+  {id: 2, name: 'bar'}
+])
 
 json.array! data do
   ...
@@ -200,11 +232,15 @@ end
 
 #### **Array core extension**
 
-For convenience, PropsTemplate includes a core\_ext that adds these methods to `Array`. For example:
+For convenience, PropsTemplate includes a core\_ext that adds these methods to
+`Array`. For example:
 
 ```ruby
 require 'props_template/core_ext'
-data = [{id: 1, name: 'foo'}, {id: 2, name: 'bar'}]
+data = [
+  {id: 1, name: 'foo'},
+  {id: 2, name: 'bar'}
+]
 
 json.posts
   json.array! data do
@@ -213,38 +249,39 @@ json.posts
 end
 ```
 
-PropsTemplate does not know what the elements are in your collection. The example above will be fine for [traversing](props-template.md#traversing_nodes) by index `\posts?bzq=posts.0`, but will raise a `NotImplementedError` if you traverse by attribute `/posts?bzq=posts.id=1`. You may still need a delegate that implements `member_by`.
+PropsTemplate does not know what the elements are in your collection. The
+example above will be fine for [traversing](#traversing)
+by index, but will raise a `NotImplementedError` if you query by attribute. You
+may still need to implement `member_by`.
 
 ### json.deferred!
-Returns all deferred nodes used by the [#deferment](#deferment) option.
+Returns all deferred nodes used by the [deferment](#deferment) option.
 
-```ruby
-json.deferred json.deferred!
-```
+**Note** This is a [BreezyJS][1] specific functionality and is used in
+`application.json.props` when first running `rails breezy:install:web`
 
-This method is normally used in `application.json.props` when first generated by `rails breezy:install:web`
-
-### json.fragments!
-Returns all fragment nodes used by the [partial fragments](#partial-fragments) option.
 
 ```ruby
-json.fragments json.fragments!
-```
+json.deferred json.deferred!
 
-This method is normally used in `application.json.props` when first generated by `rails breezy:install:web`
+# => [{url: '/some_url?props_at=outer.inner', path: 'outer.inner', type: 'auto'}]
+```
 
-### json.fragment_digest!
+This method provides metadata about deferred nodes to the frontend ([BreezyJS][1])
+to fetch missing data in a second round trip.
 
-Returns the digest of the current partial name and the locals passed. Useful for [optimistic updates](#optimistic-updates).
+### json.fragments!
+Returns all fragment nodes used by the [partial fragments](#partial-fragments)
+option.
 
-```ruby
-# _some_partial.json.props
+```ruby json.fragments json.fragments!  ```
 
-json.digest json.fragment_digest!
-```
+**Note** This is a [BreezyJS][1] specific functionality and is used in
+`application.json.props` when first running `rails breezy:install:web`
 
 ## Options
-Functionality such as Partials, Deferements, and Caching can only be set on a block. It is normal to see empty blocks.
+Options Functionality such as Partials, Deferements, and Caching can only be
+set on a block. It is normal to see empty blocks.
 
 ```ruby
 json.post(partial: 'blog_post') do
@@ -253,7 +290,9 @@ end
 
 ### Partials
 
-Partials are supported. The following will render the file `views/posts/_blog_posts.json.props`, and set a local variable `foo` assigned with @post, which you can use inside the partial.
+Partials are supported. The following will render the file
+`views/posts/_blog_posts.json.props`, and set a local variable `foo` assigned
+with @post, which you can use inside the partial.
 
 ```ruby
 json.one_post partial: ["posts/blog_post", locals: {post: @post}] do
@@ -263,7 +302,8 @@ end
 Usage with arrays:
 
 ```ruby
-# as an option on an array. The `as:` option is supported when using `array!`
+# The `as:` option is supported when using `array!`
+
 json.posts do
   json.array! @posts, partial: ["posts/blog_post", locals: {foo: 'bar'}, as: 'post'] do
   end
@@ -271,14 +311,14 @@ end
 ```
 
 ### Partial Fragments
+**Note** This is a [BreezyJS][1] specific functionality.
 
-A fragment uses a digest to identify a rendered partial across your page state in Redux. When BreezyJS recieves a payload with a fragment, it will update every fragment with the same digest in your Redux store.
-
-You would need use partials and add the option `fragment: true`.
+A fragment identifies a partial output across multiple pages. It can be used to
+update cross cutting concerns like a header bar.
 
 ```ruby
 # index.json.props
-json.header partial: ["profile", fragment: true] do
+json.header partial: ["profile", fragment: "header"] do
 end
 
 # _profile.json.props
@@ -292,57 +332,16 @@ end
 When using fragments with Arrays, the argument **MUST** be a lamda:
 
 ```ruby
-require 'props_template/core_ext' #See (lists)[#Lists]
-
-json.array! ['foo', 'bar'], partial: ["footer", fragment: ->(x){ x == 'foo'}]
-```
-
-PropsTemplate creates a name for the partial using a digest of your locals, partial name, and globalId (to_json as fallback if there is no globalId) on objects that you pass. You may override this behavior and use a custom identifier:
+require 'props_template/core_ext'
 
-```ruby
-# index.js.breezy
-json.header partial: ["profile", fragment: 'me_header'] do
+json.array! ['foo', 'bar'], partial: ["footer", fragment: ->(x){ x == 'foo'}] do
 end
 ```
 
-#### Optimisitc Updates
-Breezy uses the digest generated by `fragment: true` to uniquely identify a partial across the redux state. If you need to optimistically update a fragment, use `json.fragment_digest!` to obtain the identifier in your partial, and `updateFragments` from BreezyJS.
-
-For example:
-
-```ruby
-# _header.js.props
-json.fragment_digest json.fragment_digest!
-```
-
-And in your reducer
-
-```javacript
-import {updateFragments} from 'jho406/Breezy';
-
-switch(action.type) {
-case SOME_ACTION: {
-  const {
-    fragmentDigest,
-    prevNode // <- the content of the _header.js.props
-  } = action.payload
-
-  const nextNode = {
-    ...prevNode,
-    foo: 'bar'
-  }
-
-  return updateFragments(state, {
-    [fragmentDigest]: nextNode
-  })
-}
-default:
-  return state
-}
-```
-
 ### Caching
-Caching is supported on any node.
+Caching is supported on internal nodes only. This limitation is what makes it
+possible to for props_template to forgo marshalling/unmarshalling and simply
+use [push_json](http://www.ohler.com/oj/doc/Oj/StringWriter.html#push_json-instance_method).
 
 Usage:
 
@@ -368,44 +367,60 @@ end
 When used with arrays, PropsTemplate will use `Rails.cache.read_multi`.
 
 ```ruby
-require 'props_template/core_ext' #See (lists)[#Lists]
+require 'props_template/core_ext'
+
+opts = { cache: ->(i){ ['a', i] } }
 
-opts = {
-  cache: ->(i){ ['a', i] }
-}
 json.array! [4,5], opts do |x|
   json.top "hello" + x.to_s
 end
 
 #or on arrays with partials
 
-opts = {
-  cache: (->(d){ ['a', d.id] }),
-  partial: ["blog_post", as: :blog_post]
-}
-json.array! @options, opts
+opts = { cache: (->(d){ ['a', d.id] }), partial: ["blog_post", as: :blog_post] }
+
+json.array! @options, opts do
+end
 ```
 
 ### Deferment
 
-You can defer rendering of expensive nodes in your content tree using the `defer: :auto` option. Behind the scenes PropsTemplates will no-op the block entirely, replace the value with `{}` as a placeholder.
-When the client recieves the payload, BreezyJS will use the meta data to issue a `remote` dispatch to fetch the missing node and immutibly graft it at the appropriate keypath in your Redux store.
+You can defer rendering of expensive nodes in your content tree using the
+`defer: :manual` option. Behind the scenes PropsTemplates will no-op the block
+entirely and replace the value with a placeholder. A common use case would be
+tabbed content that does not load until you click the tab.
+
+When your client receives the payload, you may issue a second request to the
+same endpoint to fetch any missing nodes. See [traversing nodes](#traversing)
 
-You can access what was deferred with `json.deferred!`. If you use the generators, this will be set up in `application.json.props`.
+There is also an `defer: :auto` option that you can use with [BreezyJS][1]. [BreezyJS][1]
+will use the metadata from `json.deferred!` to issue a `remote` dispatch to fetch
+the missing node and immutably graft it at the appropriate keypath in your Redux
+store.
 
 Usage:
 
 ```ruby
-json.dashboard(defer: :auto) do
+json.dashboard(defer: :manual) do
+  sleep 10
+  json.some_fancy_metric 42
+end
+
+
+# or you can explicitly pass a placeholder
+
+json.dashboard(defer: [:manual, placeholder: {}]) do
   sleep 10
   json.some_fancy_metric 42
 end
 ```
 
-A manual option is also available:
+A auto option is available:
+
+**Note** This is a [BreezyJS][1] specific functionality.
 
 ```ruby
-json.dashboard(defer: :manual) do
+json.dashboard(defer: :auto) do
   sleep 10
   json.some_fancy_metric 42
 end
@@ -417,39 +432,51 @@ Finally in your `application.json.props`:
 json.defers json.deferred!
 ```
 
-
-If `:manual` is used, PropsTemplate will no-op the block and will not populate `json.deferred!`. Its up to you to [traverse](props-template.md#traversing_nodes) to fetch the node seperately. A common usecase would be tab content that does not load until you click the tab.
-
 #### Working with arrays
-The default behavior for deferements is to use the index of the collection to identify an element. PropsTemplate will generate `?_bzq=a.b.c.0.title` in its metadata.
+The default behavior for deferements is to use the index of the collection to
+identify an element.
+
+**Note** If you are using this library with [BreezyJS][1], the `:auto` options will
+generate `?props_at=a.b.c.0.title` for `json.deferred!`.
 
 If you wish to use an attribute to identify the element. You must:
-1. Implement `:key` to specify which attribute you want to use to uniquely identify the element in the collection. PropsTemplate will generate `?_bzq=a.b.c.some_id=some_value.title`
-2. Implement `member_at`, and `member_key` on the collection to allow for BreezyJS to traverse the tree based on key value attributes.
+
+1. Use the `:key` option on `json.array!`. This key refers to an attribute on
+your collection item, and is used for `defer: :auto` to generate a keypath for
+[BreezyJS][1]. If you are NOT using BreezyJS, you do not need to do this.
+
+2. Implement `member_at`, on the [collection](#jsonarray). This will be called
+by PropsTemplate to when [searching nodes](#traversing)
 
 For example:
 
 ```ruby
-require 'props_template/core_ext' #See (lists)[#Lists]
-
-data = [{id: 1, name: 'foo'}, {id: 2, name: 'bar'}]
+require 'props_template/core_ext'
+data = [
+  {id: 1, name: 'foo'},
+  {id: 2, name: 'bar'}
+]
 
 json.posts
   json.array! data, key: :some_id do |item|
+    # By using :key, props_template will append `json.some_id item.some_id`
+    # automatically
+
     json.contact(defer: :auto) do
       json.address '123 example drive'
     end
-
-   # json.some_id item.some_id will be appended automatically to the end of the block
   end
 end
 ```
 
-When BreezyJS receives the response, it will automatically kick off `remote(?bzq=posts.some_id=1.contact)` and `remote(?bzq=posts.some_id=2.contact)`.
+If you are using [BreezyJS][1], BreezyJS will, it will automatically kick off
+`remote(?props_at=posts.some_id=1.contact)` and `remote(?props_at=posts.some_id=2.contact)`.
 
-# Traversing
+## Traversing
 
-PropsTemplate has the ability to walk the tree you build, skipping execution of untargeted nodes. This feature is useful for partial updating your frontend state. See [traversing nodes](react-redux.md#traversing-nodes)
+PropsTemplate has the ability to walk the tree you build, skipping execution of
+untargeted nodes. This feature is useful for selectively updating your frontend
+state.
 
 ```ruby
 traversal_path = ['data', 'details', 'personal']
@@ -457,7 +484,7 @@ traversal_path = ['data', 'details', 'personal']
 json.data(search: traversal_path) do
   json.details do
     json.employment do
-      ...more stuff...
+      ...more stuff
     end
 
     json.personal do
@@ -468,25 +495,28 @@ json.data(search: traversal_path) do
 end
 
 json.footer do
- ...
+  ...
 end
 ```
 
-PropsTemplate will will walk breath first, finds the matching key, executes the associated block, then repeats until it the node is found. The above will output the below:
+PropsTemplate will walk depth first, walking only when it finds a matching key,
+then executes the associated block, and repeats until it the node is found.
+The above will output:
 
 ```json
 {
-  data: {
-    name: 'james',
-    zipCode: 91210
+  "data": {
+    "name": 'james',
+    "zipCode": 91210
   },
-  footer: {
-    ....
+  "footer": {
+    ...
   }
 }
 ```
 
-Breezy's searching only works with blocks, and will NOT work with Scalars ("leaf" values). For example:
+Searching only works with blocks, and will NOT work with Scalars
+("leaf" values). For example:
 
 ```ruby
 traversal_path = ['data', 'details', 'personal', 'name'] <- not found
@@ -498,12 +528,11 @@ json.data(search: traversal_path) do
     end
   end
 end
-
 ```
 
 ## Nodes that do not exist
 
-Nodes that are not found will not define the key where search was enabled on.
+Nodes that are not found will remove the branch where search was enabled on.
 
 ```ruby
 traversal_path = ['data', 'details', 'does_not_exist']
@@ -517,17 +546,54 @@ json.data(search: traversal_path) do
 end
 
 json.footer do
- ...
+  ...
 end
-
 ```
 
 The above will render:
 
-```
+```json
 {
-  footer: {
+  "footer": {
     ...
   }
 }
 ```
+
+## Layouts
+A single layout is supported. To use, create an `application.json.props` in
+`app/views/layouts`. Here's an example:
+
+```ruby
+json.data do
+  # template runs here.
+  yield json
+end
+
+json.header do
+  json.greeting "Hello"
+end
+
+json.footer do
+  json.greeting "Hello"
+end
+
+json.flash flash.to_h
+```
+
+**NOTE** PropsTemplate inverts the usual Rails rendering flow. PropsTemplate
+will render Layout first, then the template when `yield json` is used.
+
+## Contributing
+
+See the [CONTRIBUTING] document. Thank you, [contributors]!
+
+  [CONTRIBUTING]: CONTRIBUTING.md
+  [contributors]: https://github.com/thoughtbot/props_template/graphs/contributors
+
+## Special Thanks
+
+Thanks to [turbostreamer](https://github.com/malomalo/turbostreamer) for the
+inspiration.
+
+[1]: https://github.com/thoughtbot/breezy

data/lib/props_template/base_with_extensions.rb

@@ -28,10 +28,6 @@ module Props
       @em.fragments
     end
 
-    def fragment_digest!
-      @em.fragment_digest
-    end
-
     def set_block_content!(options = {})
       return super if !@em.has_extensions(options)
 

data/lib/props_template/extension_manager.rb

@@ -7,7 +7,7 @@ module Props
   class ExtensionManager
     attr_reader :base, :builder, :context
 
-    def initialize(base, defered=[], fragments={})
+    def initialize(base, defered=[], fragments=[])
       @base = base
       @context = base.context
       @builder = base.builder
@@ -36,10 +36,6 @@ module Props
       @deferment.deferred
     end
 
-    def fragment_digest
-      @fragment.name
-    end
-
     def fragments
       @fragment.fragments
     end
@@ -59,10 +55,8 @@ module Props
         handle_cache(options) do
           base.set_block_content! do
             if options[:partial]
-              current_digest = @fragment.name
               @fragment.handle(options)
               @partialer.handle(options)
-              @fragment.name = current_digest
             else
               yield
             end
@@ -104,14 +98,7 @@ module Props
           next_deferred, next_fragments = Oj.load(meta)
           base.stream.push_json(raw_json)
           deferred.push(*next_deferred)
-
-          next_fragments.each do |k, v|
-            if fragments[k]
-              fragments[k].push(*v)
-            else
-              fragments[k] = v
-            end
-          end
+          fragments.push(*next_fragments)
         end
       else
         yield

data/lib/props_template/extensions/cache.rb

@@ -25,12 +25,6 @@ module Props
       @context
     end
 
-    def instrument(name, **options)
-      ActiveSupport::Notifications.instrument(name, options) do |payload|
-        yield payload
-      end
-    end
-
     def multi_fetch(keys, options = {})
       result = {}
       key_to_ckey = {}
@@ -49,7 +43,7 @@ module Props
 
       read_caches = {}
 
-      instrument('read_multi_fragments.action_view', payload) do |payload|
+      ActiveSupport::Notifications.instrument('read_multi_fragments.action_view', payload) do |payload|
         read_caches = ::Rails.cache.read_multi(*ckeys, options)
         payload[:read_caches] = read_caches
       end
@@ -122,7 +116,7 @@ module Props
 
     def cache_key(key, options)
       name_options = options.slice(:skip_digest, :virtual_path)
-      key = fragment_name_with_digest(key, name_options)
+      key = @context.cache_fragment_name(key, **name_options)
 
       if @context.respond_to?(:combined_fragment_cache_key)
         key = @context.combined_fragment_cache_key(key)
@@ -132,19 +126,6 @@ module Props
 
       ::ActiveSupport::Cache.expand_cache_key(key, :props)
     end
-
-    def fragment_name_with_digest(key, options)
-      if @context.respond_to?(:cache_fragment_name)
-        # Current compatibility, fragment_name_with_digest is private again and cache_fragment_name
-        # should be used instead.
-        @context.cache_fragment_name(key, options)
-      elsif @context.respond_to?(:fragment_name_with_digest)
-        # Backwards compatibility for period of time when fragment_name_with_digest was made public.
-        @context.fragment_name_with_digest(key)
-      else
-        key
-      end
-    end
   end
 end
 

data/lib/props_template/extensions/deferment.rb

@@ -34,6 +34,8 @@ module Props
 
       type, rest = options[:defer]
       placeholder = rest[:placeholder]
+      success_action = rest[:success_action]
+      fail_action = rest[:fail_action]
 
       if type.to_sym == :auto && options[:key]
         key, val = options[:key]
@@ -45,16 +47,22 @@ module Props
       path = @base.traveled_path.join('.')
       uri = ::URI.parse(request_path)
       qry = ::URI.decode_www_form(uri.query || '')
-        .reject{|x| x[0] == 'bzq' }
-        .push(["bzq", path])
+        .reject{|x| x[0] == 'props_at' }
+        .push(["props_at", path])
 
       uri.query = ::URI.encode_www_form(qry)
 
-      @deferred.push(
+      deferral = {
         url: uri.to_s,
         path: path,
-        type: type.to_s
-      )
+        type: type.to_s,
+      }
+
+      # camelize for JS land
+      deferral[:successAction] = success_action if success_action
+      deferral[:failAction] = fail_action if fail_action
+
+      @deferred.push(deferral)
 
       placeholder
     end

data/lib/props_template/extensions/fragment.rb

@@ -1,14 +1,10 @@
-require 'digest'
-
 module Props
   class Fragment
     attr_reader :fragments
-    attr_accessor :name
 
-    def initialize(base, fragments={})
+    def initialize(base, fragments=[])
       @base = base
       @fragments = fragments
-      @digest = Digest::SHA2.new(256)
     end
 
     def handle(options)
@@ -20,30 +16,10 @@ module Props
         fragment_name = fragment.to_s
         path = @base.traveled_path.join('.')
         @name = fragment_name
-        @fragments[fragment_name] ||= []
-        @fragments[fragment_name].push(path)
-      end
-
-      if fragment == true
-        locals = partial_opts[:locals]
 
-        identity = {}
-        locals
-          .clone
-          .tap{|h| h.delete(:json)}
-          .each do |key, value|
-            if value.respond_to?(:to_global_id)
-              identity[key] = value.to_global_id.to_s
-            else
-              identity[key] = value
-            end
-          end
-
-        path = @base.traveled_path.join('.')
-        fragment_name = @digest.hexdigest("#{partial_name}#{identity.to_json}")
-        @name = fragment_name
-        @fragments[fragment_name] ||= []
-        @fragments[fragment_name].push(path)
+        @fragments.push(
+          { type: fragment_name, partial: partial_name, path: path }
+        )
       end
     end
   end

data/lib/props_template/extensions/partial_renderer.rb

@@ -1,22 +1,56 @@
 require 'action_view'
 
 module Props
+  class RenderedTemplate
+    attr_reader :body, :layout, :template
+
+    def initialize(body, layout, template)
+      @body = body
+      @layout = layout
+      @template = template
+    end
+
+    def format
+      template.format
+    end
+  end
+
   class Partialer
+    INVALID_PARTIAL_MESSAGE = "The partial name must be a string, but received (%s)."
+
     def initialize(base, context, builder)
       @context = context
       @builder = builder
       @base = base
     end
 
+    def extract_details(options) # :doc:
+      @context.lookup_context.registered_details.each_with_object({}) do |key, details|
+        value = options[key]
+
+        details[key] = Array(value) if value
+      end
+    end
+
     def find_and_add_template(all_options)
       first_opts = all_options[0]
 
       if first_opts[:partial]
         partial_opts = block_opts_to_render_opts(@builder, first_opts)
-        renderer = PartialRenderer.new(@context, partial_opts)
+          .merge(formats: [:json])
+        partial_opts.delete(:handlers)
+        partial = partial_opts[:partial]
+
+        if !(String === partial)
+          raise ArgumentError.new(INVALID_PARTIAL_MESSAGE % (partial.inspect))
+        end
+
+        template_keys = retrieve_template_keys(partial_opts)
+        details = extract_details(partial_opts)
+        template = find_template(partial, template_keys, details)
 
         all_options.map do |opts|
-          opts[:_template] = renderer.template
+          opts[:_template] = template
           opts
         end
       else
@@ -24,6 +58,17 @@ module Props
       end
     end
 
+    def find_template(path, locals, details)
+      prefixes = path.include?(?/) ? [] : @context.lookup_context.prefixes
+      @context.lookup_context.find_template(path, prefixes, true, locals, details)
+    end
+
+    def retrieve_template_keys(options)
+      template_keys = options[:locals].keys
+      template_keys << options[:as] if options[:as]
+      template_keys
+    end
+
     def block_opts_to_render_opts(builder, options)
       partial, pass_opts = [*options[:partial]]
       pass_opts ||= {}
@@ -45,9 +90,20 @@ module Props
 
       renderer.render(template, pass_opts)
     end
+
+    def render(template, options)
+      view = @context
+      instrument(:partial, identifier: template.identifier) do |payload|
+        locals = options[:locals]
+        content = template.render(view, locals)
+
+        payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
+        build_rendered_template(content, template)
+      end
+    end
   end
 
-  class PartialRenderer < ActionView::AbstractRenderer
+  class PartialRenderer
     OPTION_AS_ERROR_MESSAGE  = "The value (%s) of the option `as` is not a valid Ruby identifier; " \
                                "make sure it starts with lowercase letter, " \
                                "and is followed by any combination of letters, numbers and underscores."
@@ -56,21 +112,6 @@ module Props
 
     INVALID_PARTIAL_MESSAGE = "The partial name must be a string, but received (%s)."
 
-    def self.find_and_add_template(builder, context, all_options)
-      first_opts = all_options[0]
-
-      if first_opts[:partial]
-        partial_opts = block_opts_to_render_opts(builder, first_opts)
-        renderer = new(context, partial_opts)
-
-        all_options.map do |opts|
-          opts[:_template] = renderer.template
-          opts
-        end
-      else
-        all_options
-      end
-    end
 
     def self.raise_invalid_option_as(as)
       raise ArgumentError.new(OPTION_AS_ERROR_MESSAGE % (as))
@@ -106,8 +147,7 @@ module Props
         locals[as] = item
 
         if fragment_name = rest[:fragment]
-          fragment_name = Proc === fragment_name ? fragment_name.call(item) : fragment_name.to_s
-          rest[:fragment] = fragment_name
+          rest[:fragment] = fragment_name.to_s
         end
       end
 
@@ -121,7 +161,6 @@ module Props
 
     def initialize(context, options)
       @context = context
-      super(@context.lookup_context)
       @options = options.merge(formats: [:json])
       @options.delete(:handlers)
       @details = extract_details(@options)
@@ -133,7 +172,7 @@ module Props
       end
 
       @path = partial
-      @context_prefix = @lookup_context.prefixes.first
+
       template_keys = retrieve_template_keys(@options)
       @template = find_template(@path, template_keys)
     end
@@ -145,6 +184,19 @@ module Props
     end
 
     private
+      def extract_details(options) # :doc:
+        @context.lookup_context.registered_details.each_with_object({}) do |key, details|
+          value = options[key]
+
+          details[key] = Array(value) if value
+        end
+      end
+
+      def instrument(name, **options) # :doc:
+        ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
+          yield payload
+        end
+      end
 
       def render_partial(template, view, options)
         template ||= @template
@@ -159,17 +211,13 @@ module Props
         end
       end
 
-      # Sets up instance variables needed for rendering a partial. This method
-      # finds the options and details and extracts them. The method also contains
-      # logic that handles the type of object passed in as the partial.
-      #
-      # If +options[:partial]+ is a string, then the <tt>@path</tt> instance variable is
-      # set to that string. Otherwise, the +options[:partial]+ object must
-      # respond to +to_partial_path+ in order to setup the path.
+      def build_rendered_template(content, template, layout = nil)
+        RenderedTemplate.new content, layout, template
+      end
 
       def find_template(path, locals)
-        prefixes = path.include?(?/) ? [] : @lookup_context.prefixes
-        @lookup_context.find_template(path, prefixes, true, locals, @details)
+        prefixes = path.include?(?/) ? [] : @context.lookup_context.prefixes
+        @context.lookup_context.find_template(path, prefixes, true, locals, @details)
       end
 
       def retrieve_template_keys(options)

data/lib/props_template/searcher.rb

@@ -23,9 +23,6 @@ module Props
       []
     end
 
-    def fragment_digest!
-    end
-
     def found!
       pass_opts = @found_options.clone || {}
       pass_opts.delete(:defer)

data/lib/props_template/version.rb

@@ -0,0 +1,3 @@
+module Props
+  VERSION = "0.21.0".freeze
+end

data/lib/props_template.rb

@@ -1,6 +1,7 @@
 require 'props_template/base_with_extensions'
 require 'props_template/searcher'
 require 'props_template/handler'
+require 'props_template/version'
 
 require 'active_support'
 
@@ -16,7 +17,6 @@ module Props
       :deferred!,
       :fragments!,
       :set_block_content!,
-      :fragment_digest!,
       to: :builder!
 
     def initialize(context = nil, options = {})

data/spec/layout_spec.rb

@@ -1,16 +1,24 @@
-require_relative './support/helper'
-require_relative './support/rails_helper'
-require 'props_template/layout_patch'
+require_relative "./support/helper"
+require_relative "./support/rails_helper"
+require "props_template/layout_patch"
+require "action_controller"
 
-RSpec.describe 'Props::Template' do
-  it 'uses a layout to render' do
-    view_path = File.join(File.dirname(__FILE__),'./fixtures')
-    controller = ActionView::TestCase::TestController.new
+RSpec.describe "Props::Template" do
+  class TestController < ActionController::Base
+    protect_from_forgery
+
+    def self.controller_path
+      ""
+    end
+  end
+
+  it "uses a layout to render" do
+    view_path = File.join(File.dirname(__FILE__), "./fixtures")
+    controller = TestController.new
     controller.prepend_view_path(view_path)
-    controller.response.headers['Content-Type']='application/json'
-    controller.request.path = '/some_url'
 
-    json = controller.render('200', layout: 'application')
+    json = controller.render_to_string("200", layout: "application")
+
     expect(json.strip).to eql('{"data":{"success":"ok"}}')
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: props_template
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Johny Ho
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-25 00:00:00.000000000 Z
+date: 2022-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -52,8 +52,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.9'
-description: A JSON builder for your React props
-email: jho406@gmail.com
+description: PropsTemplate is a direct-to-Oj, JBuilder-like DSL for building JSON.
+  It has support for Russian-Doll caching, layouts, and can be queried by giving the
+  root a key path.
+email: johny@thoughtbot.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -74,14 +76,15 @@ files:
 - lib/props_template/layout_patch.rb
 - lib/props_template/railtie.rb
 - lib/props_template/searcher.rb
+- lib/props_template/version.rb
 - spec/layout_spec.rb
 - spec/props_template_spec.rb
 - spec/searcher_spec.rb
-homepage: https://github.com/jho406/breezy/
+homepage: https://github.com/thoughtbot/props_template/
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -89,17 +92,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
-summary: A JSON builder for your React props
+summary: A fast JSON builder
 test_files:
 - spec/searcher_spec.rb
 - spec/layout_spec.rb