Relative translation keys inside blocks resolve to partial’s scope instead of caller’s scope

[AckermannTM]

When using the t helper method inside a block passed to a partial, Rails resolves relative translation keys using the partial's path instead of the caller's path. This results in translations being looked up from the partial’s scope instead of the scope of the file where the block is defined.

Steps to reproduce

# test_component.html.erb
<%= render "shared/partial" do %>
  <%= t(".title") %>
<% end %>

Expected behavior

The translation key should resolve to:
en.test_component.title

Actual behavior

The translation key instead resolves to:
en.shared.partial.title

System configuration

Rails version:
8.0.2
Ruby version:
3.4.4
Gem version:
4.0.0

Note: This works correctly in version 3.23.2 but breaks in 4.0.0.

This is my first bug report. I’m happy to provide more details if needed.

[joelhawksley]

@AckermannTM thanks for the bug report! We fixed a similar issue in #2389.

Could I interest you in writing a PR with a failing test for this issue? Once we can agree on the reproduction of the issue it will be easier to figure out a solution.

[AckermannTM]

No problem and sorry for the late response!

I'll look into it if I have some time to write a PR with a failing test.

Maybe tomorrow or over the weekend.

[TorgilZ]

We've run into a similar issue, but in a different setup involving nested components. When passing a block to deeply nested components, lazy translation keys (t('.key')) resolve with the wrong scope. This used to work in version 3.x.

In our case, we have an outer component with nested sections, which in turn contain groups:

class OuterComponent < ViewComponent::Base
  renders_many :sections, 'SectionComponent'

  erb_template <<-ERB
    <% sections.each do |section| %>
      <%= section %>
    <% end %>
  ERB

  class SectionComponent < ViewComponent::Base
    renders_many :groups, 'GroupComponent'

    erb_template <<-ERB
      <% groups.each do |group| %>
        <%= group %>
      <% end %>
    ERB

    class GroupComponent < ViewComponent::Base
      def call
        content
      end
    end
  end
end

Used like this in a view:

<%# views/things/index.html.erb %>
<%= render(OuterComponent.new) do |outer| %>
  <% outer.with_section do |section| %>
    <% section.with_group do %>
      <%= t('.lazy') %> <%# Resolves to outer_component.lazy instead of things.index.lazy %>
    <% end %>
  <% end %>
<% end %>

The problem is that the innermost block gets evaluated in the context of the component class, not the template where it's defined, causing t('.lazy') to incorrectly scope to outer_component.lazy rather than things.index.lazy.

As a workaround, we include the following module in OuterComponent:

module NoLocalI18nScope
  def virtual_path
    @old_virtual_path || super
  end
end

This prevents the component from injecting its own virtual_path, allowing the translation lookup to retain the outer (view) scope instead. But it's more of a hack than a proper fix 🙂.

[AckermannTM]

I've created a failing PR related to this issue: #2432

I hope this helps you solve the problem. Thank you in advance!