nice_partials 0.1.4 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3275a33c9f1de9e8267042ab36b485297451804bb1c704082576890d800a20cd
-  data.tar.gz: 7b55dd85d2d291eb411b564819c602e039dc412ec8cbb82df7b58f8472d062e4
+  metadata.gz: dc6e751d8a192aa46fe3ee5401fe924c4dc1f5c6c3c7fabe8c22f468ff3a344c
+  data.tar.gz: de5a48e0d84e96a40b85293933af3dadd4977e6dfa2dd06522c85e1a6fbd0576
 SHA512:
-  metadata.gz: ef49218a25d20bb8b0446b5b0dd975fb173191ea1e236e9dfa6a700fec717ef9b24f8f06fcc114b4e1e731ddf62aed143cd225193cd6ebc64acb4fd06edb0e3b
-  data.tar.gz: 52e0f030102269996e35132ad2ff16bcb94100faca76787b13059a31450c0d65456961b71bf69d2610f46bb8f48a9b410f4a01090c96f946d2d5b1ec6ece9b8c
+  metadata.gz: 5f56fb3b92520c7a818b6ced0225def224a265a9ca2400d70e283300df8eef3fc266c6b65fa2e4e24856d7eccb6c0b39bdadf056bdec76c499be68fd9d90a982
+  data.tar.gz: 6a58763a68c0aa76cfee32432c730166cd96a19b2c8a1e8428c26260663ff706fc4883af07e9b1782da0d7e493ca7f4f8883fde223b75674967acce7a3780bc1

data/.gitignore

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

data/.travis.yml

@@ -2,6 +2,7 @@ sudo: false
 language: ruby
 
 rvm:
+- 3.1
 - 3.0
 - 2.7
 - 2.6

data/CHANGELOG.md

@@ -1,9 +1,63 @@
 ## CHANGELOG
 
+* Remove need to insert `<% yield p = np %>` in partials.
+
+  Nice Partials now automatically captures blocks passed to `render`.
+  Instead of `p`, a `partial` method has been added to access the
+  current `NicePartials::Partial` object.
+
+  Here's a script to help update your view code:
+
+  ```ruby
+  files_to_inspect = []
+
+  Dir["app/views/**/*.html.erb"].each do |path|
+    if contents = File.read(path).match(/(<%=? yield\(?.*? = np\)? %>\n+)/m)&.post_match
+      files_to_inspect << path if contents.match?(/render.*?do \|/)
+
+      contents.gsub! /\bp\.(?=yield|helpers|content_for|content_for\?)/, "partial."
+      File.write path, contents
+    end
+  end
+
+  if files_to_inspect.any?
+    puts "These files had render calls with a block parameter and likely require some manual edits:"
+    puts files_to_inspect
+  else
+    puts "No files with render calls with a block parameter found, you're likely all set"
+  end
+  ```
+
+* Support manual `yield`s in partials.
+
+  Due to the automatic yield support above, support has also been added for manual `yield some_object` calls.
+
+  Nice Partials automatically appends the `partial` to the yielded arguments, so you can
+  change `render … do |some_object|` to `render … do |some_object, partial|`.
+
+* Deprecate `p` as the partial object access. Use `partial` instead.
+
+* Expose `partial.yield` to access the captured output buffer.
+
+  Lets you access what a `<%= yield %>` call returned, like this:
+
+  ```erb
+  <%= render "card" do %>
+    This is the content of the internal output buffer
+  <% end %>
+  ```
+
+  ```erb
+  # app/views/cards/_card.html.erb
+  # This can be replaced with `partial.yield`.
+  <%= yield %> # Will output "This is the content of the internal output buffer"
+  ```
+
+### 0.1.7
+
 * Rely on `ActiveSupport.on_load :action_view`
 * Add support for Ruby 3.0
 
 ### 0.1.0
 
 * Initial release
-

data/README.md

