nice_partials 0.1.6 → 0.9.0

data/lib/nice_partials/helper.rb

@@ -1,25 +1,12 @@
 require_relative "partial"
 
 module NicePartials::Helper
-  def np
-    NicePartials::Partial.new(self)
-  end
-
-  def nice_partials_push_t_prefix(prefix)
-    @_nice_partials_t_prefixes ||= []
-    @_nice_partials_t_prefixes << prefix
+  def nice_partial_with(local_assigns)
+    NicePartials::Partial.new(self, local_assigns)
   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)
+  def nice_partial
+    NicePartials::Partial.new(self)
   end
+  alias_method :np, :nice_partial
 end

data/lib/nice_partials/monkey_patch.rb

@@ -1,59 +1,121 @@
 # 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
-    else
-      # Render partial calls with no block should disable any prefix magic.
-      context.nice_partials_push_t_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
 
-    begin
-      result = original_render(partial, context, block)
-    rescue Exception => exception
-      # If there was some sort of exception thrown, we also need to pop the `t` prefix.
-      # This provides compatibility with other libraries that depend on catching exceptions from the view renderer.
-      context.nice_partials_pop_t_prefix
-      raise exception
+    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
 
-    # Whether there was a block or not, pop off whatever we put on the stack.
-    context.nice_partials_pop_t_prefix
+  # 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(options = {}, locals = {}, &block)
+    partial_locals = options.is_a?(Hash) ? options[:locals] : locals
+    __partials.prepend nice_partial_with(partial_locals)
+    super
+  ensure
+    __partials.shift
+  end
 
-    return result
+  # 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
+      super
+    end
   end
 
-  # This and ActionView::Template#render below are for compatibility
-  # with Ruby 3, as opposed to altering the original functionality.
+  # 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
+
+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)
-    ActiveSupport::Notifications.instrument(
-      "render_partial.action_view",
-      identifier: template.identifier,
-      layout: layout && layout.virtual_path
-    ) do |payload|
-      content = template.render(view, locals, ActionView::OutputBuffer.new, {add_to_stack: !block}) do |*name|
-        view._layout_for(*name, &block)
-      end
-
-      content = layout.render(view, locals) { content } if layout
-      payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
-      build_rendered_template(content, template)
-    end
+    view.capture_with_outer_partial_access(&block) if block && !template.has_capturing_yield?
+    super
   end
 end
 
-class ActionView::Template
-  def render(view, locals, buffer = ActionView::OutputBuffer.new, flag = {add_to_stack: true}, &block)
-    instrument_render_template do
-      compile!(view)
-      view._run(method_name, self, locals, buffer, **flag, &block)
-    end
-  rescue => e
-    handle_render_error(view, e)
+module NicePartials::CapturingYieldDetection
+  ActionView::Template.include self
+
+  # 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?(/[^\.\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

@@ -0,0 +1,48 @@
+class NicePartials::Partial::Section < NicePartials::Partial::Content
+  def yield(*arguments)
+    chunks.each { append @view_context.capture(*arguments, &_1) }
+    self
+  end
+
+  def present?
+    chunks.present? || super
+  end
+
+  undef_method :p # Remove Kernel.p here to pipe through method_missing and hit tag proxy.
+
+  # 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
+      @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?(...)
+
+  private
+
+  def capture(block)
+    if block&.arity&.nonzero?
+      chunks << block
+    else
+      super
+    end
+  end
+
+  def chunks() = @chunks ||= []
+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,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
 
-    def initialize(view_context)
-      @view_context = view_context
-      @key = SecureRandom.uuid
+    def initialize(view_context, local_assigns = nil)
+      @view_context, @local_assigns = view_context, local_assigns
     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?
+        @captured_buffer
+      else
+        content_for(*arguments, &block)
+      end
     end
 
     def helpers(&block)
-      class_eval &block
+      self.class.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)
+    # `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
 
-      result = @view_context.content_for("#{name}_#{@key}".to_sym, content, options, &block)
+    # 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
 
-      if block_given?
-        @view_context.nice_partials_pop_t_prefix
-      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.title { |tag| tag.h1 } %>
+    #
+    #  # …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(...)
+      section(...)&.to_s
+    end
+
+    def slice(*keys)
+      keys.index_with { content_for _1 }
+    end
+
+    def capture(*arguments, &block)
+      @captured_buffer = @view_context.capture(*arguments, self, &block)
+    end
 
-      return result
+    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 content_for?(name)
-      @view_context.content_for?("#{name}_#{@key}".to_sym)
+    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.6"
+  VERSION = "0.9.0"
 end

data/lib/nice_partials.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
 require_relative "nice_partials/version"
-require_relative "nice_partials/helper"
-require_relative "nice_partials/monkey_patch"
 
 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)
+    partial_location = block.source_location.first.dup
+    lookup_context.view_paths.each { partial_location.delete_prefix!(_1.path)&.delete_prefix!("/") }
+    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

@@ -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"
@@ -22,4 +28,5 @@ Gem::Specification.new do |gem|
   gem.add_dependency "actionview", '>= 4.2.6'
 
   gem.add_development_dependency "rails"
+  gem.add_development_dependency "standard"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: nice_partials
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.9.0
 platform: ruby
 authors:
 - Andrew Culver
 - Dom Christie
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2023-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview
@@ -39,6 +39,20 @@ dependencies:
     - - ">="
       - !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
@@ -47,8 +61,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -59,13 +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.gemspec
-- test/fixtures/_basic.html.erb
-- test/fixtures/_card.html.erb
-- test/fixtures/card_test.html.erb
-- test/renderer_test.rb
-- test/test_helper.rb
 homepage: https://github.com/bullet-train-co/nice_partials
 licenses:
 - MIT
@@ -85,13 +95,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+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/card_test.html.erb
-- test/renderer_test.rb
-- test/test_helper.rb
+test_files: []

data/.gitignore

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

data/.travis.yml

@@ -1,18 +0,0 @@
-sudo: false
-language: ruby
-
-rvm:
-- 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,2 +0,0 @@
-<% yield p = np %>
-<%= p.yield :message %>

data/test/fixtures/_card.html.erb

@@ -1,13 +0,0 @@
-<% yield p = np %>
-
-<div class="card">
-  <%= p.yield :image %>
-  <div class="card-body">
-    <h5 class="card-title"><%= title %></h5>
-    <% if p.content_for? :body %>
-      <p class="card-text">
-        <%= p.content_for :body %>
-      </p>
-    <% end %>
-  </div>
-</div>

data/test/fixtures/card_test.html.erb

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