nice_partials 0.1.9 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc6e751d8a192aa46fe3ee5401fe924c4dc1f5c6c3c7fabe8c22f468ff3a344c
-  data.tar.gz: de5a48e0d84e96a40b85293933af3dadd4977e6dfa2dd06522c85e1a6fbd0576
+  metadata.gz: b3b70755595cff02588aa600004e44ec9f20847a4fdd026e0326876a2cad7f52
+  data.tar.gz: 24e42267606eb6a56ed481d2b82d137210618dff3282f6586036aa68bfad71c0
 SHA512:
-  metadata.gz: 5f56fb3b92520c7a818b6ced0225def224a265a9ca2400d70e283300df8eef3fc266c6b65fa2e4e24856d7eccb6c0b39bdadf056bdec76c499be68fd9d90a982
-  data.tar.gz: 6a58763a68c0aa76cfee32432c730166cd96a19b2c8a1e8428c26260663ff706fc4883af07e9b1782da0d7e493ca7f4f8883fde223b75674967acce7a3780bc1
+  metadata.gz: de339636e922f606a268eb0a9888686e3f0c6b3bdd0f874c8c50998a55437dfc8dff7f4a1c4293d4814277f75a49a959aa47ba9318ad9d9898d651c87d5fc6f8
+  data.tar.gz: ed7d3ff442df563d12aba16982a7a3ecae8a5f5b3022255e733bd2b5fd816c828064ddb659162839ef234fc26b22bd3f3a3a6be175e918a5518688a5cfe8bde2

data/CHANGELOG.md

@@ -1,5 +1,163 @@
 ## CHANGELOG
 
+* Fix rendering with special characters in a view path.
+
+  Ref: https://github.com/bullet-train-co/nice_partials/pull/70
+
+* Seed Nice Partials content from `local_assigns`
+
+  Previously, the only way to assign content to a Nice Partial was through passing a block:
+
+  ```erb
+  # app/views/posts/show.html.erb
+  <%= render "posts/post", byline: "Some guy" %>
+
+  # app/views/posts/_post.html.erb
+  <%= render "card" do |partial| %>
+    <% partial.title "Hello there" %>
+    <% partial.byline byline %> <%# `byline` comes from the outer `render` call above. %>
+  <% end %>
+
+  Now, Nice Partials will automatically use Rails' `local_assigns`, which contain any `locals:` passed to `render`, as the seed for content. So this works:
+
+  ```erb
+  <%= render "card", title: "Hello there", byline: byline %>
+  ```
+
+  And the `card` partial is now oblivious to whether its `title` or `byline` were passed as render `locals:` or through the usual assignments in a block.
+
+  ```erb
+  # app/views/_card.html.erb
+  <%= partial.title %> written by <%= partial.byline %>
+  ```
+
+  Previously to get this behavior you'd need to write:
+
+  ```erb
+  # app/views/_card.html.erb
+  <%= partial.title.presence || local_assigns[:title] %> written by <%= partial.byline.presence || local_assigns[:byline] %>
+  ```
+
+  Passing extra content via a block appends:
+
+  ```erb
+  <%= render "card", title: "Hello there" do |partial| %>
+    <% partial.title ", and welcome!" %> # Calling `partial.title` outputs `"Hello there, and welcome!"`
+  <% end %>
+  ```
+
+* Add `NicePartials::Partial#slice`
+
+  Returns a Hash of the passed keys with their contents, useful for passing to other render calls:
+
+  ```erb
+  <%= render "card", partial.slice(:title, :byline) %>
+  ```
+
+* Fix `partial.helpers` accidentally adding methods to `ActionView::Base`
+
+  When using `partial.helpers {}`, internally `class_eval` would be called on the Partial instance, and through `delegate_missing_to` passed on to the view context and thus we'd effectively have a global method, exactly as if we'd just used regular Rails view helpers.
+
+* Let partials respond to named content sections
+
+  ```erb
+  <% partial.content_for :title, "Title content" %> # Before
+  <% partial.title "Title content" %> # After
+
+  # Which can then be output
+  <% partial.title %> # => "Title content"
+  <% partial.title? %> # => true
+  ```
+
+  Note, `title` responds to `present?` so rendering could also be made conditional with:
+
+  ```erb
+  <% partial.title if partial.title? %> # Instead of this…
+  <% partial.title.presence %> # …you can do this
+  ```
+
+  #### Passing procs or components
+
+  Procs and objects that implement `render_in`, like ViewComponents, can also be appended as content:
+
+  ```erb
+  <% partial.title { "some content" } %>
+  <% partial.title TitleComponent.new(Current.user) %>
+  ```
+
+  #### Capturing `options`
+
+  Options can also be captured and output:
+
+  ```erb
+  <% partial.title class: "text-m4" %> # partial.title.options # => { class: "text-m4" }
+
+  # When output `to_s` is called and options automatically pipe through `tag.attributes`:
+  <h1 <% partial.title.options %>> # => <h1 class="text-m4">
+  ```
+
+  #### Proxying to the view context and appending content
+
+  A content section appends to its content when calling any view context method on it, e.g.:
+
+  ```erb
+  <% partial.title.t ".title" %>
+  <% partial.title.link_to @document.name, @document %>
+  <% partial.title.render "title", user: Current.user %>
+  <% partial.title.render TitleComponent.new(Current.user) do |component| %>
+    <% … %>
+  <% end %>
+  ```
+
+  #### Building elements with `tag` proxy
+
+  These `tag` calls let you generate elements based on the stored content and options:
+
+  ```erb
+  <% partial.title "content", class: "post-title" %> # Adding some content and options…
+  <% partial.title.h2 %> # => <h2 class="post-title">content</h2>
+  <% partial.title.h2 "more" %> # => <h2 class="post-title">contentmore</h2>
+  ```
+
+* Add `NicePartials#t` to aid I18n.
+
+  When using NicePartials with I18n you end up with lots of calls that look like:
+
+  ```erb
+  <% partial.title       t(".title") %>
+  <% partial.description t(".header") %>
+  <% partial.byline      t("custom.key") %>
+  ```
+
+  With NicePartials' `t` method, you can write the above as:
+
+  ```erb
+  <% partial.t :title, description: :header, byline: "custom.key" %>
+  ```
+
+  Clarifying what keys get converted to what content sections on the partial rather than the syntax heavy `partial.… t(".…")`.
+
+  Like the Rails built-in `t` method, it's just a shorthand alias for `translate` so that's available too.
+
+* Add `Partial#content_from`
+
+  `content_from` lets a partial extract contents from another partial.
+  Additionally, contents can be renamed by passing a hash:
+
+  ```erb
+  <% partial.title "Hello there" %>
+  <% partial.byline "Somebody" %>
+
+  <%= render "shared/title" do |cp| %>
+    # Here the inner partial `cp` accesses the outer partial through `partial`
+    # extracting the `title` and `byline` contents.
+    # `byline` is renamed to `name` in `cp`.
+    <% cp.content_from partial, :title, byline: :name %>
+  <% end %>
+  ```
+
+### 0.1.9
+
 * Remove need to insert `<% yield p = np %>` in partials.
 
   Nice Partials now automatically captures blocks passed to `render`.