@@ -1,34 +1,34 @@
 # 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 extends the concept of [`content_for` blocks and `yield`](https://guides.rubyonrails.org/layouts_and_rendering.html#using-the-content-for-method) for those times when a partial needs to provide one or more named "content areas" or "slots". This thin, optional layer of magic helps make traditional Rails view partials an even better fit for extracting components from your views, like so:
+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:
 
 `app/views/components/_card.html.erb`:
 ```html+erb
 <div class="card">
-  <%= p.yield :image %>
+  <%= partial.yield :image %>
   <div class="card-body">
     <h5 class="card-title"><%= title %></h5>
-    <% if p.content_for? :body %>
+    <% if partial.content_for? :body %>
       <p class="card-text">
-        <%= p.yield :body %>
+        <%= partial.yield :body %>
       </p>
     <% end %>
   </div>
 </div>
 ```
 
-These partials can still be utilized with a standard `render` call, but you can specify how to populate the content areas like so:
+Then you can call `render`, but specify how to populate the content areas:
 
 ```html+erb
-<%= render 'components/card', title: 'Some Title' do |p| %>
-  <% p.content_for :body do %>
+<%= 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.
   <% end %>
 
-  <% p.content_for :image do %>
+  <% partial.content_for :image do %>
     <%= image_tag image_path('example.jpg'), alt: 'An example image' %>
   <% end %>
 <% end %>
@@ -50,7 +50,7 @@ Nice Partials is a lightweight and hopefully more Rails-native alternative to [V
 
 ## Benefits of Nice Partials
 
-Compared to something more heavy-handed, Nice Partials:
+Nice Partials:
 
  - is just regular Rails view partials like you're used to.
  - reduces the friction when extracting components.
@@ -104,32 +104,46 @@ You only need to use Nice Partials when:
 
  - you want to specifically isolate your helper methods for a specific partial.
 
-### Use Nice Partials in a partial
+### Using Nice Partials
 
-To invoke nice partials, start your partial file with the following:
+Nice Partials is invoked automatically when you render your partial with a block like so:
 
 ```html+erb
-<% yield p = np %>
+<%= render 'components/card' do |partial| %>
+  <%= partial.content_for :some_section do %>
+    Some content!
+  <% end %>
+<% end %>
 ```
 
-Here's what is happening here:
+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.
 
-  - `yield` executes the block we receive when someone uses our partial.
-  - `np` fetches an instance of the generic class that helps isolate our content buffers and helper methods.
-  - `p = np` ensures we have a reference to that object in this partial.
-  - `yield p = np` ensures the developer using this partial also has a reference to that object, so they can define what goes in the various content buffers.
+### Accessing the content returned from `yield`
 
-(This is, [as far as we know](https://github.com/bullet-train-co/nice_partials/issues/1), the minimum viable invocation.)
+In a regular Rails partial:
 
-Once you've done this at the top of your partial file, you can then use `<%= p.yield :some_section %>` to render whatever content areas you want to be passed into your partial.
+```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`:
+
+```html+erb
+<%# app/views/components/_card.html.erb %>
+<%= yield %> # => "Some content!\n\nYet more content!"
+```
+
+With Nice Partials, you can call `partial.yield` without arguments and return the same `"Some content!\n\nYet more content!"`.
 
 ### 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:
 
 ```html+erb
-<% p.helpers do
+<% partial.helpers do
 
   # references should be a link if the user can drill down, otherwise just a text label.
   def reference_to(user)
@@ -147,7 +161,15 @@ end %>
 Then later in the partial you can use the helper method like so:
 
 ```html+erb
-<td><%= p.reference_to(user) %></td>
+<td><%= partial.reference_to(user) %></td>
+```
+
+## Development
+
+### Testing
+
+```sh
+bundle exec rake test
 ```
 
 ## MIT License

data/Rakefile

@@ -30,8 +30,8 @@ end
 # # #
 # Run specs
 
