lexxy-variables 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20e1253a50b9ac063ff88624785d48c6103842a46c07256ab867db405497f38a
-  data.tar.gz: 6c9097c35bd39c7a81b204de9f68599c56be4fcd319ec660cbcfb5aaa4432f85
+  metadata.gz: a109be7d8f0e268e60ce7fbaa71cf752d492f6d08f04300b52418016a54c7fdf
+  data.tar.gz: a84a11352b3b3d9701719e66428574c8693e05e36a8fff2f3d140022076ee930
 SHA512:
-  metadata.gz: c6d6291c6770026b75e2b167262f39d3419fdcb23ba255969391f3a96adce42abb2c3a2f7e73cd775855832483fc7158ab9dd655b481caf80042791262638931
-  data.tar.gz: 343e6f7cc524a95b4c5aca8a0230d091acf16a3ef7147cc2324172fc545ca3bc1db91bae1907ef344b6d06fd255874c741b770393d609ee7c4a3124c0f59dbf9
+  metadata.gz: 2ccc7224904bf969b37d41449bbd8efd42654a345483242ca3dc898e278a2de8c641735db757815d7ba79482b9c85f670e43d14d1c64e5493539bd7b8ff8617c
+  data.tar.gz: 74066919264113eb0370da5d0e740a05cecfb5ffd6036fedf0e448115e8dbaa4b856dfdc2a5ca7b1cbeaaf270bf5d7c1c74bb49df4d768aba55bebb23b332d05

data/README.md

@@ -9,9 +9,9 @@ an `<action-text-attachment>` chip with its own content type, not as literal
 You decide what variables exist and what they turn into.
 
 Because variables are just Action Text attachments, you can register new
