lexxy-variables 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b3aad3f3ce716d523463e8bc65d14d4d7e1b87fbe166b3c2a240e52632e8c4f
-  data.tar.gz: 5837750469a552f3758ad187a0d8087b935cba24983df189e70132ddcab396b7
+  metadata.gz: a109be7d8f0e268e60ce7fbaa71cf752d492f6d08f04300b52418016a54c7fdf
+  data.tar.gz: a84a11352b3b3d9701719e66428574c8693e05e36a8fff2f3d140022076ee930
 SHA512:
-  metadata.gz: f850a1474ddd89b9652a0a76a670b039246fe8db766168c3acb8df93708b331e59a7586cca403f3ae49bea97dd180007a9c60893c64a6174776cf959d9d593d2
-  data.tar.gz: 1b246e2ab7e6eb75fa3814e018fb826de38a294e68efe5df05854c14d83882690a5c7e82635995350bd0d87a8bde67290c2212972e73cde95cba5f54dcdde08d
+  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.
@@ -44,8 +44,8 @@ in your entrypoint:
 
 ```js
 // app/javascript/application.js
+import * as Lexxy from "lexxy"
 import VariableExtension from "lexxy-variables"
-import * as Lexxy from "@37signals/lexxy"
 
 Lexxy.configure({ global: { extensions: [ VariableExtension ] } })
 ```
@@ -54,16 +54,25 @@ Lexxy.configure({ global: { extensions: [ VariableExtension ] } })
 npm package. Install it alongside Lexxy:
 
 ```sh
-yarn add lexxy-variables @37signals/lexxy
+yarn add @37signals/lexxy lexxy-variables
 ```
 
-and register the extension with the same snippet as above.
+and register the extension in your JavaScript.
+
+```js
+// app/javascript/application.js
+import * as Lexxy from "@37signals/lexxy"
+import VariableExtension from "lexxy-variables"
+
+Lexxy.configure({ global: { extensions: [ VariableExtension ] } })
+```
 
 ## Minimal configuration
 
 `catalog` is the list users pick from in the editor. `assigns` is the lookup that
 turns a key into a value at render time. `catalog` is required and `assigns` is
-optional. Leave it out and the gem reads `value` straight off the catalog item.
+optional. Leave it out and the gem reads `value` straight off the catalog item,
+or supply values per render (see [Examples](#examples)).
 
 Put the `configure` block in an initializer, e.g. `config/initializers/lexxy_variables.rb`:
 
@@ -73,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`
@@ -98,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_lexxy_content(@record.body) %>
+<%= @record.body.with_variables %>
 ```
 
 Each chip resolves to its value, so the reader sees finished text:
@@ -113,15 +120,149 @@ Each chip resolves to its value, so the reader sees finished text:
 `@record` and `:body` are placeholders. Use whatever model and Action Text
 attribute hold your content.
 
+## Examples
+
+### Simple replacement from a model
+
+First and last name variables, with the values supplied at render time. No Liquid needed. The `catalog` lists the two variables so they appear in the editor:
+
+```ruby
+# config/initializers/lexxy_variables.rb
+LexxyVariables.configure do |c|
+  c.catalog = [
+    { key: "first_name", name: "First name" },
+    { key: "last_name",  name: "Last name" }
+  ]
+end
+```
+
+Editor page:
+
+```erb
+<%= form_with model: @message do |form| %>
+  <%= form.rich_text_area :body do %>
+    <%= lexxy_variables_prompt %>
+  <% end %>
+  <%= form.submit %>
+<% end %>
+```
+
+Display page:
+
+```erb
+<%= @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. 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 `with_variables` takes no arguments:
+
+```ruby
+LexxyVariables.configure do |c|
+  c.catalog = [ { key: "company", name: "Company", value: "Acme" } ]
+end
+```
+
+```erb
+<%= @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:
+
+```ruby
+# app/drops/user_drop.rb
+class UserDrop < Liquid::Drop
+  def initialize(user) = @user = user
+
+  def first_name = @user.first_name
+  def full_name  = @user.full_name
+  def email      = @user.email
+end
+```
+
+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|
+  c.catalog = [
+    { key: "user.first_name", name: "First name" },
+    { key: "user.full_name",  name: "Full name" },
+    { key: "user.email",      name: "Email" }
+  ]
+
+  c.renderer = LexxyVariables::Renderers::Liquid.new
+
+  c.assigns = ->(_used_keys) { { "user" => UserDrop.new(Current.user) } }
+end
+```
+
+```erb
+<%= @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
+```
+
+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
 
-`context` is yours to define. The gem passes it untouched to your catalog,
-assigns, and resolve callables, so put whatever they need in it. That might be a
-tenant, `nil`, or any object.
+`context` is yours to define. The gem passes it untouched to your catalog, assigns, and resolve callables, so put whatever they need in it. That might be a tenant, `nil`, or any object.
 
 ```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.
@@ -130,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,
@@ -145,24 +286,19 @@ 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. |
-| `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_lexxy_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_lexxy_content(@record.body, locale: recipient.locale) %>
 ```
 
 ## Multi-tenancy
@@ -177,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 %>
@@ -188,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_lexxy_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
@@ -256,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,11 +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
-    def render_lexxy_content(rich_text, context: nil, locale: I18n.locale)
-      LexxyVariables::Pipeline.new(self).call(rich_text, context: context, locale: locale)
-    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,41 +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)
-      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)
-        )
-
-        assigns = @config.resolve_assigns(@context, @used_keys.uniq)
-        rendered = @config.renderer.render(html, nonce: @nonce, assigns: assigns)
-
-        @view.render(layout: @config.content_layout) { rendered.html_safe }
+        fragment = substitute(content.fragment, 0)
+        resolved = @config.resolve_assigns(@context, @used_keys.uniq)
+        resolved = resolved.merge(assigns.transform_keys(&:to_s)) if assigns.any?
+        inject_values(fragment, resolved)
+        ActionText::Content.new(fragment, canonicalize: false)
       end
     end
 
@@ -73,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.3"
+  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