-desc "#{gemspec.name} | Spec"
-task :spec do
-  sh "for file in spec/*_spec.rb; do ruby $file; done"
+desc "#{gemspec.name} | Test"
+task :test do
+  sh "for file in test/{**/,}*_test.rb; do ruby -Ilib:test $file; done"
 end
-task default: :spec
+task default: :test

data/lib/nice_partials/helper.rb

@@ -1,25 +1,8 @@
 require_relative "partial"
 
 module NicePartials::Helper
-  def np
+  def nice_partial
     NicePartials::Partial.new(self)
   end
-
-  def nice_partials_push_t_prefix(prefix)
-    @_nice_partials_t_prefixes ||= []
-    @_nice_partials_t_prefixes << prefix
-  end
-
-  def nice_partials_pop_t_prefix
-    @_nice_partials_t_prefixes ||= []
-    @_nice_partials_t_prefixes.pop
-  end
-
-  def t(key, options = {})
-    if @_nice_partials_t_prefixes&.any? && key.first == '.'
-      key = "#{@_nice_partials_t_prefixes.last}#{key}"
-    end
-
-    super(key, options)
-  end
+  alias_method :np, :nice_partial
 end

data/lib/nice_partials/monkey_patch.rb

@@ -1,23 +1,120 @@
 # Monkey patch required to make `t` work as expected. Is this evil?
 # TODO Do we need to monkey patch other types of renderers as well?
-class ActionView::PartialRenderer
-  alias_method :original_render, :render
-
-  # See `content_for` in `lib/nice_partials/partial.rb` for something similar.
-  def render(partial, context, block)
-    if block
-      partial_prefix = nice_partials_locale_prefix_from_view_context_and_block(context, block)
-      context.nice_partials_push_t_prefix partial_prefix
+module NicePartials::RenderingWithLocalePrefix
+  ActionView::Base.prepend self
+
+  def capture(*, &block)
+    with_nice_partials_t_prefix(lookup_context, block) { super }
+  end
+
+  def t(key, options = {})
+    if (prefix = @_nice_partials_t_prefix) && key.first == '.'
+      key = "#{prefix}#{key}"
+    end
+
+    super(key, **options)
+  end
+
+  private
+
+  def with_nice_partials_t_prefix(lookup_context, block)
+    _nice_partials_t_prefix = @_nice_partials_t_prefix
+    @_nice_partials_t_prefix = block ? NicePartials.locale_prefix_from(lookup_context, block) : nil
+    yield
+  ensure
+    @_nice_partials_t_prefix = _nice_partials_t_prefix
+  end
+end
+
+require "active_support/deprecation"
+NicePartials::DEPRECATOR = ActiveSupport::Deprecation.new("1.0", "nice_partials")
+
+module NicePartials::RenderingWithAutoContext
+  ActionView::Base.prepend self
+
+  def __partials
+    @__partials ||= NicePartials::Partial::Stack.new
+  end
+  delegate :partial, to: :__partials
+
+  def p(*args)
+    if args.empty?
+      NicePartials::DEPRECATOR.deprecation_warning :p, :partial # In-branch printing so we don't warn on legit `Kernel.p` calls.
+      partial
+    else
+      super # …we're really Kernel.p
+    end
+  end
+
+  # 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
+    super
+  ensure
+    __partials.shift
+  end
+
+  # Since Action View passes any `yield`s in partials through `_layout_for`, we
+  # override `_layout_for` to detects if it's a capturing yield and append the
+  # current partial to the arguments.
+  #
+  # So `render … do |some_object|` can become `render … do |some_object, partial|`
+  # without needing to find and update the inner `yield some_object` call.
+  def _layout_for(*arguments, &block)
+    if block && !arguments.first.is_a?(Symbol)
+      capture_with_outer_partial_access(*arguments, &block)
     else
-      # Render partial calls with no block should disable any prefix magic.
-      context.nice_partials_push_t_prefix ''
+      super
     end