data/Gemfile

@@ -1,7 +1,17 @@
 source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 gemspec
 
 gem "minitest"
 gem "rake"
 gem "irb"
+
+if ENV["RAILS_MAIN"]
+  gem "rails", github: "rails/rails", branch: "main"
+else
+  gem "rails"
+end
+
+gem "view_component"
+gem "capybara"

data/README.md

@@ -1,150 +1,254 @@
-# nice_partials [![[version]](https://badge.fury.io/rb/nice_partials.svg)](https://badge.fury.io/rb/nice_partials)  [![[travis]](https://travis-ci.org/andrewculver/nice_partials.svg)](https://travis-ci.org/andrewculver/nice_partials)
+# nice_partials [![[version]](https://badge.fury.io/rb/nice_partials.svg)](https://badge.fury.io/rb/nice_partials)
 
-Nice Partials lets [`content_for` and `yield`](https://guides.rubyonrails.org/layouts_and_rendering.html#using-the-content-for-method) calls be partial specific, to provide named "content areas" or "slots". This optional layer of magic helps make traditional Rails view partials a better fit for extracting components from your views, like so:
+Nice Partials adds ad-hoc named content areas, or sections, to Action View partials with a lot of extra power on top.
+
+Everything happens through a new `partial` method, which at the base of it have method shorthands for partial specific `content_for` and `content_for?`s.
+
+See, here we're outputting the `image`, `title`, and `body` sections:
 
 `app/views/components/_card.html.erb`:
 ```html+erb
 <div class="card">
-  <%= partial.yield :image %>
+  <%= partial.image %> # Same as `partial.content_for :image`
   <div class="card-body">
-    <h5 class="card-title"><%= title %></h5>
-    <% if partial.content_for? :body %>
+    <h5 class="card-title"><%= partial.title %></h5>
+    <% if partial.body? %>
       <p class="card-text">
-        <%= partial.yield :body %>
+        <%= partial.body %>
       </p>
     <% end %>
   </div>
 </div>
 ```
 
-Then you can call `render`, but specify how to populate the content areas:
+Then in `render` we populate them:
 
 ```html+erb
-<%= render 'components/card', title: 'Some Title' do |partial| %>
-  <% partial.content_for :body do %>
-    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
-    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-    <strong>quis nostrud exercitation ullamco laboris</strong> nisi ut aliquip
-    ex ea commodo consequat.
+<%= render "components/card", title: "Some Title" do |partial| %>
+  <% partial.title t(".title") %> # Same as `partial.content_for :title, t(".title")`
+
+  <% partial.body do %>
+    Lorem ipsum dolor sit amet, …
   <% end %>
 
-  <% partial.content_for :image do %>
-    <%= image_tag image_path('example.jpg'), alt: 'An example image' %>
+  <% partial.image do %>
+    <%= image_tag image_path("example.jpg"), alt: "An example image" %>
   <% end %>
 <% end %>
 ```
 
-Nice Partials is a lightweight and hopefully more Rails-native alternative to [ViewComponent](http://viewcomponent.org). It aims to provide many of the same benefits as ViewComponent while requiring less ceremony. This specific approach originated with [Bullet Train](https://bullettrain.co)'s "Field Partials" and was later reimagined and completely reimplemented by Dom Christie.
+So far these uses are pretty similar to Rails' global `content_for` & `content_for?`, except these sections are local to the specific partial, so there's no clashing or leaking.
 
+### More-in depth compared to regular Rails partials
 
-## Sponsored By
+Consider this regular Rails partials rendering:
 
-<a href="https://bullettrain.co" target="_blank">
-  <img src="https://github.com/CanCanCommunity/cancancan/raw/develop/logo/bullet_train.png" alt="Bullet Train" width="400"/>
-</a>
-<br/>
-<br/>
+```html+erb
+<%= render "components/card" do %>
+  <% content_for :title, "Title content" %>
+<% end %>
 
-> Would you like to support Nice Partials development and have your logo featured here? [Reach out!](http://twitter.com/andrewculver)
+# app/views/components/_card.html.erb
+<%= yield :title %>
+<%= yield %>
+```
+
+There's a number of gotchas here:
 
+- The `content_for` writes to `:title` across every partial, thus leaking.
+- The rendering block isn't called until `<%= yield %>` is, so the `content_for` isn't called and `<%= yield :title %>` outputs nothing.
 
-## Benefits of Nice Partials
+With Nice Partials the yield is automatic and we can write content for just that partial without leaking:
+
+```html+erb
+<%= render "components/card" do |partial| %>
+  <% partial.title "Title content" %>
+<% end %>
+
+# app/views/components/_card.html.erb
+<%= partial.title %>
+```
+
+This happens because Nice Partials checks the partial source code for any `yield` calls that calls Rails' `capture` helper — e.g. `yield` and `yield something` but not `yield :title`. If there's no capturing yields Nice Partials calls `capture` for you.
+
+This means Nice Partials also respect existing yield calls in your partial, so you can upgrade existing partials bit by bit or not at all if you don't want to.
 
 Nice Partials:
 
- - is just regular Rails view partials like you're used to.
- - reduces the friction when extracting components.
- - only ends up in the specific partials you need its functionality in.
- - reduces context switching.
- - allows isolated helper logic alongside your partial view code.
- - doesn't require any upgrades to existing partials for interoperability.
- - are still testable!
+  - are still regular Rails view partials.
+  - reduces the friction when extracting components.
+  - only ends up in the specific partials you need the functionality.
+  - reduces context switching.
+  - allows isolated helper logic alongside your partial view code.
+  - doesn't require any upgrades to existing partials for interoperability.
+  - are still testable!
 
+Nice Partials are a lightweight and more Rails-native alternative to [ViewComponent](http://viewcomponent.org). Providing many of the same benefits as ViewComponent with less ceremony.
 
-## Can't I do the same thing without Nice Partials?
+## What extra powers does `partial` give me?
 
-You can almost accomplish the same thing without Nice Partials, but in practice you end up having to flush the content buffers after using them, leading to something like this:
+Having a `partial` object lets us add abstractions that are hard to replicate in standard Rails partials.
+
+### Passing content from the render call
+
+Nice Partials will use Action View's `local_assigns`, which stores any `locals` passed to `render`, as the basis for contents.
+
+Given a partial like
 
 ```html+erb
-<div class="card">
-  <%= yield :image %>
-  <% content_for :image, flush: true do '' end %>
-  <div class="card-body">
-    <h5 class="card-title"><%= title %></h5>
-    <% if content_for? :body %>
-      <p class="card-text">
-        <%= yield :body %>
-        <% content_for :body, flush: true do '' end %>
-      </p>
-    <% end %>
-  </div>
-</div>
+<%# app/views/components/_card.html.erb %>
+<%= partial.title %> written by <%= partial.byline %>
 ```
 
-Earlier iterations of Nice Partials aimed to simply clean up this syntax with helper methods like `flush_content_for`, but because the named content buffers were in a global namespace, it was also possible to accidentally create situations where two partials with a `:body` content area would end up interfering with each other, depending on the order they're nested and rendered.
+Can then be used like this:
+
+```html+erb
+<%= render "components/card", title: "Hello there", byline: "Some guy" do |partial| %>
+  <% partial.byline ", who writes stuff" %>
+<% end %>
+```
 
-Nice Partials resolves the last-mile issues with standard view partials and content buffers by introducing a small, generic object that helps transparently namespace your named content buffers. This same object can also be used to define helper methods specific to your partial that are isolated from the global helper namespace.
+This will then output "Hello there written by Some guy, who writes stuff"
 
+You can also use `slice` to pass on content from an outer partial:
 
-## Setup
+```html+erb
+<%= render "components/card", partial.slice(:title, :byline) %>
+```
 
-Add to your `Gemfile`:
+### Appending content from the view into a section
 
-```ruby
-gem "nice_partials"
+Nice Partials supports calling any method on `ActionView::Base`, like the helpers shown here, and then have them auto-append to the section.
+
+```html+erb
+<%= render "components/card" do |partial| %>
+  <% partial.title.t ".title" %>
+  <% partial.body.render "form", tangible_thing: @tangible_thing %>
+  <% partial.image.image_tag image_path("example.jpg"), alt: "An example image" %>
+<% end %>
 ```
 
-## Usage
+### I18n: translating and setting multiple keys at a time
 
-### When to use Nice Partials
+`partial.t` is a shorthand to translate and assign multiple keys at once:
 
-You only need to use Nice Partials when:
+```html+erb
+<% partial.t :title, description: :header, byline: "custom.key" %>
 
- - you want to define one or more named content areas in your partial. If you don't have multiple named content areas in your partial, you could just pass your content into the partial using the standard block and `yield` approach.
+# The above is the same as writing:
+<% partial.title t(".title") %>
+<% partial.description t(".header") %>
+<% partial.byline t("custom.key") %>
+```
 
- - you want to specifically isolate your helper methods for a specific partial.
+### Capturing options in the rendering block and building HTML tags in the partial
 
-### Using Nice Partials
+You can pass keyword options to a writer method and they'll be auto-added to `partial.x.options`, like so:
 
-Nice Partials is invoked automatically when you render your partial with a block like so:
+```html+erb
+<%= render "components/card" do |partial| %>
+  <% partial.title "Title content", class: "text-m4", data: { controller: "title" } %>
+<% end %>
+
+# app/views/components/_card.html.erb:
+# From the render above `title.options` now contain `{ class: "text-m4", data: { controller: "title" } }`.
+# The options can be output via `<%=` and are automatically run through `tag.attributes` to be converted to HTML attributes.
+
+<h1 <%= partial.title.options %>><%= partial.title %></h1> # => <h1 class="text-m4" data-controller="title">Title content</h1>
+```
+
+`partial` also supports auto-generating an element by calling any of Rails' `tag` methods e.g.:
 
 ```html+erb
-<%= render 'components/card' do |partial| %>
-  <%= partial.content_for :some_section do %>
-    Some content!
-  <% end %>
+# This shorthand gets us the same h1 element from the previous example:
+<%= partial.title.h1 %> # => <h1 class="text-m4" data-controller="title">Title content</h1>
+
+# Internally, this is similar to doing:
+<%= tag.h1 partial.title.to_s, partial.title.options %>
+```
+
+### Yielding tag builders into the rendering block
+
+The above example showed sending options from the rendering block into the partial and having it construct elements.
+
+But the partial can also prepare tag builders that the rendering block can then extend and finalize:
+
+```html+erb
+<% render "components/card" do |partial|
+  <% partial.title { |tag| tag.h1 "Title content" } %>
 <% end %>
+
+# app/views/components/_card.html.erb
+<% partial.title.yield tag.with_options(class: "text-m4", data: { controller: "title" }) %> # => <h1 class="text-m4" data-controller="title">Title content</h1>
 ```
 
-Now within the partial file itself, you can use `<%= partial.yield :some_section %>` to render whatever content areas you want to be passed into your partial.
+### Smoother conditional rendering
 
-### Accessing the content returned from `yield`
+In regular Rails partials it's common to see `content_for?` used to conditionally rendering something. With Nice Partials we can do this:
 
-In a regular Rails partial:
+```html+erb
+<% if partial.title? %>
+  <% partial.title.h1 %>
+<% end %>
+```
+
+But since sections respond to and leverage `present?`, we can shorten the above to:
 
 ```html+erb
-<%= render 'components/card' do %>
+<% partial.title.presence&.h1 %>
+```
+
+This way no empty h1 element is rendered.
+
+### Accessing the content returned via `partial.yield`
+
+To access the inner content lines in the block here, partials have to manually insert a `<%= yield %>` call.
+
+```html+erb
+<%= render "components/card" do %>
   Some content!
   Yet more content!
 <% end %>
 ```
 
-You can access the inner content lines through what's returned from `yield`:
+With Nice Partials, `partial.yield` returns the same content:
 
 ```html+erb
-<%# app/views/components/_card.html.erb %>
-<%= yield %> # => "Some content!\n\nYet more content!"
+# app/views/components/_card.html.erb
+<%= partial.yield %> # => "Some content!\n\nYet more content!"
+```
+
+### Referring to the outer partial while rendering another
+
+During a rendering block `partial` refers to the outer partial, so you can compose them.
+
+```html+erb
+<% partial.title "Title content" %>
+
+<%= render "components/card" do |cp| %>
+  <% cp.title partial.title %>
+<% end %>
+```
+
+### Passing content from one partial to the next
+
+If you need to pass content into another partial, `content_from` lets you pass the keys to extract and then a hash to rename keys.
+
+```html+erb
+<%= render "components/card" do |cp| %>
+  <% cp.content_from partial, :title, byline: :header %>
+<% end %>
 ```
 
-With Nice Partials, you can call `partial.yield` without arguments and return the same `"Some content!\n\nYet more content!"`.
+Here, we copied the `partial.title` to `cp.title` and `partial.byline` became `cp.header`.
 
 ### Defining and using well isolated helper methods
 
-To minimize the amount of pollution in the global helper namespace, you can use the shared context object to define helper methods specifically for your partials _within your partial_ like so:
+If you want to have helper methods that are available only within your partials, you can call `partial.helpers` directly:
 
 ```html+erb
+# app/views/components/_card.html.erb
 <% partial.helpers do
-
   # references should be a link if the user can drill down, otherwise just a text label.
   def reference_to(user)
     # look! this method has access to the scope of the entire view context and all the other helpers that come with it!
@@ -154,17 +258,30 @@ To minimize the amount of pollution in the global helper namespace, you can use
       object.name
     end
   end
-
 end %>
-```
 
-Then later in the partial you can use the helper method like so:
-
-```html+erb
+# Later in the partial we can use the method:
 <td><%= partial.reference_to(user) %></td>
 ```
 
-## Development
+## Sponsored By
+
+<a href="https://bullettrain.co" target="_blank">
+  <img src="https://github.com/CanCanCommunity/cancancan/raw/develop/logo/bullet_train.png" alt="Bullet Train" width="400"/>
+</a>
+<br/>
+<br/>
+
+> Would you like to support Nice Partials development and have your logo featured here? [Reach out!](http://twitter.com/andrewculver)
+
+
+## Setup
+
+Add to your `Gemfile`:
+
+```ruby
+gem "nice_partials"
+```
 
 ### Testing
 
@@ -174,4 +291,4 @@ bundle exec rake test
 
 ## MIT License
 
-Copyright (C) 2020 Andrew Culver <https://bullettrain.co> and Dom Christie <https://domchristie.co.uk>. Released under the MIT license.
+Copyright (C) 2022 Andrew Culver <https://bullettrain.co> and Dom Christie <https://domchristie.co.uk>. Released under the MIT license.

data/Rakefile

@@ -1,6 +1,8 @@
 # # #
 # Get gemspec info
 
+require "bundler/gem_tasks"
+
 gemspec_file = Dir["*.gemspec"].first
 gemspec = eval File.read(gemspec_file), binding, gemspec_file
 info = "#{gemspec.name} | #{gemspec.version} | " \
@@ -26,12 +28,3 @@ desc "#{gemspec.name} | IRB"
 task :irb do
   sh "irb -I ./lib -r #{gemspec.name.gsub '-','/'}"
 end
-
-# # #
-# Run specs
-
-desc "#{gemspec.name} | Test"
-task :test do
-  sh "for file in test/{**/,}*_test.rb; do ruby -Ilib:test $file; done"
-end
-task default: :test

data/lib/nice_partials/helper.rb

@@ -1,6 +1,10 @@
 require_relative "partial"
 
 module NicePartials::Helper
+  def nice_partial_with(local_assigns)
+    NicePartials::Partial.new(self, local_assigns)
+  end
+
   def nice_partial
     NicePartials::Partial.new(self)
   end

data/lib/nice_partials/monkey_patch.rb

@@ -48,8 +48,9 @@ module NicePartials::RenderingWithAutoContext
 
   # Overrides `ActionView::Helpers::RenderingHelper#render` to push a new `nice_partial`
   # on the stack, so rendering has a fresh `partial` to store content in.
-  def render(*)
-    __partials.prepend nice_partial
+  def render(options = {}, locals = {}, &block)
+    partial_locals = options.is_a?(Hash) ? options[:locals] : locals
+    __partials.prepend nice_partial_with(partial_locals)
     super
   ensure
     __partials.shift
@@ -115,6 +116,6 @@ module NicePartials::CapturingYieldDetection
   # Note: `<%= yield %>` becomes `yield :layout` with no `render` `block`, though this method assumes a block is passed.
   def has_capturing_yield?
     defined?(@has_capturing_yield) ? @has_capturing_yield :
-      @has_capturing_yield = source.match?(/\byield[\(? ]+(%>|[^:])/)
+      @has_capturing_yield = source.match?(/[^\.\b]yield[\(? ]+(%>|[^:])/)
   end
 end

data/lib/nice_partials/partial/content.rb

@@ -0,0 +1,54 @@
+class NicePartials::Partial::Content
+  class Options < Hash
+    def initialize(view_context)
+      @view_context = view_context
+    end
+
+    def to_s
+      @view_context.tag.attributes(self)
+    end
+  end
+
+  def initialize(view_context, content = nil)
+    @view_context, @options = view_context, Options.new(view_context)
+    @content = ActiveSupport::SafeBuffer.new and concat content
+  end
+  delegate :to_s, :present?, to: :@content
+
+  # Contains options passed to a partial:
+  #
+  #   <% partial.title class: "post-title" %> # partial.title.options # => { class: "post-title" }
+  #
+  #   # Automatically runs `tag.attributes` when `to_s` is called, e.g.:
+  #   <h1 <% partial.title.options %>> # => <h1 class="post-title">
+  attr_reader :options
+
+  def write?(content = nil, **new_options, &block)
+    @options.merge! new_options
+    append content or capture block
+  end
+
+  def write(...)
+    write?(...)
+    self
+  end
+
+  private
+
+  def append(content)
+    case
+    when content.respond_to?(:render_in) then concat  content.render_in(@view_context)
+    when content.respond_to?(:call)      then capture content
+    else
+      concat content
+    end
+  end
+
+  def capture(block)
+    append @view_context.capture(&block) if block
+  end
+
+  def concat(string)
+    @content << string.to_s if string.present?
+  end
+end

data/lib/nice_partials/partial/section.rb

@@ -1,43 +1,48 @@
-class NicePartials::Partial::Section
-  def initialize(view_context)
-    @view_context = view_context
-    @content = @pending_content = nil
+class NicePartials::Partial::Section < NicePartials::Partial::Content
+  def yield(*arguments)
+    chunks.each { append @view_context.capture(*arguments, &_1) }
+    self
   end
 
-  def content_for(*arguments, &block)
-    if write_content_for(arguments.first, &block)
-      nil
-    else
-      capture_content_for(*arguments) if pending?
-      @content
-    end
+  def present?
+    chunks.present? || super
   end
 
-  def content?
-    pending? || @content
-  end
-
-  private
+  undef_method :p # Remove Kernel.p here to pipe through method_missing and hit tag proxy.
 
-  def write_content_for(content = nil, &block)
-    if content && !pending?
-      concat content
+  # Implements our proxying to the `@view_context` or `@view_context.tag`.
+  #
+  # `@view_context` proxying forwards the message and automatically appends any content, so you can do things like:
+  #
+  #   <% partial.body.render "form", tangible_thing: @tangible_thing %>
+  #   <% partial.body.link_to @document.name, @document %>
+  #   <% partial.body.t ".body" %>
+  #
+  # `@view_context.tag` proxy lets you build bespoke elements based on content and options provided:
+  #
+  #    <% partial.title "Some title content", class: "xl" %> # Write the content and options to the `title`
+  #    <% partial.title.h2 ", appended" %> # => <h2 class="xl">Some title content, appended</h2>
+  #
+  # Note that NicePartials don't support deep merging attributes out of the box.
+  # For that, bundle https://github.com/seanpdoyle/attributes_and_token_lists
+  def method_missing(meth, *arguments, **keywords, &block)
+    if meth != :p && @view_context.respond_to?(meth)
+      append @view_context.public_send(meth, *arguments, **keywords, &block)
     else
-      @pending_content = block if block
+      @view_context.tag.public_send(meth, @content + arguments.first.to_s, **options.merge(keywords), &block)
     end
   end
+  def respond_to_missing?(...) = @view_context.respond_to?(...)
 
-  def capture_content_for(*arguments)
-    concat @view_context.capture(*arguments, &@pending_content)
-    @pending_content = nil
-  end
+  private
 
-  def concat(string)
-    @content ||= ActiveSupport::SafeBuffer.new
-    @content << string.to_s if string.present?
+  def capture(block)
+    if block&.arity&.nonzero?
+      chunks << block
+    else
+      super
+    end
   end
 
-  def pending?
-    @pending_content
-  end
+  def chunks() = @chunks ||= []
 end

data/lib/nice_partials/partial.rb

@@ -1,57 +1,111 @@
 module NicePartials
   class Partial
+    autoload :Content, "nice_partials/partial/content"
     autoload :Section, "nice_partials/partial/section"
     autoload :Stack, "nice_partials/partial/stack"
 
     delegate_missing_to :@view_context
 
-    #   <%= render "nice_partial" do |p| %>
-    #     <% p.content_for :title, "Yo" %>
-    #     This content can be accessed through calling `yield`.
-    #   <% end %>
-    #
-    # Then in the nice_partial:
-    #   <%= content.content_for :title %> # => "Yo"
-    #   <%= content.output_buffer %> # => "This line is printed to the `output_buffer`."
-    attr_accessor :output_buffer
-
-    def initialize(view_context)
-      @view_context = view_context
-      @contents = Hash.new { |h, k| h[k] = Section.new(@view_context) }
+    def initialize(view_context, local_assigns = nil)
+      @view_context, @local_assigns = view_context, local_assigns
     end
 
     def yield(*arguments, &block)
       if arguments.empty?
-        output_buffer
+        @captured_buffer
       else
         content_for(*arguments, &block)
       end
     end
 
     def helpers(&block)
-      class_eval &block
+      self.class.class_eval(&block)
+    end
+
+    # `translate` is a shorthand to set `content_for` with content that's run through
+    # the view's `translate`/`t` context.
+    #
+    #   partial.t :title                       # => partial.content_for :title, t(".title")
+    #   partial.t title: :section              # => partial.content_for :title, t(".section")
+    #   partial.t title: "some.custom.key"     # => partial.content_for :title, t("some.custom.key")
+    #   partial.t :description, title: :header # Mixing is supported too.
+    #
+    # Note that `partial.t "some.custom.key"` can't derive a `content_for` name, so an explicit
+    # name must be provided e.g. `partial.t title: "some.custom.key"`.
+    def translate(*names, **renames)
+      names.chain(renames).each do |name, key = name|
+        content_for name, @view_context.t(key.is_a?(String) ? key : ".#{key}")
+      end
+    end
+    alias t translate
+
+    # Allows an inner partial to copy content from an outer partial.
+    #
+    # Additionally a hash of keys to rename in the new partial context can be passed.
+    #
+    #   First, an outer partial gets some content set:
+    #   <% partial.title "Hello there" %>
+    #   <% partial.byline "Somebody" %>
+    #
+    #   Second, a new partial is rendered, but we want to extract the title, byline content but rename the byline key too:
+    #   <%= render "shared/title" do |cp| %>
+    #     <% cp.content_from partial, :title, byline: :name %>
+    #   <% end %>
+    #
+    #   # Third, the contents with any renames are accessible in shared/_title.html.erb:
+    #   <%= partial.title %> # => "Hello there"
+    #   <%= partial.name %> # => "Somebody"
+    def content_from(partial, *names, **renames)
+      names.chain(renames).each { |key, new_key = key| public_send new_key, partial.public_send(key).to_s }
     end
 
     # Similar to Rails' built-in `content_for` except it defers any block execution
     # and lets you pass arguments into it, like so:
     #
     #   # Here we store a block with some eventual content…
-    #   <% partial.content_for :title do |tag|
-    #     <%= tag.h1 %>
-    #   <% end %>
+    #   <% partial.title { |tag| tag.h1 } %>
     #
-    #  # …which is then invoked with some predefined options later.
-    #  <%= partial.content_for :title, tag.with_options(class: "text-bold") %>
-    def content_for(name, content = nil, *arguments, &block)
-      @contents[name].content_for(content, *arguments, &block)
+    #  # …which we can then yield into with some predefined options later.
+    #  <%= partial.title.yield tag.with_options(class: "text-bold") %>
+    def section(name, content = nil, **options, &block)
+      section_from(name).then { _1.write?(content, **options, &block) ? nil : _1 }
+    end
+
+    def section?(name)
+      @sections&.dig(name).present?
     end
+    alias content_for? section?
 
-    def content_for?(name)
-      @contents[name].content?
+    def content_for(...)
+      section(...)&.to_s
+    end
+
+    def slice(*keys)
+      keys.index_with { content_for _1 }
     end
 
     def capture(*arguments, &block)
-      self.output_buffer = @view_context.capture(*arguments, self, &block)
+      @captured_buffer = @view_context.capture(*arguments, self, &block)
+    end
+
+    private
+
+    def section_from(name)
+      @sections ||= {} and @sections[name] ||= Section.new(@view_context, @local_assigns&.dig(name))
+    end
+
+    def method_missing(meth, *arguments, **keywords, &block)
+      if @view_context.respond_to?(meth)
+        @view_context.public_send(meth, *arguments, **keywords, &block)
+      else
+        define_accessor meth and public_send(meth, *arguments, **keywords, &block)
+      end
+    end
+
+    def define_accessor(name)
+      name = name.to_s.chomp("?").to_sym
+      self.class.define_method(name) { |content = nil, **options, &block| section(name, content, **options, &block) }
+      self.class.define_method("#{name}?") { section?(name) }
     end
   end
 end

data/lib/nice_partials/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NicePartials
-  VERSION = "0.1.9"
+  VERSION = "0.9.0"
 end

data/lib/nice_partials.rb

@@ -4,9 +4,8 @@ require_relative "nice_partials/version"
 
 module NicePartials
   def self.locale_prefix_from(lookup_context, block)
-    root_paths = lookup_context.view_paths.map(&:path)
     partial_location = block.source_location.first.dup
-    root_paths.each { |path| partial_location.gsub!(/^#{path}\//, '') }
+    lookup_context.view_paths.each { partial_location.delete_prefix!(_1.path)&.delete_prefix!("/") }
     partial_location.split('.').first.gsub('/_', '/').gsub('/', '.')
   end
 end

data/nice_partials.gemspec

@@ -12,9 +12,15 @@ Gem::Specification.new do |gem|
   gem.homepage      = "https://github.com/bullet-train-co/nice_partials"
   gem.license       = "MIT"
 
-  gem.files         = Dir["{**/}{.*,*}"].select{ |path| File.file?(path) && path !~ /^pkg/ }
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+    # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  gem.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  gem.bindir = "exe"
+  gem.executables = gem.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = ">= 2.0"

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: nice_partials
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.9.0
 platform: ruby
 authors:
 - Andrew Culver
 - Dom Christie
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2022-08-15 00:00:00.000000000 Z
+date: 2023-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview
@@ -61,8 +61,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -73,25 +71,11 @@ files:
 - lib/nice_partials/helper.rb
 - lib/nice_partials/monkey_patch.rb
 - lib/nice_partials/partial.rb
+- lib/nice_partials/partial/content.rb
 - lib/nice_partials/partial/section.rb
 - lib/nice_partials/partial/stack.rb
 - lib/nice_partials/version.rb
-- nice_partials-0.1.8.gem
 - nice_partials.gemspec
-- test/fixtures/_basic.html.erb
-- test/fixtures/_card.html.erb
-- test/fixtures/_clobberer.html.erb
-- test/fixtures/_partial_accessed_in_outer_context.html.erb
-- test/fixtures/card_test.html.erb
-- test/fixtures/translations/_nice_partials_translated.html.erb
-- test/fixtures/translations/_translated.html.erb
-- test/fixtures/yields/_object.html.erb
-- test/fixtures/yields/_plain.html.erb
-- test/fixtures/yields/_plain_nested.html.erb
-- test/fixtures/yields/_symbol.html.erb
-- test/renderer/translation_test.rb
-- test/renderer_test.rb
-- test/test_helper.rb
 homepage: https://github.com/bullet-train-co/nice_partials
 licenses:
 - MIT
@@ -111,22 +95,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: A little bit of magic to make partials perfect for components.
-test_files:
-- test/fixtures/_basic.html.erb
-- test/fixtures/_card.html.erb
-- test/fixtures/_clobberer.html.erb
-- test/fixtures/_partial_accessed_in_outer_context.html.erb
-- test/fixtures/card_test.html.erb
-- test/fixtures/translations/_nice_partials_translated.html.erb
-- test/fixtures/translations/_translated.html.erb
-- test/fixtures/yields/_object.html.erb
-- test/fixtures/yields/_plain.html.erb
-- test/fixtures/yields/_plain_nested.html.erb
-- test/fixtures/yields/_symbol.html.erb
-- test/renderer/translation_test.rb
-- test/renderer_test.rb
-- test/test_helper.rb
+test_files: []

data/.gitignore

@@ -1,3 +0,0 @@
-Gemfile.lock
-/pkg
-*~

data/.travis.yml

@@ -1,19 +0,0 @@
-sudo: false
-language: ruby
-
-rvm:
-- 3.1
-- 3.0
-- 2.7
-- 2.6
-- 2.5
-- 2.4
-- ruby-head
-- jruby-9.2.11.1
-- truffleruby-20.2.0
-
-matrix:
-  allow_failures:
-    - rvm: 2.4
-    - rvm: ruby-head
-#   fast_finish: true

data/test/fixtures/_basic.html.erb

@@ -1 +0,0 @@
-<%= partial.yield :message %>

data/test/fixtures/_card.html.erb

@@ -1,11 +0,0 @@
-<div class="card">
-  <%= partial.yield :image %>
-  <div class="card-body">
-    <h5 class="card-title"><%= title %></h5>
-    <% if partial.content_for? :body %>
-      <p class="card-text">
-        <%= partial.content_for :body, tag.with_options(class: "text-bold") %>
-      </p>
-    <% end %>
-  </div>
-</div>

data/test/fixtures/_clobberer.html.erb

@@ -1,3 +0,0 @@
-<% p "it's clobbering time" %>
-<%# TODO: Remove this file once `p` has been removed post deprecation, but don't change it yet. %>
-<%= p.yield :message %>

data/test/fixtures/_partial_accessed_in_outer_context.html.erb

@@ -1,11 +0,0 @@
-<% partial.content_for :original_message, "hello" %>
-
-<%= render "basic" do |cp| %>
-  <% cp.content_for :message, partial.content_for(:original_message) %>
-<% end %>
-
-<%= render "basic" do |cp| %>
-  <% cp.content_for :message, "goodbye" %>
-<% end %>
-
-<span><%= partial.content_for :message %></span>

data/test/fixtures/card_test.html.erb

@@ -1,9 +0,0 @@
-<%= render "card", title: "Some Title" do |p| %>
-  <% p.content_for :body do |tag| %>
-    <%= tag.p "Lorem Ipsum" %>
-  <% end %>
-
-  <% p.content_for :image do %>
-    <img src="https://example.com/image.jpg" />
-  <% end %>
-<% end %>

data/test/fixtures/translations/_nice_partials_translated.html.erb

@@ -1,3 +0,0 @@
-<%= render("basic") do |partial| %>
-  <%= partial.content_for :message, t(".message") %>
-<% end %>

data/test/fixtures/translations/_translated.html.erb

@@ -1 +0,0 @@
-<%= t ".message" %>

data/test/fixtures/yields/_object.html.erb

@@ -1 +0,0 @@
-<%= yield Hash.new(custom_key: :custom_value) %>

data/test/fixtures/yields/_plain.html.erb

@@ -1 +0,0 @@
-<%= yield %>

data/test/fixtures/yields/_plain_nested.html.erb

@@ -1,3 +0,0 @@
-<%= render "yields/plain" do %>
-  <%= yield %>
-<% end %>

data/test/fixtures/yields/_symbol.html.erb

@@ -1 +0,0 @@
-<%= yield :message %>

data/test/renderer/translation_test.rb

@@ -1,26 +0,0 @@
-require "test_helper"
-
-module Renderer; end
-
-class Renderer::TranslationTest < NicePartials::Test
-  setup do
-    I18n.backend.store_translations "en", { translations: {
-      translated: { message: "message" },
-      nice_partials_translated: { message: "nice_partials" }
-    } }
-  end
-
-  teardown { I18n.reload! }
-
-  test "clean translation render" do
-    render "translations/translated"
-
-    assert_rendered "message"
-  end
-
-  test "translations insert prefix from originating partial" do
-    render "translations/nice_partials_translated"
-
-    assert_rendered "nice_partials"
-  end
-end

data/test/renderer_test.rb

@@ -1,83 +0,0 @@
-require "test_helper"
-
-class RendererTest < NicePartials::Test
-  test "render basic nice partial" do
-    render("basic") { |p| p.content_for :message, "hello from nice partials" }
-
-    assert_rendered "hello from nice partials"
-  end
-
-  test "render nice partial in card template" do
-    render(template: "card_test")
-
-    assert_rendered "Some Title"
-    assert_rendered '<p class="text-bold">Lorem Ipsum</p>'
-    assert_rendered "https://example.com/image.jpg"
-  end
-
-  test "accessing partial in outer context won't leak state to inner render" do
-    render "partial_accessed_in_outer_context"
-
-    assert_rendered "hello"
-    assert_rendered "goodbye"
-    assert_rendered "<span></span>"
-    assert_not_includes rendered, "hellogoodbye"
-  end
-
-  test "explicit yield without any arguments auto-captures passed block" do
-    render "yields/plain" do |partial, auto_capture_shouldnt_pass_extra_argument|
-      assert_kind_of NicePartials::Partial, partial
-      assert_nil auto_capture_shouldnt_pass_extra_argument
-    end
-  end
-
-  test "explicit yield with symbol auto-captures passed block" do
-    render "yields/symbol" do |partial, auto_capture_shouldnt_pass_extra_argument|
-      assert_kind_of NicePartials::Partial, partial
-      assert_nil auto_capture_shouldnt_pass_extra_argument
-    end
-  end
-
-  test "explicit yield with object won't auto-capture but make partial available in capture" do
-    render "yields/object" do |object, partial|
-      assert_equal Hash.new(custom_key: :custom_value), object
-      assert_kind_of NicePartials::Partial, partial
-    end
-  end
-
-  test "explicit yield without any arguments with nesting" do
-    render "yields/plain_nested" do
-      tag.span "Output in outer partial through yield"
-    end
-
-    assert_rendered "<span>Output in outer partial through yield</span>"
-  end
-
-  test "output_buffer captures content not written via yield/content_for" do
-    nice_partial = nil
-    render "basic" do |p|
-      nice_partial = p
-      p.content_for :message, "hello from nice partials"
-      "Some extra content"
-    end
-
-    assert_rendered "hello from nice partials"
-    assert_equal "Some extra content", nice_partial.yield
-  end
-
-  test "doesn't clobber Kernel.p" do
-    assert_output "\"it's clobbering time\"\n" do
-      render("clobberer") { |p| p.content_for :message, "hello from nice partials" }
-    end
-
-    assert_rendered "hello from nice partials"
-  end
-
-  test "deprecates top-level access through p method" do
-    assert_deprecated /p is deprecated and will be removed from nice_partials \d/, NicePartials::DEPRECATOR do
-      assert_output "\"it's clobbering time\"\n" do
-        render("clobberer") { |p| p.content_for :message, "hello from nice partials" }
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,17 +0,0 @@
-require "active_support"
-require "active_support/testing/autorun"
-require "action_controller"
-require "action_view"
-require "action_view/test_case"
-
-require "nice_partials"
-
-class NicePartials::Test < ActionView::TestCase
-  TestController.view_paths << "test/fixtures"
-
-  private
-
-  def assert_rendered(matcher)
-    assert_match matcher, rendered
-  end
-end