-chip types with `register_attachment` (see [Full configuration](#full-configuration)):
-a chip that renders as `:text` resolves to an escaped string, one that renders
-as `:html` splices rich content in before sanitization.
+chip types with `register_attachment` (see [Full configuration](#full-configuration)).
+A `:text` chip resolves to an escaped string. An `:html` chip splices rich
+content in before sanitization.
 
 Liquid is **optional**. The default renderer is plain, injection-safe string
 substitution and pulls in no template engine.
@@ -82,9 +82,6 @@ LexxyVariables.configure do |c|
 end
 ```
 
-The gem adds two view helpers, one for each side of the workflow: one to author
-content and one to display it.
-
 On the **editor page** (the form where content is composed), render the prompt
 *inside* the Lexxy editor. The editor extension looks for the `<lexxy-prompt>`
 within the `<lexxy-editor>` element, so it must be nested in the `rich_text_area`
@@ -107,10 +104,11 @@ for picking from the same list. Inserted variables appear as chips in the editor
 </p>
 
 On the **display page** (where the saved content is shown to readers), resolve
-the stored rich text. This is what swaps each variable chip for its value:
+the stored rich text with `with_variables`. This is what swaps each variable
+chip for its value:
 
 ```erb
-<%= render_variable_content(@record.body) %>
+<%= @record.body.with_variables %>
 ```
 
 Each chip resolves to its value, so the reader sees finished text:
@@ -152,16 +150,20 @@ Editor page:
 Display page:
 
 ```erb
-<%= render_variable_content(@message.body,
+<%= @message.body.with_variables(
       first_name: @user.first_name,
       last_name:  @user.last_name) %>
 ```
 
-The catalog entries have no `value` because it's supplied at render time, so the same saved content renders differently per user. The default renderer escapes the values automatically. When a variable name would collide with `context:` or `locale:`, use an `assigns:` hash instead (see [Helper options](#helper-options)).
+The catalog entries have no `value` because it's supplied at render time, so the same saved content renders differently per user. Values are escaped for HTML automatically. When a variable name would collide with `context:` or `locale:`, use an `assigns:` hash instead:
+
+```erb
+<%= @message.body.with_variables(assigns: { locale: @user.locale }) %>
+```
 
 ### Static values from config
 
-When a value is the same for everyone, it can live on the catalog item itself. With no `assigns` set, the gem reads `value` off the catalog and the helper takes no extra arguments:
+When a value is the same for everyone, it can live on the catalog item itself. With no `assigns` set, the gem reads `value` off the catalog and `with_variables` takes no arguments:
 
 ```ruby
 LexxyVariables.configure do |c|
@@ -170,27 +172,25 @@ end
 ```
 
 ```erb
-<%= render_variable_content(@message.body) %>
+<%= @message.body.with_variables %>
 ```
 
 ### Liquid drops and dotted access
 
-Liquid enables dotted access like `{{ user.first_name }}`, filters, and drops that expose a whole object. A drop is a small class that defines which methods Liquid can call, and escapes what it returns:
+Liquid enables dotted access like `{{ user.first_name }}`, filters, and drops that expose a whole object. A drop is a small class that defines which methods Liquid can call:
 
 ```ruby
 # app/drops/user_drop.rb
-# Liquid output is emitted html_safe after sanitization,
-# so a drop must escape its own values.
 class UserDrop < Liquid::Drop
   def initialize(user) = @user = user
 
-  def first_name = ERB::Util.html_escape(@user.first_name).to_s
-  def full_name  = ERB::Util.html_escape(@user.full_name).to_s
-  def email      = ERB::Util.html_escape(@user.email).to_s
+  def first_name = @user.first_name
+  def full_name  = @user.full_name
+  def email      = @user.email
 end
 ```
 
-The dotted keys go in the catalog so they can be inserted, the Liquid renderer is switched on, and `assigns` returns the drop under the name the keys use (`user`):
+The dotted keys go in the catalog, the Liquid renderer is used, and `assigns` returns the drop under the name the keys use (`user`):
 
 ```ruby
 LexxyVariables.configure do |c|
@@ -207,10 +207,54 @@ end
 ```
 
 ```erb
-<%= render_variable_content(@message.body) %>
+<%= @message.body.with_variables %>
+```
+
+A `user.first_name` chip becomes `{{ user.first_name }}`, which Liquid runs through the drop. Liquid can only call the methods the drop defines. Return raw values and let the gem handle the escaping.
+
+## Plain text and Markdown
+
+`with_variables` returns a plain `ActionText::Content` with every chip
+resolved, so Action Text's own conversions chain from it:
+
+```ruby
+@message.body.with_variables(first_name: @user.first_name).to_plain_text
+# => "Hi Ada, welcome aboard!"
+
+@message.body.with_variables(first_name: "Ada").to_markdown # Rails 8.2+
+```
+
+Each format handles its own escaping. Values come out raw in `to_plain_text`
+and `to_markdown`, and escaped in HTML. No view is required, so it works in
+mailers (the text part of an email), background jobs, and exports:
+
+```ruby
+mail.text_part = @message.body.with_variables(assigns).to_plain_text
 ```
 
-A `user.first_name` chip becomes `{{ user.first_name }}`, which Liquid runs through the drop. Only the methods defined on the drop are reachable, not arbitrary attributes on the user. Liquid doesn't escape output the way the default renderer does, so the drop escapes its own values. The same goes for any plain string returned from `assigns` or passed inline.
+Rendering works the same as on any rich text body. During a request Rails
+renders it with the current controller, so helpers and URLs resolve as usual.
+Outside a request it uses Rails' offline renderer.
+
+## Locales
+
+`with_variables` takes a `locale:`. Resolution runs inside `I18n.with_locale`,
+so anything that calls `I18n.t` along the way (assigns, resolvers, drops) sees
+that locale. Leave it off to use the current locale. The previous locale is
+restored afterward.
+
+```ruby
+@message.body.with_variables(locale: recipient.locale).to_plain_text
+```
+
+`with_variables` resolves right away, but the conversion you chain on it runs
+later under whatever locale is current then. If the content has attachments
+with translated partials, wrap the conversion too:
+
+```ruby
+resolved = @message.body.with_variables(locale: :fr)
+I18n.with_locale(:fr) { resolved.to_s }
+```
 
 ## Full configuration
 
@@ -218,7 +262,7 @@ A `user.first_name` chip becomes `{{ user.first_name }}`, which Liquid runs thro
 
 ```ruby
 LexxyVariables.configure do |c|
-  # What users can insert: the {{ prompt and the toolbar dropdown read this.
+  # What users can insert. The {{ prompt and the toolbar dropdown read this.
   c.catalog = ->(context) { context.variables + BuiltinVariable.all }
 
   # What each used key resolves to at render time.
@@ -227,7 +271,7 @@ LexxyVariables.configure do |c|
   # Opt into Liquid for dotted access, drops, and filters.
   c.renderer = LexxyVariables::Renderers::Liquid.new
 
-  # A second chip type: snippets expand to rich HTML instead of an escaped value.
+  # A second chip type. Snippets expand to rich HTML instead of an escaped value.
   c.register_attachment(
     content_type: "application/vnd.actiontext.snippet",
     renders_as: :html,
@@ -242,42 +286,21 @@ end
 | Option | Default | What it does |
 | --- | --- | --- |
 | `catalog` | `[]` | The insertable items shown in the `{{` prompt and the toolbar dropdown. A list, a zero-arg lambda, or a `->(context)` lambda. Items respond to `#key` and `#name`, and optionally `#value` and `#attachable_sgid`. |
-| `assigns` | reads `#value` off catalog items | The render-time lookup. A `->(context, used_keys)` or `->(used_keys)` lambda that receives only the keys used in the content being rendered and returns a `{ key => value }` hash. Per-render values can also be passed straight to `render_variable_content` (see [Helper options](#helper-options)). |
-| `renderer` | `Renderers::Substitution.new` | How placeholders become values. The default is plain, escaped string substitution with no template engine. Swap in `Renderers::Liquid.new` for dotted access, drops, and filters. |
+| `assigns` | reads `#value` off catalog items | The render-time lookup. A `->(context, used_keys)` or `->(used_keys)` lambda that receives only the keys used in the content being rendered and returns a `{ key => value }` hash. Per-render values can also be passed straight to `with_variables` (see [Examples](#examples)). |
+| `renderer` | `Renderers::Substitution.new` | How a chip's key becomes a value. The default is a plain hash lookup with no template engine. Swap in `Renderers::Liquid.new` for dotted access, drops, and filters. |
 | `sort` | `:name` | How the catalog is ordered in the prompt and dropdown. `:name` (case-insensitive alphabetical), `:key`, `false` to keep the catalog's given order, or a lambda (a `->(item)` sort key or a `->(a, b)` comparator). |
 | `max_fragment_depth` | `1` | How many levels of `renders_as: :html` chips expand. The default resolves the variables inside a snippet but drops a snippet nested inside another snippet. Raise it to allow deeper nesting. |
-| `content_layout` | `"layouts/action_text/contents/content"` | The Action Text layout that wraps rendered output. Point it at your own partial to change the wrapper, for example when rendering into emails. |
-| `register_attachment(content_type:, resolve:, renders_as:, label:)` | variable type pre-registered | Adds or replaces a chip type. `renders_as:` is `:text` (default, the resolver returns a key whose escaped value is substituted in) or `:html` (splices rich HTML in pre-sanitize, resolving inner `:text` chips in the same pass, bounded by `max_fragment_depth`). `label:` is the badge shown in the prompt when the list mixes types. Re-registering a content type (including the built-in variable type) replaces it, which is how you'd swap in a custom variable resolver. |
+| `register_attachment(content_type:, resolve:, renders_as:, label:)` | variable type pre-registered | Adds or replaces a chip type. `renders_as:` is `:text` (default, the resolver returns a key whose value is substituted in as inert text) or `:html` (splices rich HTML in pre-sanitize, resolving inner `:text` chips in the same pass, bounded by `max_fragment_depth`). `label:` is the badge shown in the prompt when the list mixes types. Re-registering a content type (including the built-in variable type) replaces it, which is how you'd swap in a custom variable resolver. |
 
-### Helper options
+### Prompt options
 
-Both view helpers take `context:` (see [Multi-tenancy](#multi-tenancy)). Beyond
-that, `lexxy_variables_prompt` lets you change the trigger characters and the
-empty state, and `render_variable_content` can render under a specific locale by
-wrapping the whole pass in `I18n.with_locale`.
+`lexxy_variables_prompt` takes `context:` (see [Multi-tenancy](#multi-tenancy))
+and lets you change the trigger characters and the empty state:
 
 ```erb
 <%= lexxy_variables_prompt(trigger: "%%", empty_results: t(".no_variables")) %>
-
-<%= render_variable_content(@record.body, locale: recipient.locale) %>
 ```
 
-You can also pass a variable's value straight to `render_variable_content`, as
-keyword arguments or an `assigns:` hash. These win over whatever the configured
-`assigns` returns, and a value for a key that isn't used in the content is just
-ignored:
-
-```erb
-<%# keyword arguments %>
-<%= render_variable_content(@record.body, first_name: @user.first_name) %>
-
-<%# same thing, for a name that would clash with context: or locale: %>
-<%= render_variable_content(@record.body, assigns: { first_name: @user.first_name }) %>
-```
-
-The default renderer escapes these values for you. Liquid doesn't, so escape
-them yourself or pass a drop.
-
 ## Multi-tenancy
 
 Tenancy is optional. If your app is multi-tenant, pass the tenant through as
@@ -290,7 +313,7 @@ LexxyVariables.configure do |c|
 end
 ```
 
-Both view helpers take the same `context:`. Pass the tenant on the editor page:
+Pass the tenant on the editor page:
 
 ```erb
 <%= form.rich_text_area :body do %>
@@ -301,7 +324,7 @@ Both view helpers take the same `context:`. Pass the tenant on the editor page:
 and again on the display page:
 
 ```erb
-<%= render_variable_content(@record.body, context: ActsAsTenant.current_tenant) %>
+<%= @record.body.with_variables(context: ActsAsTenant.current_tenant) %>
 ```
 
 Or skip `context` entirely and rely on acts_as_tenant scoping queries to the
@@ -369,14 +392,16 @@ popup and the dropdown:
 
 ## Security model
 
-- Every render gets a fresh random nonce that guards the placeholder tokens, so an
-  author can't fake a substitution by typing the token pattern into the body.
-- Chips are swapped for those nonce tokens before the HTML is sanitized, and the
-  real values go in afterward. A `:text` chip resolves to HTML-escaped text that
-  can't do anything, while an `:html` chip is spliced in before sanitizing so the
-  sanitizer still scrubs it.
-- Only the Liquid renderer deals with template-engine braces (`{{ }}` and `{% %}`).
-  The default renderer runs no engine at all, so there's nothing there to inject into.
+- Every resolution gets a fresh random nonce that guards the placeholder tokens,
+  so an author can't fake a substitution by typing the token pattern into the body.
+- Resolved values are injected as DOM text nodes, never parsed as markup. HTML
+  output escapes them at serialization and still runs the sanitizer at render
+  time, so a value can't reintroduce markup. Plain-text and Markdown output read
+  them raw. An `:html` chip is spliced in before that render-time sanitization,
+  so the sanitizer still scrubs it.
+- Only the Liquid renderer runs a template engine, and it only ever parses chip
+  keys, never body text, so `{{ }}` or `{% %}` an author types stays literal. The
+  default renderer runs no engine at all, so there's nothing there to inject into.
 
 ## Contributing
 

data/lib/lexxy_variables/configuration.rb

@@ -14,20 +14,18 @@ module LexxyVariables
   # renderer: Renderers::Substitution (default, no Liquid) or Renderers::Liquid.
   # max_fragment_depth: how deep :html chips (e.g. snippets) expand. The
   #   default of 1 resolves a snippet's inner variables and drops nested snippets.
-  # content_layout: the ActionText content layout wrapper for rendered output.
   # sort: how the catalog is ordered in the prompt and dropdown. Defaults to
   #   :name (case-insensitive alphabetical). Use :key to sort by key, false to
   #   preserve the catalog's given order, or a callable: a ->(item) sort key, or
   #   a ->(a, b) comparator.
   class Configuration
-    attr_accessor :assigns, :renderer, :content_layout, :max_fragment_depth, :sort
+    attr_accessor :assigns, :renderer, :max_fragment_depth, :sort
     attr_reader :registry
     attr_writer :catalog
 
     def initialize
       @registry = Registry.new
       @renderer = Renderers::Substitution.new
-      @content_layout = "layouts/action_text/contents/content"
       @max_fragment_depth = 1
       @catalog = []
       @sort = :name

data/lib/lexxy_variables/helper.rb

@@ -1,22 +1,9 @@
 module LexxyVariables
-  # Mixed into Action View by the engine. `context` is opaque to the gem and is
-  # passed straight through to the host's catalog/assigns/resolve callables.
+  # Editor-side view helpers. LexxyVariables::Engine includes this module into
+  # Action View when the host app boots, so lexxy_variables_prompt and
+  # lexxy_variable_chip are callable from any view with no setup. `context` is
+  # opaque to the gem and is passed straight through to the host's catalog.
   module Helper
-    # `assigns:` (and any extra keyword args) are per-render values merged on top
-    # of the configured `assigns`, so a caller can supply a key's value inline:
-    #
-    #   render_variable_content(@record.body, first_name: @user.first_name)
-    #
-    # Inline values win over the configured assigns. Keys not used by any chip in
-    # the body are ignored. Under the default renderer inline values are
-    # HTML-escaped; under Liquid they are emitted as-is, so pre-escape them or
-    # pass a drop.
-    def render_variable_content(rich_text, context: nil, locale: I18n.locale, assigns: {}, **inline_assigns)
-      LexxyVariables::Pipeline.new(self).call(
-        rich_text, context: context, locale: locale, assigns: assigns.merge(inline_assigns)
-      )
-    end
-
     # Renders the <lexxy-prompt> the editor extension reads, built from the
     # configured catalog. `context` is passed to the catalog callable.
     def lexxy_variables_prompt(context: nil, trigger: "{{", empty_results: "No variables found")

data/lib/lexxy_variables/renderers/liquid.rb

@@ -1,29 +1,25 @@
 module LexxyVariables
   module Renderers
-    # Opt-in renderer that resolves placeholders through Liquid, enabling dotted
+    # Opt-in renderer that resolves each key through Liquid, enabling dotted
     # access, drops (e.g. {{ company.name }}), and filters. Requires the `liquid`
     # gem. It is loaded here, when a host instantiates this renderer, so apps on
     # the default renderer never pull it in.
     #
-    # Security: because Liquid does interpret {{ }} and {% %}, any such syntax the
-    # author typed as plain text is entity-escaped BEFORE our own placeholders are
-    # revealed, so users cannot forge Liquid. Only the nonce-protected placeholders
-    # this pipeline emitted become real Liquid tags.
+    # Security: only the chip's key is parsed as a Liquid template, never body
+    # text, so {{ }} or {% %} an author types stays literal. The resolved value
+    # is injected as a DOM text node and escaped per output format by the
+    # resolver, so drops must NOT pre-escape their values.
     #
     # `assigns` is the Hash passed to Liquid: string values and/or Liquid::Drop
-    # instances. Drops must escape their own output, since Liquid output is emitted
-    # html_safe after sanitization.
+    # instances.
     class Liquid
       def initialize(error_mode: :lax)
         require "liquid"
         @error_mode = error_mode
       end
 
-      def render(html, nonce:, assigns:)
-        html = html.gsub("{{", "{{").gsub("{%", "{%")
-        html = html.gsub(Placeholder.pattern(nonce)) { "{{ #{$1} }}" }
-
-        ::Liquid::Template.parse(html, error_mode: @error_mode).render(assigns)
+      def resolve_value(key, assigns)
+        ::Liquid::Template.parse("{{ #{key} }}", error_mode: @error_mode).render(assigns)
       end
     end
   end

data/lib/lexxy_variables/renderers/substitution.rb

@@ -1,14 +1,12 @@
 module LexxyVariables
   module Renderers
-    # Default renderer. Replaces nonce placeholders with resolved values by plain
-    # string substitution. There is no template engine, so author-typed text can
-    # never be interpreted as code. Each value is HTML-escaped, so it is inert and
-    # cannot reintroduce markup the sanitizer already stripped.
-    #
-    # `assigns` is a Hash of key => value. Values are coerced to escaped strings.
+    # Default renderer. Looks each key up in the assigns hash, no template
+    # engine, so author-typed text can never be interpreted as code. The value
+    # is returned raw: the resolver injects it as a DOM text node, where HTML
+    # serialization escapes it and plain-text/markdown conversions read it as-is.
     class Substitution
-      def render(html, nonce:, assigns:)
-        html.gsub(Placeholder.pattern(nonce)) { ERB::Util.html_escape(assigns[$1].to_s) }
+      def resolve_value(key, assigns)
+        assigns[key].to_s
       end
     end
   end

data/lib/lexxy_variables/{pipeline.rb → resolver.rb}

@@ -1,42 +1,35 @@
 module LexxyVariables
-  # Turns stored rich text into rendered HTML with attachment chips resolved.
+  # Resolves the attachment chips in stored rich text, returning a new
+  # ActionText::Content with every chip replaced by its value. The result is a
+  # plain content object, so Action Text's own conversions chain from it:
+  # #to_s (sanitized HTML), #to_plain_text, #to_markdown, #to_html.
   #
   # Security invariants (do not weaken):
   #   1. A random per-render nonce guards placeholder tokens, so an author cannot
   #      forge a substitution by typing the token pattern into the body.
-  #   2. Attachments are swapped for nonce tokens BEFORE sanitization and resolved
-  #      values are injected AFTER. :text output is HTML-escaped and therefore
-  #      inert. :html output is spliced pre-sanitize so the sanitizer cleans it.
-  #   3. Any template-engine escaping (Liquid braces) lives only in that renderer.
+  #   2. Resolved values are injected as DOM text nodes, never parsed as markup.
+  #      HTML serialization escapes them, and the sanitizer still runs when the
+  #      content is rendered. :html output is spliced as markup here, before that
+  #      render-time sanitization, so the sanitizer cleans it too.
+  #   3. Any template-engine parsing (Liquid) sees only chip keys, never body text.
   #
-  # Needs a view context (self, from the helper) for Action Text rendering.
-  # Build a fresh Pipeline per render, as the helper does. #call stores
-  # per-render state on the instance.
-  class Pipeline
-    def initialize(view, config = LexxyVariables.config)
-      @view = view
+  # Build a fresh Resolver per call. #call stores per-render state on the instance.
+  class Resolver
+    def initialize(config = LexxyVariables.config)
       @config = config
     end
 
-    def call(rich_text, context: nil, locale: I18n.locale, assigns: {})
-      body = rich_text&.body
-      return "".html_safe if body.blank?
-
+    def call(content, context: nil, locale: nil, assigns: {})
       @context = context
       @nonce = SecureRandom.hex(8)
       @used_keys = []
 
       I18n.with_locale(locale || I18n.locale) do
-        fragment = substitute(body.fragment, 0)
-        html = @view.render_action_text_content(
-          ActionText::Content.new(fragment.to_html, canonicalize: false)
-        )
-
+        fragment = substitute(content.fragment, 0)
         resolved = @config.resolve_assigns(@context, @used_keys.uniq)
         resolved = resolved.merge(assigns.transform_keys(&:to_s)) if assigns.any?
-        rendered = @config.renderer.render(html, nonce: @nonce, assigns: resolved)
-
-        @view.render(layout: @config.content_layout) { rendered.html_safe }
+        inject_values(fragment, resolved)
+        ActionText::Content.new(fragment, canonicalize: false)
       end
     end
 
@@ -74,6 +67,19 @@ module LexxyVariables
       substitute(inner, depth + 1)
     end
 
+    # Swaps each nonce-guarded token for its value, staying at the text-node
+    # level so values serialize as escaped text and read back raw in plain-text
+    # and markdown conversions. #substitute returned a fresh fragment, so
+    # mutating it in place is safe.
+    def inject_values(fragment, assigns)
+      pattern = Placeholder.pattern(@nonce)
+      fragment.source.traverse do |node|
+        next unless node.text? && node.content.match?(pattern)
+
+        node.content = node.content.gsub(pattern) { @config.renderer.resolve_value($1, assigns) }
+      end
+    end
+
     # Accepts whatever a :html resolver returns (ActionText content, rich
     # text, a Nokogiri node, or an HTML string) and coerces it to the
     # ActionText::Fragment that #substitute needs, or nil to drop the chip.

data/lib/lexxy_variables/version.rb

@@ -1,3 +1,3 @@
 module LexxyVariables
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/lexxy_variables/with_variables.rb

@@ -0,0 +1,31 @@
+module LexxyVariables
+  # Mixed into ActionText::Content via the :action_text_content load hook.
+  module WithVariables
+    # Returns a new ActionText::Content with every variable chip resolved, so
+    # Action Text's own conversions chain from the result:
+    #
+    #   @post.body.with_variables(first_name: "Ada").to_plain_text
+    #   @post.body.with_variables(context: tenant).to_s
+    #   @post.body.with_variables.to_markdown  # on Rails versions that ship it
+    #
+    # Takes `context:`, `locale:`, and per-render values as keyword args or an
+    # `assigns:` hash.
+    def with_variables(context: nil, locale: nil, assigns: {}, **inline_assigns)
+      LexxyVariables::Resolver.new.call(
+        self, context: context, locale: locale, assigns: assigns.merge(inline_assigns)
+      )
+    end
+  end
+
+  # Mixed into ActionText::RichText via the :action_text_rich_text load hook,
+  # so `@post.body.with_variables` works straight off the association.
+  module RichTextWithVariables
+    def with_variables(context: nil, locale: nil, assigns: {}, **inline_assigns)
+      (body || ActionText::Content.new(nil, canonicalize: false))
+        .with_variables(context: context, locale: locale, assigns: assigns.merge(inline_assigns))
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_text_content) { include LexxyVariables::WithVariables }
+ActiveSupport.on_load(:action_text_rich_text) { include LexxyVariables::RichTextWithVariables }

data/lib/lexxy_variables.rb

@@ -1,5 +1,4 @@
 require "active_support"
-require "erb"
 require "securerandom"
 require "nokogiri"
 
@@ -10,15 +9,16 @@ require "lexxy_variables/registry"
 require "lexxy_variables/renderers/substitution"
 require "lexxy_variables/renderers/liquid"
 require "lexxy_variables/configuration"
-require "lexxy_variables/pipeline"
+require "lexxy_variables/resolver"
+require "lexxy_variables/with_variables"
 require "lexxy_variables/attachable"
 require "lexxy_variables/helper"
 require "lexxy_variables/engine" if defined?(Rails::Engine)
 
 # Insert and safely resolve variable/attachment tokens in Lexxy rich text.
 #
-# The gem owns the mechanism: the editor extension, the nonce-safe render
-# pipeline, the attachment-type registry, and the renderers. The host app owns
+# The gem owns the mechanism: the editor extension, the nonce-safe resolver,
+# the attachment-type registry, and the renderers. The host app owns
 # the policy: what variables exist (catalog), what a key resolves to (assigns),
 # and any extra attachment types (register_attachment, e.g. snippets).
 module LexxyVariables

data/vendor/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/erb-6.0.5/gem_make.out

@@ -0,0 +1,19 @@
+current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/erb-6.0.5/ext/erb/escape
+/opt/hostedtoolcache/Ruby/3.4.10/x64/bin/ruby extconf.rb
+checking for rb_ext_ractor_safe() in ruby.h... yes
+creating Makefile
+
+current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/erb-6.0.5/ext/erb/escape
+make DESTDIR\= sitearchdir\=./.gem.20260719-2315-wnl2jv sitelibdir\=./.gem.20260719-2315-wnl2jv clean
+
+current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/erb-6.0.5/ext/erb/escape
+make DESTDIR\= sitearchdir\=./.gem.20260719-2315-wnl2jv sitelibdir\=./.gem.20260719-2315-wnl2jv
+compiling escape.c
+linking shared-object erb/escape.so
+
+current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/erb-6.0.5/ext/erb/escape
+make DESTDIR\= sitearchdir\=./.gem.20260719-2315-wnl2jv sitelibdir\=./.gem.20260719-2315-wnl2jv install
+/usr/bin/install -c -m 0755 escape.so ./.gem.20260719-2315-wnl2jv/erb
+
+current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/erb-6.0.5/ext/erb/escape
+make DESTDIR\= sitearchdir\=./.gem.20260719-2315-wnl2jv sitelibdir\=./.gem.20260719-2315-wnl2jv clean

data/vendor/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/{lexxy-0.9.24 → lexxy-0.9.25}/gem_make.out

@@ -1,2 +1,2 @@
-current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/lexxy-0.9.24/ext
-/opt/hostedtoolcache/Ruby/3.4.10/x64/bin/ruby -rrubygems /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/exe/rake RUBYARCHDIR\=/home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/lexxy-0.9.24 RUBYLIBDIR\=/home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/lexxy-0.9.24
+current directory: /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/lexxy-0.9.25/ext
+/opt/hostedtoolcache/Ruby/3.4.10/x64/bin/ruby -rrubygems /home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/exe/rake RUBYARCHDIR\=/home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/lexxy-0.9.25 RUBYLIBDIR\=/home/runner/work/lexxy-variables/lexxy-variables/vendor/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/lexxy-0.9.25

data/vendor/bundle/ruby/3.4.0/gems/{concurrent-ruby-1.3.7 → concurrent-ruby-1.3.8}/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Current
 
+## Release v1.3.8 (19 July 2026)
+
+concurrent-ruby:
+
+* See the [release notes on GitHub](https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.3.8).
+
 ## Release v1.3.7 (16 June 2026)
 
 concurrent-ruby:

data/vendor/bundle/ruby/3.4.0/gems/{concurrent-ruby-1.3.7 → concurrent-ruby-1.3.8}/lib/concurrent-ruby/concurrent/constants.rb

@@ -3,6 +3,6 @@ module Concurrent
   # Various classes within allows for +nil+ values to be stored,
   # so a special +NULL+ token is required to indicate the "nil-ness".
   # @!visibility private
-  NULL = ::Object.new
+  NULL = ::Object.new.freeze
 
 end

data/vendor/bundle/ruby/3.4.0/gems/{concurrent-ruby-1.3.7 → concurrent-ruby-1.3.8}/lib/concurrent-ruby/concurrent/promises.rb

@@ -915,6 +915,7 @@ module Concurrent
     # Represents a value which will become available in future. May reject with a reason instead,
     # e.g. when the tasks raises an exception.
     class Future < AbstractEventFuture
+      SET_BACKTRACE_LOCATIONS_SUPPORTED = RUBY_VERSION >= '3.4'
 
       # Is it in fulfilled state?
       # @return [Boolean]
@@ -1014,9 +1015,10 @@ module Concurrent
         raise Concurrent::Error, 'it is not rejected' unless rejected?
         raise ArgumentError unless args.size <= 1
         reason = Array(internal_state.reason).flatten.compact
+        callsites = SET_BACKTRACE_LOCATIONS_SUPPORTED ? caller_locations : caller
         if reason.size > 1
           ex = Concurrent::MultipleErrors.new reason
-          ex.set_backtrace(caller)
+          ex.set_backtrace(callsites)
           ex
         else
           ex = if reason[0].respond_to? :exception
@@ -1024,7 +1026,11 @@ module Concurrent
                else
                  RuntimeError.new(reason[0]).exception(*args)
                end
-          ex.set_backtrace Array(ex.backtrace) + caller
+          if SET_BACKTRACE_LOCATIONS_SUPPORTED && (locations = ex.backtrace_locations)
+            ex.set_backtrace locations + callsites
+          else
+            ex.set_backtrace Array(ex.backtrace) + callsites.map(&:to_s)
+          end
           ex
         end
       end