+  end
+
+  # Reverts `partial` to return the outer partial before the `render` call started.
+  #
+  # So we don't clobber the `partial` shown here:
+  #
+  #   <%= render "card" do |inner_partial| %>
+  #     <% inner_partial.content_for :title, partial.content_for(:title) %>
+  #   <% end %>
+  #
+  # Note: this happens because the `@partial` instance variable is shared between all
+  # `render` calls since rendering happens in one `ActionView::Base` instance.
+  def capture_with_outer_partial_access(*arguments, &block)
+    __partials.locate_previous
+    __partials.first.capture(*arguments, &block)
+  ensure
+    __partials.reset_locator
+  end
+end
 
-    result = original_render(partial, context, block)
+module NicePartials::PartialRendering
+  ActionView::PartialRenderer.prepend self
+
+  # Automatically captures the `block` in case the partial has no manual capturing `yield` call.
+  #
+  # This manual equivalent would be inserting this:
+  #
+  #   <% yield partial %>
+  def render_partial_template(view, locals, template, layout, block)
+    view.capture_with_outer_partial_access(&block) if block && !template.has_capturing_yield?
+    super
+  end
+end
 
-    # Whether there was a block or not, pop off whatever we put on the stack.
-    context.nice_partials_pop_t_prefix
+module NicePartials::CapturingYieldDetection
+  ActionView::Template.include self
 
-    return result
+  # Matches yields that'll end up calling `capture`:
+  #   <%= yield %>
+  #   <%= yield something_else %>
+  #
+  # Doesn't match obfuscated `content_for` invocations, nor custom yields:
+  #   <%= yield :message %>
+  #   <%= something.yield %>
+  #
+  # 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[\(? ]+(%>|[^:])/)
   end
 end

data/lib/nice_partials/partial/section.rb

@@ -0,0 +1,43 @@
+class NicePartials::Partial::Section
+  def initialize(view_context)
+    @view_context = view_context
+    @content = @pending_content = nil
+  end
+
+  def content_for(*arguments, &block)
+    if write_content_for(arguments.first, &block)
+      nil
+    else
+      capture_content_for(*arguments) if pending?
+      @content
+    end
+  end
+
+  def content?
+    pending? || @content
+  end
+
+  private
+
+  def write_content_for(content = nil, &block)
+    if content && !pending?
+      concat content
+    else
+      @pending_content = block if block
+    end
+  end
+
+  def capture_content_for(*arguments)
+    concat @view_context.capture(*arguments, &@pending_content)
+    @pending_content = nil
+  end
+
+  def concat(string)
+    @content ||= ActiveSupport::SafeBuffer.new
+    @content << string.to_s if string.present?
+  end
+
+  def pending?
+    @pending_content
+  end
+end

data/lib/nice_partials/partial/stack.rb

@@ -0,0 +1,19 @@
+class NicePartials::Partial::Stack
+  def initialize
+    @partials = []
+    reset_locator
+  end
+  delegate :prepend, :shift, :first, to: :@partials
+
+  def partial
+    @partials.public_send @locator
+  end
+
+  def locate_previous
+    @locator = :second
+  end
+
+  def reset_locator
+    @locator = :first
+  end
+end

data/lib/nice_partials/partial.rb

@@ -1,39 +1,57 @@
 module NicePartials
   class Partial
+    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
-      @key = SecureRandom.uuid
+      @contents = Hash.new { |h, k| h[k] = Section.new(@view_context) }
     end
 
-    def yield(name = nil)
-      raise "You can only use Nice Partial's yield method to retrieve the content of named content area blocks. If you're not trying to fetch the content of a named content area block, you don't need Nice Partials! You can just call the vanilla Rails `yield`." unless name
-      content_for(name)
+    def yield(*arguments, &block)
+      if arguments.empty?
+        output_buffer
+      else
+        content_for(*arguments, &block)
+      end
     end
 
     def helpers(&block)
       class_eval &block
     end
 
-    # See the `ActionView::PartialRenderer` monkey patch in `lib/nice_partials/monkey_patch.rb` for something similar.
-    def content_for(name, content = nil, options = {}, &block)
-      if block_given?
-        partial_prefix = nice_partials_locale_prefix_from_view_context_and_block(@view_context, block)
-        @view_context.nice_partials_push_t_prefix(partial_prefix)
-      end
-
-      result = @view_context.content_for("#{name}_#{@key}".to_sym, content, options, &block)
-
-      if block_given?
-        @view_context.nice_partials_pop_t_prefix
-      end
-
-      return result
+    # 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 %>
+    #
+    #  # …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)
     end
 
     def content_for?(name)
-      @view_context.content_for?("#{name}_#{@key}".to_sym)
+      @contents[name].content?
+    end
+
+    def capture(*arguments, &block)
+      self.output_buffer = @view_context.capture(*arguments, self, &block)
     end
   end
 end

data/lib/nice_partials/version.rb

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

data/lib/nice_partials.rb

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "nice_partials/version"
-require_relative "nice_partials/helper"
-require_relative "nice_partials/monkey_patch"
-require_relative "partials"
 
 module NicePartials
-end
-
-# TODO Is there somewhere better we can put this?
-def nice_partials_locale_prefix_from_view_context_and_block(context, block)
-  root_paths = context.view_renderer.lookup_context.view_paths.map(&:path)
-  partial_location = block.source_location.first.dup
-  root_paths.each { |path| partial_location.gsub!(/^#{path}\//, '') }
-  partial_location.split('.').first.gsub('/_', '/').gsub('/', '.')
+  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}\//, '') }
+    partial_location.split('.').first.gsub('/_', '/').gsub('/', '.')
+  end
 end
 
 ActiveSupport.on_load :action_view do
+  require_relative "nice_partials/monkey_patch"
+
+  require_relative "nice_partials/helper"
   include NicePartials::Helper
 end

data/nice_partials.gemspec

@@ -20,4 +20,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = ">= 2.0"
 
   gem.add_dependency "actionview", '>= 4.2.6'
+
+  gem.add_development_dependency "rails"
+  gem.add_development_dependency "standard"
 end

data/test/fixtures/_basic.html.erb

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

data/test/fixtures/_card.html.erb

@@ -0,0 +1,11 @@
+<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

@@ -0,0 +1,3 @@
+<% 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

@@ -0,0 +1,11 @@
+<% 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

@@ -0,0 +1,9 @@
+<%= 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

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

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

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

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

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

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

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

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

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

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

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

data/test/renderer/translation_test.rb

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,17 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nice_partials
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.9
 platform: ruby
 authors:
 - Andrew Culver
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-05 00:00:00.000000000 Z
+date: 2022-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview
@@ -25,6 +25,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A little bit of magic to make partials perfect for components.
 email:
 - andrew.culver@gmail.com
@@ -45,10 +73,25 @@ files:
 - lib/nice_partials/helper.rb
 - lib/nice_partials/monkey_patch.rb
 - lib/nice_partials/partial.rb
+- lib/nice_partials/partial/section.rb
+- lib/nice_partials/partial/stack.rb
 - lib/nice_partials/version.rb
-- lib/partials.rb
+- nice_partials-0.1.8.gem
 - nice_partials.gemspec
-- spec/nice_partials_spec.rb
+- 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
@@ -68,9 +111,22 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A little bit of magic to make partials perfect for components.
 test_files:
-- spec/nice_partials_spec.rb
+- 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

data/lib/partials.rb

@@ -1,2 +0,0 @@
-module Partials
-end

data/spec/nice_partials_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../lib/nice_partials"
-require "minitest/autorun"
-
-describe NicePartials do
-  it "works" do
-    assert_equal true, false
-  end
-end
-