lexxy-variables 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8513d081ebde943d76aefe2150f1c9fc8cd4d5477b0333ea0caa057b73a02992
+  data.tar.gz: b7cc4682a733783bfb1e68d9b6f01d7ac52f0459e4a6de77c461e59d92bc266c
+SHA512:
+  metadata.gz: 6f45333d30271a85bdbf32e319dd7d43d923f7d72fe9c8aabb6373a6174ce5218df87321dde0b38021e945134fa6a5de708aefb4a21b1d40a2c6b17ae90df228
+  data.tar.gz: 6af8e6bdb3c0cc8a1cba9c18e76fdd36772d219cfc3da67bc87e7c7bec150ed4ef997cb6272aed108da0465d052984cbb7630e76f9d110fbe63a0f03dff382b9

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2026 Andrew Quinn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,280 @@
+# lexxy-variables
+
+Insert and safely resolve variables in [Lexxy](https://github.com/basecamp/lexxy)
+rich text. The gem gives you an editor button (and a `{{` prompt) for inserting
+variables into your text. Each variable is stored as an [Action Text
+attachment](https://guides.rubyonrails.org/action_text_overview.html#rendering-attachments)
+— an `<action-text-attachment>` chip with its own content type — not as literal
+`{{ var_name }}` markup. At render time the gem resolves each chip to its `value`.
+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 `:value` chip resolves to an escaped string, a `:fragment` 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.
+
+<p align="center">
+  <img src="docs/images/prompt-popup.png" alt="The {{ prompt listing variables inside the Lexxy editor" width="606">
+</p>
+
+## Requirements
+
+Ruby 3.2+, Rails 8.0+, and a JavaScript bundler (esbuild, vite, or webpack).
+See the note on importmap in [Install](#install).
+
+## Install
+
+Ruby:
+
+```ruby
+# Gemfile
+gem "lexxy-variables"
+```
+
+JavaScript. The editor extension is distributed as an npm package, so you need a
+bundler (esbuild, vite, webpack). Install it alongside Lexxy:
+
+```sh
+yarn add lexxy-variables @37signals/lexxy
+```
+
+Then register the extension in your JavaScript entrypoint:
+
+```js
+import VariableExtension from "lexxy-variables"
+import * as Lexxy from "@37signals/lexxy"
+
+Lexxy.configure({ global: { extensions: [ VariableExtension ] } })
+```
+
+The extension imports a few primitives from `lexical`, and Lexical is very
+sensitive to running as a single instance. If your bundle ends up with two
+copies of `lexical` (a common one: your app pulls a newer `lexical` than the
+version Lexxy bundles), commands dispatched from one instance won't see nodes
+from the other and inserts fail silently. If you hit that, pin `lexical` to the
+version Lexxy bundles so everything dedupes to one copy:
+
+```sh
+# match the lexical Lexxy depends on (0.44.x for Lexxy 0.9.22)
+yarn add lexical@0.44.0
+```
+
+> **importmap is not supported yet.** The extension needs `lexical` and
+> `@37signals/lexxy` resolved to the same instance Lexxy runs, which importmap
+> can't currently guarantee. The gem still ships the vendored JS and pins so it
+> works the moment Lexxy exposes Lexical to extensions upstream
+> ([basecamp/lexxy#1047](https://github.com/basecamp/lexxy/pull/1047)). Until
+> then, use a bundler.
+
+## 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; `assigns` is
+optional. Leave it out and the gem reads `value` straight off the catalog item.
+
+Put the `configure` block in an initializer, e.g. `config/initializers/lexxy_variables.rb`:
+
+```ruby
+LexxyVariables.configure do |c|
+  c.catalog = [ { key: "company", name: "Company", value: "Acme" } ]
+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`
+block — that is what feeds the `{{` popup and the toolbar dropdown:
+
+```erb
+<%= form_with model: @record do |form| %>
+  <%= form.rich_text_area :body do %>
+    <%= lexxy_variables_prompt %>
+  <% end %>
+  <%= form.submit %>
+<% end %>
+```
+
+Typing `{{` opens the prompt shown above; there's also a toolbar dropdown for
+picking from the same list. Inserted variables appear as chips in the editor:
+
+<p align="center">
+  <img src="docs/images/editor-chips.png" alt="Variable chips inline in the Lexxy editor" width="606">
+</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:
+
+```erb
+<%= render_lexxy_content(@record.body) %>
+```
+
+Each chip resolves to its value, so the reader sees finished text:
+
+<p align="center">
+  <img src="docs/images/rendered-output.png" alt="The saved message with every variable chip resolved to its value" width="606">
+</p>
+
+`@record` and `:body` are placeholders — use whatever model and Action Text
+attribute hold your content.
+
+## 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.
+
+```ruby
+LexxyVariables.configure do |c|
+  # The menu users pick from. A list, a zero-arg lambda, or a ->(context) lambda.
+  c.catalog = ->(context) { context.variables + BuiltinVariable.all }
+
+  # The lookup. Gets only the keys used in the content being rendered and returns
+  # a { key => value } hash. ->(used_keys) also works if you don't need context.
+  c.assigns = ->(context, used_keys) { MyResolver.assigns(context, used_keys) }
+
+  # Opt into Liquid for dotted access / drops / filters.
+  c.renderer = LexxyVariables::Renderers::Liquid.new
+
+  # How the catalog is ordered in the prompt and dropdown. Defaults to :name
+  # (case-insensitive alphabetical). Use :key to sort by key, false to keep the
+  # catalog's given order, or a lambda: a ->(item) sort key or a ->(a, b) comparator.
+  c.sort = :name
+
+  # Register an extra attachment type. :fragment splices rich HTML pre-sanitize
+  # (e.g. snippets) and its inner :value chips resolve in the same pass.
+  c.register_attachment(
+    content_type: "application/vnd.actiontext.snippet",
+    phase: :fragment,
+    label: "Snippet", # shown as a badge in the prompt when the list mixes types
+    resolve: ->(node, context) { MySnippets.content_for(node, context) }
+  )
+end
+```
+
+## Multi-tenancy
+
+Tenancy is optional. If your app is multi-tenant, pass the tenant through as
+`context`. With [acts_as_tenant](https://github.com/ErwinM/acts_as_tenant) that
+looks like:
+
+```ruby
+LexxyVariables.configure do |c|
+  c.catalog = ->(tenant) { tenant.variables }
+end
+```
+
+Both view helpers take the same `context:`. Pass the tenant on the editor page:
+
+```erb
+<%= form.rich_text_area :body do %>
+  <%= lexxy_variables_prompt(context: ActsAsTenant.current_tenant) %>
+<% end %>
+```
+
+and again on the display page:
+
+```erb
+<%= render_lexxy_content(@record.body, context: ActsAsTenant.current_tenant) %>
+```
+
+Or skip `context` entirely and rely on acts_as_tenant scoping queries to the
+current tenant for you:
+
+```ruby
+LexxyVariables.configure do |c|
+  c.catalog = -> { Variable.all }  # already scoped to ActsAsTenant.current_tenant
+  c.assigns = ->(keys) { Variable.where(key: keys).pluck(:key, :value).to_h }
+end
+```
+
+## Styling
+
+The gem ships a default stylesheet so the editor UI works out of the box. Import
+it and override the CSS custom properties (or the classes) to match your app.
+
+```css
+/* bundlers (esbuild, vite): */
+@import "lexxy-variables/styles";
+```
+
+```ruby
+# importmap / asset-pipeline hosts: the engine adds the vendored CSS to the asset
+# paths. Link or @import "lexxy_variables.css".
+```
+
+Classes the gem emits: `.lexxy-variable` (token chip), `.lexxy-variable--block`
+(chips that expand to a block, e.g. snippets), `.lexxy-variables-menu` /
+`.lexxy-variables-menu__item` (the toolbar dropdown), and `.lexxy-variables-option`
+/ `__header` / `__name` / `__type` / `__code` (option content, shared by the
+`{{` prompt popup and the dropdown).
+
+<p align="center">
+  <img src="docs/images/toolbar-dropdown.png" alt="The toolbar dropdown listing the variable catalog" width="640">
+</p>
+
+Override without touching the classes:
+
+```css
+:root {
+  --lexxy-variable-background: #fef3c7;
+  --lexxy-variable-color: #92400e;
+  --lexxy-variable-block-border: 1px dashed #f59e0b;
+  --lexxy-variables-menu-item-hover-background: #f4f4f5;
+  --lexxy-variables-option-code-color: #a1a1aa;
+  --lexxy-variables-option-type-background: #f4f4f5;
+  --lexxy-variables-option-type-color: #71717a;
+  --lexxy-variables-prompt-max-width: 24rem; /* widen the {{ prompt popup (Lexxy caps at 20ch) */
+}
+```
+
+Your prompt items should use the option classes so they appear the same in the
+popup and the dropdown:
+
+```erb
+<template type="menu">
+  <span class="lexxy-variables-option">
+    <span class="lexxy-variables-option__name"><%= variable.name %></span>
+    <code class="lexxy-variables-option__code">{{ <%= variable.key %> }}</code>
+  </span>
+</template>
+```
+
+## 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 `:value` resolves to HTML-escaped text that can't
+  do anything, while a `:fragment` 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.
+
+## Contributing
+
+Bug reports and pull requests are welcome. To get set up:
+
+```sh
+bundle install
+bundle exec rake test     # run the test suite
+bundle exec rubocop       # lint
+```
+
+The editor extension in `src/` is compiled into `vendor/` (the copy importmap
+apps load). If you change anything under `src/`, rebuild before committing or CI
+will fail:
+
+```sh
+npm install
+npm run build
+```
+
+CI runs the tests across Ruby 3.2–4.0, rubocop, and a check that `vendor/`
+matches `src/`.
+

data/app/views/lexxy_variables/_prompt.html.erb

@@ -0,0 +1,27 @@
+<%# Feeds the editor extension. Built from LexxyVariables.config.catalog. A host
+    can override this file by creating app/views/lexxy_variables/_prompt.html.erb. %>
+<% show_types = items.map { |i| LexxyVariables.item_content_type(i) }.uniq.size > 1 %>
+<lexxy-prompt trigger="<%= trigger %>" name="variable" empty-results="<%= empty_results %>">
+  <% items.each do |item| %>
+    <% key = LexxyVariables.item_key(item) %>
+    <% name = LexxyVariables.item_name(item) %>
+    <% content_type = LexxyVariables.item_content_type(item) %>
+    <% type_label = show_types ? LexxyVariables.item_type_label(item) : nil %>
+    <lexxy-prompt-item search="<%= "#{name} #{key}" %>" sgid="<%= LexxyVariables.item_sgid(item) %>">
+      <template type="menu">
+        <span class="lexxy-variables-option">
+          <span class="lexxy-variables-option__header">
+            <span class="lexxy-variables-option__name"><%= name %></span>
+            <% if type_label.present? %>
+              <span class="lexxy-variables-option__type"><%= type_label %></span>
+            <% end %>
+          </span>
+          <code class="lexxy-variables-option__code">{{ <%= key %> }}</code>
+        </span>
+      </template>
+      <%= tag.template(type: "editor", "content-type": content_type) do %><%=
+        lexxy_variable_chip(name, key: key, block: LexxyVariables.block_content_type?(content_type))
+      %><% end %>
+    </lexxy-prompt-item>
+  <% end %>
+</lexxy-prompt>

data/config/importmap.rb

@@ -0,0 +1,3 @@
+# Importmap pin for host apps using importmap-rails. Bundler-based hosts ignore
+# this and resolve the npm package from node_modules instead.
+pin "lexxy-variables", to: "lexxy_variables.js", preload: true

data/lib/lexxy-variables.rb

@@ -0,0 +1,4 @@
+# Bundler auto-requires a gem by its dashed name ("lexxy-variables"), but the
+# implementation lives in lexxy_variables.rb (the LexxyVariables namespace). This
+# shim bridges the two so `gem "lexxy-variables"` loads the gem with no `require:`.
+require "lexxy_variables"

data/lib/lexxy_variables/attachable.rb

@@ -0,0 +1,17 @@
+module LexxyVariables
+  # Convenience for hosts whose variable objects are not already Action Text
+  # attachables. Include it and set `attachable_content_type` so chips carry a
+  # real sgid and the pipeline can match them. Models that already include
+  # ActionText::Attachable do not need this.
+  module Attachable
+    extend ActiveSupport::Concern
+
+    included do
+      include ActionText::Attachable
+    end
+
+    def attachable_content_type
+      LexxyVariables::VARIABLE_CONTENT_TYPE
+    end
+  end
+end

data/lib/lexxy_variables/attachment_type.rb

@@ -0,0 +1,25 @@
+module LexxyVariables
+  # Describes one kind of attachment chip the pipeline knows how to resolve.
+  # A chip is identified solely by its content-type, which the editor always
+  # writes and the model always persists.
+  #
+  # phase:
+  #   :value    the resolver returns a String key. The pipeline records it, emits
+  #             a nonce-protected placeholder, and later substitutes the resolved
+  #             HTML-escaped value. Safe by construction. Variables use this.
+  #   :fragment the resolver returns rich content (ActionText content, RichText,
+  #             or an HTML String) spliced into the document BEFORE sanitization,
+  #             so the sanitizer cleans it and inner :value chips resolve in the
+  #             same pass. Snippets use this. Bounded by max_fragment_depth.
+  #
+  # resolve: ->(node, context) { ... } returning a key (:value) or rich content
+  #   (:fragment), or nil to drop the chip.
+  #
+  # label: optional short type name (e.g. "Variable", "Snippet"). The prompt shows
+  #   it as a badge only when the list mixes more than one type, so users can tell
+  #   them apart without noise when there is only one. nil shows no badge.
+  AttachmentType = Struct.new(:content_type, :phase, :resolve, :label, keyword_init: true) do
+    def value?    = phase == :value
+    def fragment? = phase == :fragment
+  end
+end

data/lib/lexxy_variables/configuration.rb

@@ -0,0 +1,117 @@
+module LexxyVariables
+  # Host-supplied policy. The gem ships working defaults, so the smallest
+  # integration is just `config.catalog = [...]`. Everything else is optional.
+  #
+  #   LexxyVariables.configure do |c|
+  #     c.catalog = [ { key: "company", name: "Company", value: "Acme" } ]
+  #   end
+  #
+  # catalog: the insertable items for the editor prompt. A list, a zero-arg
+  #   callable, or a ->(context) callable. Items respond to #key, #name,
+  #   optional #value (used by the default assigns), and #attachable_sgid.
+  # assigns: ->(context, used_keys) or ->(used_keys) returning a Hash of
+  #   key => value for a render. Omit to read #value off catalog items.
+  # renderer: Renderers::Substitution (default, no Liquid) or Renderers::Liquid.
+  # max_fragment_depth: how deep :fragment 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_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
+      register_default_variable_type
+    end
+
+    # Adds or overrides an attachment type. Variables are pre-registered. A host
+    # calls this to add types like snippets, or to override the variable resolver.
+    # `label` is an optional badge name shown in the prompt when types are mixed.
+    def register_attachment(content_type:, phase:, resolve:, label: nil)
+      registry.register(AttachmentType.new(content_type:, phase:, resolve:, label:))
+    end
+
+    def resolve_catalog(context)
+      sort_catalog(Array(call_with_context(@catalog, context)))
+    end
+
+    def resolve_assigns(context, keys)
+      return default_assigns(context, keys) unless @assigns
+
+      if @assigns.arity == 1
+        @assigns.call(keys)
+      else
+        @assigns.call(context, keys)
+      end
+    end
+
+    private
+
+    # The gem's built-in variable resolver. Prefers an sgid-backed attachable
+    # (models that respond to #key), and otherwise falls back to the key that
+    # lexxy_variable_chip embeds as data-lexxy-key in the chip content. The
+    # fallback is what makes a plain-hash catalog (no sgid) resolve. Hosts with
+    # extra policy (e.g. tenant scoping) override this by re-registering the type.
+    def register_default_variable_type
+      register_attachment(
+        content_type: LexxyVariables::VARIABLE_CONTENT_TYPE,
+        phase: :value,
+        resolve: ->(node, _context) {
+          attachable = LexxyVariables.attachable_from(node)
+          next attachable.key if attachable.respond_to?(:key)
+
+          LexxyVariables.chip_key(node)
+        }
+      )
+    end
+
+    # Default value resolution: look each used key up in the catalog and read
+    # #value. Used only when no custom `assigns` is configured.
+    def default_assigns(context, keys)
+      items = Array(resolve_catalog(context))
+      keys.each_with_object({}) do |key, hash|
+        item = items.find { |i| LexxyVariables.item_key(i) == key }
+        hash[key] = LexxyVariables.item_value(item) if item
+      end
+    end
+
+    # Orders the resolved catalog per the `sort` policy. Both the prompt DOM and
+    # the dropdown read from this, so ordering stays consistent across them.
+    def sort_catalog(items)
+      case @sort
+      when nil, false
+        items
+      when :name
+        items.sort_by { |item| LexxyVariables.item_name(item).to_s.downcase }
+      when :key
+        items.sort_by { |item| LexxyVariables.item_key(item).to_s.downcase }
+      else
+        if @sort.arity == 1
+          items.sort_by { |item| @sort.call(item) }
+        else
+          items.sort { |a, b| @sort.call(a, b) }
+        end
+      end
+    end
+
+    def call_with_context(value, context)
+      return value unless value.respond_to?(:call)
+
+      if value.arity == 0
+        value.call
+      else
+        value.call(context)
+      end
+    end
+  end
+end

data/lib/lexxy_variables/engine.rb

@@ -0,0 +1,29 @@
+module LexxyVariables
+  # Wires the gem into a host Rails app: mixes in the helper and exposes the
+  # vendored JS so importmap apps can pin it with no JS tooling. Bundler apps
+  # (esbuild, etc.) instead resolve the npm package from node_modules and ignore
+  # the vendored copy.
+  class Engine < ::Rails::Engine
+    initializer "lexxy_variables.helper" do
+      ActiveSupport.on_load(:action_view) do
+        include LexxyVariables::Helper
+      end
+    end
+
+    # Make the vendored JS + CSS resolvable by the asset pipeline (Propshaft/Sprockets).
+    initializer "lexxy_variables.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << root.join("vendor/javascript").to_s
+        app.config.assets.paths << root.join("vendor/stylesheets").to_s
+      end
+    end
+
+    # Pin the vendored module for importmap-rails hosts. Without importmap-rails
+    # the config key does not exist and this initializer does nothing.
+    initializer "lexxy_variables.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << root.join("config/importmap.rb")
+      end
+    end
+  end
+end

data/lib/lexxy_variables/helper.rb

@@ -0,0 +1,25 @@
+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.
+  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")
+      items = Array(LexxyVariables.config.resolve_catalog(context))
+      render partial: "lexxy_variables/prompt",
+             locals: { items: items, trigger: trigger, empty_results: empty_results }
+    end
+
+    # Default variable/attachment chip shown in the editor. `block:` renders the
+    # block style, for chips that expand to a rich fragment (e.g. snippets).
+    def lexxy_variable_chip(name, key:, block: false)
+      tag.span name,
+        class: [ "lexxy-variable", ("lexxy-variable--block" if block) ],
+        data: { lexxy_key: key }
+    end
+  end
+end

data/lib/lexxy_variables/pipeline.rb

@@ -0,0 +1,97 @@
+module LexxyVariables
+  # Turns stored rich text into rendered HTML with attachment chips resolved.
+  #
+  # 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. :value output is HTML-escaped and therefore
+  #      inert. :fragment output is spliced pre-sanitize so the sanitizer cleans it.
+  #   3. Any template-engine escaping (Liquid braces) lives only in that renderer.
+  #
+  # 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
+      @config = config
+    end
+
+    def call(rich_text, context: nil, locale: I18n.locale)
+      body = rich_text&.body
+      return "".html_safe if body.blank?
+
+      @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 }
+      end
+    end
+
+    private
+
+    def substitute(fragment, depth)
+      fragment.replace(ActionText::Attachment.tag_name) do |node|
+        type = @config.registry.match(node)
+        next node unless type # images, files, and unknown attachments pass through
+
+        if type.value?
+          resolve_value(node, type)
+        elsif type.fragment?
+          resolve_fragment(node, type, depth)
+        else
+          node
+        end
+      end
+    end
+
+    def resolve_value(node, type)
+      key = type.resolve.call(node, @context)
+      return empty_text(node) if key.nil?
+
+      @used_keys << key
+      Nokogiri::XML::Text.new(Placeholder.token(@nonce, key), node.document)
+    end
+
+    def resolve_fragment(node, type, depth)
+      return empty_text(node) if depth >= @config.max_fragment_depth
+
+      inner = coerce_fragment(type.resolve.call(node, @context))
+      return empty_text(node) if inner.nil?
+
+      substitute(inner, depth + 1)
+    end
+
+    # Accepts whatever a :fragment 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.
+    # The Nokogiri checks come before the respond_to? checks because Nokogiri
+    # nodes also respond to #fragment, with different behavior.
+    def coerce_fragment(value)
+      return nil if value.nil?
+      return nil if value.respond_to?(:blank?) && value.blank?
+      return value if value.is_a?(ActionText::Fragment)
+      return ActionText::Fragment.wrap(value) if value.is_a?(Nokogiri::XML::DocumentFragment)
+      return ActionText::Fragment.from_html(value.to_html) if value.is_a?(Nokogiri::XML::Node)
+      return value.fragment if value.respond_to?(:fragment)         # ActionText::Content
+      return value.body&.fragment if value.respond_to?(:body)       # ActionText::RichText
+
+      ActionText::Fragment.from_html(value.to_s)
+    end
+
+    def empty_text(node)
+      Nokogiri::XML::Text.new("", node.document)
+    end
+  end
+end

data/lib/lexxy_variables/placeholder.rb

@@ -0,0 +1,16 @@
+module LexxyVariables
+  # The single definition of the placeholder token format. The pipeline writes
+  # tokens with #token and the renderers find them with #pattern, so the format
+  # only lives here.
+  module Placeholder
+    PREFIX = "@@lexxy-var-"
+
+    def self.token(nonce, key)
+      "#{PREFIX}#{nonce}:#{key}@@"
+    end
+
+    def self.pattern(nonce)
+      /#{Regexp.escape(PREFIX)}#{Regexp.escape(nonce)}:([a-z][a-z0-9_.]*)@@/
+    end
+  end
+end

data/lib/lexxy_variables/registry.rb

@@ -0,0 +1,24 @@
+module LexxyVariables
+  # Maps a chip's content-type to the attachment type that resolves it.
+  # Registering the same content-type again overrides the previous entry, so a
+  # host can replace a built-in type (e.g. variables) or add new ones (snippets).
+  # Nodes with no registered content-type (images, files, ...) match nothing and
+  # are left untouched by the pipeline.
+  class Registry
+    def initialize
+      @by_content_type = {}
+    end
+
+    def register(type)
+      @by_content_type[type.content_type] = type
+    end
+
+    def match(node)
+      @by_content_type[node["content-type"]]
+    end
+
+    def types
+      @by_content_type.values
+    end
+  end
+end

data/lib/lexxy_variables/renderers/liquid.rb

@@ -0,0 +1,30 @@
+module LexxyVariables
+  module Renderers
+    # Opt-in renderer that resolves placeholders 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.
+    #
+    # `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.
+    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)
+      end
+    end
+  end
+end

data/lib/lexxy_variables/renderers/substitution.rb

@@ -0,0 +1,15 @@
+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.
+    class Substitution
+      def render(html, nonce:, assigns:)
+        html.gsub(Placeholder.pattern(nonce)) { ERB::Util.html_escape(assigns[$1].to_s) }
+      end
+    end
+  end
+end

data/lib/lexxy_variables/version.rb

@@ -0,0 +1,3 @@
+module LexxyVariables
+  VERSION = "0.0.1"
+end

data/lib/lexxy_variables.rb

@@ -0,0 +1,128 @@
+require "active_support"
+require "erb"
+require "securerandom"
+require "nokogiri"
+
+require "lexxy_variables/version"
+require "lexxy_variables/placeholder"
+require "lexxy_variables/attachment_type"
+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/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 policy: what variables exist (catalog), what a key resolves to (assigns),
+# and any extra attachment types (register_attachment, e.g. snippets).
+module LexxyVariables
+  # Default content-type carried by variable attachment chips. A host may
+  # register additional types (snippets, etc.) via Configuration#register_attachment.
+  VARIABLE_CONTENT_TYPE = "application/vnd.actiontext.variable"
+
+  class << self
+    def configure
+      yield config
+      config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    # Primarily for tests / reloading.
+    def reset_config!
+      @config = Configuration.new
+    end
+
+    # Resolves an attachment node's sgid to its attachable, or nil if the sgid is
+    # missing or stale. Handy for host-supplied :value / :fragment resolvers.
+    def attachable_from(node)
+      ActionText::Attachable.from_attachable_sgid(node["sgid"])
+    rescue StandardError
+      nil
+    end
+
+    # Reads the key that lexxy_variable_chip embeds as data-lexxy-key in the chip
+    # content, or nil if absent. This is how a plain-hash catalog (which has no
+    # sgid-backed attachable) maps a chip back to its catalog key at render.
+    def chip_key(node)
+      content = node["content"]
+      return nil if content.nil? || content.empty?
+
+      span = Nokogiri::HTML5.fragment(content).at_css("[data-lexxy-key]")
+      key = span && span["data-lexxy-key"]
+      key unless key.nil? || key.empty?
+    rescue StandardError
+      nil
+    end
+
+    # Catalog items can be plain hashes or any objects that respond to the same
+    # fields. These accessors read the fields the prompt needs either way.
+    def item_name(item)
+      if item.is_a?(Hash)
+        item[:name]
+      else
+        item.name
+      end
+    end
+
+    def item_key(item)
+      if item.is_a?(Hash)
+        item[:key]
+      else
+        item.key
+      end
+    end
+
+    def item_value(item)
+      if item.is_a?(Hash)
+        item[:value]
+      else
+        item.value
+      end
+    end
+
+    def item_sgid(item)
+      if item.is_a?(Hash)
+        item[:attachable_sgid]
+      else
+        item.attachable_sgid
+      end
+    end
+
+    def item_content_type(item)
+      if item.is_a?(Hash)
+        item[:content_type]
+      elsif item.respond_to?(:attachable_content_type)
+        item.attachable_content_type
+      end
+    end
+
+    # True when a content-type is registered as a :fragment type (e.g. snippets),
+    # so its chip should render in the block style.
+    def block_content_type?(content_type)
+      type = registered_type(content_type)
+      type ? type.fragment? : false
+    end
+
+    # The badge label for an item's type, or nil if none is registered.
+    def item_type_label(item)
+      registered_type(item_content_type(item))&.label
+    end
+
+    private
+
+    def registered_type(content_type)
+      return nil if content_type.nil?
+
+      config.registry.match("content-type" => content_type)
+    end
+  end
+end

data/vendor/javascript/lexxy_variables.js

@@ -0,0 +1,122 @@
+import * as Lexxy from "@37signals/lexxy"
+import { $getSelection, $isTextNode, $createTextNode } from "lexical"
+
+const VARIABLE_CONTENT_TYPE = "application/vnd.actiontext.variable"
+
+// Lexxy 0.9.22 anchors prompt replacement on lastIndexOf(trigger[0]), which
+// lands on the second brace of a "{{" trigger and silently aborts the insert.
+// Replace the search with one that scans back until the full string matches.
+// Runs inside the caller's editor.update(), like the original.
+// TODO: upstream to @37signals/lexxy and drop this patch.
+let contentsPatched = false
+
+function patchReplaceTextBackUntil(contents) {
+  if (contentsPatched) return
+  contentsPatched = true
+
+  const proto = Object.getPrototypeOf(contents)
+  proto.replaceTextBackUntil = function(stringToReplace, replacementNodes) {
+    replacementNodes = Array.isArray(replacementNodes) ? replacementNodes : [ replacementNodes ]
+
+    const selection = $getSelection()
+    if (!selection || !selection.isCollapsed()) return
+    const anchorNode = selection.anchor.getNode()
+    if (!$isTextNode(anchorNode)) return
+
+    const fullText = anchorNode.getTextContent()
+    const offset = selection.anchor.offset
+
+    let start = fullText.slice(0, offset).lastIndexOf(stringToReplace[0])
+    while (start !== -1 && !fullText.startsWith(stringToReplace, start)) {
+      start = fullText.slice(0, start).lastIndexOf(stringToReplace[0])
+    }
+    if (start === -1) return
+
+    const cloneFormatting = (text) => $createTextNode(text)
+      .setFormat(anchorNode.getFormat())
+      .setDetail(anchorNode.getDetail())
+      .setMode(anchorNode.getMode())
+      .setStyle(anchorNode.getStyle())
+
+    const textAfter = fullText.slice(start + stringToReplace.length)
+    const nodeBefore = cloneFormatting(fullText.slice(0, start))
+    const nodeAfter = cloneFormatting(textAfter || " ")
+
+    anchorNode.replace(nodeBefore)
+    let previous = nodeBefore
+    for (const node of replacementNodes) {
+      previous.insertAfter(node)
+      previous = node
+    }
+    previous.insertAfter(nodeAfter)
+
+    const cursorOffset = textAfter ? 0 : 1
+    nodeAfter.select(cursorOffset, cursorOffset)
+  }
+}
+
+const ICON = `
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none"
+       stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M7 4a2 2 0 0 0 -2 2v3a2 3 0 0 1 -2 3a2 3 0 0 1 2 3v3a2 2 0 0 0 2 2" />
+    <path d="M17 4a2 2 0 0 1 2 2v3a2 3 0 0 0 2 3a2 3 0 0 0 -2 3v3a2 2 0 0 1 -2 2" />
+  </svg>`
+
+// Adds an "Insert variable" toolbar dropdown fed by the same server-rendered
+// <lexxy-prompt name="variable"> items that power the typed "{{" trigger. The
+// prompt items are produced by the host app, so this extension is content-agnostic.
+export default class VariableExtension extends Lexxy.Extension {
+  get enabled() {
+    return this.editorElement.supportsRichText && this.promptItems.length > 0
+  }
+
+  get allowedElements() {
+    return [ { tag: "span", attributes: [ "data-lexxy-key", "class" ] } ]
+  }
+
+  initializeToolbar(toolbar) {
+    patchReplaceTextBackUntil(this.editorElement.contents)
+
+    const dropdown = document.createElement("lexxy-toolbar-dropdown")
+    dropdown.className = "lexxy-editor__toolbar-dropdown"
+    dropdown.innerHTML = `
+      <button data-dropdown-trigger class="lexxy-editor__toolbar-button lexxy-editor__toolbar-button--chevron"
+              type="button" name="variable" title="Insert variable" aria-haspopup="menu" aria-expanded="false">${ICON}</button>
+      <div data-dropdown-panel role="menu" class="lexxy-variables-menu" aria-label="Variables" hidden></div>`
+
+    const panel = dropdown.querySelector("[data-dropdown-panel]")
+    for (const item of this.promptItems) {
+      panel.appendChild(this.#menuButtonFor(item, dropdown))
+    }
+
+    toolbar.appendChild(dropdown)
+  }
+
+  get promptItems() {
+    return Array.from(this.editorElement.querySelectorAll("lexxy-prompt[name='variable'] lexxy-prompt-item"))
+  }
+
+  #menuButtonFor(item, dropdown) {
+    const button = document.createElement("button")
+    button.type = "button"
+    button.className = "lexxy-variables-menu__item"
+    button.setAttribute("role", "menuitem")
+    button.append(item.querySelector("template[type='menu']").content.cloneNode(true))
+    button.addEventListener("click", (event) => {
+      event.preventDefault()
+      dropdown.close()
+      this.#insert(item)
+    })
+    return button
+  }
+
+  #insert(item) {
+    const template = item.querySelector("template[type='editor']")
+    const attachment = document.createElement("action-text-attachment")
+    attachment.setAttribute("sgid", item.getAttribute("sgid"))
+    attachment.setAttribute("content-type", template.getAttribute("content-type") || VARIABLE_CONTENT_TYPE)
+    attachment.setAttribute("content", template.innerHTML.trim())
+    this.editorElement.contents.insertHtml(attachment.outerHTML)
+  }
+}

data/vendor/stylesheets/lexxy_variables.css

@@ -0,0 +1,115 @@
+/*
+ * Default styles for lexxy-variables. Import this for a working out-of-the-box
+ * look. Override the CSS custom properties (or the classes) to match your app.
+ *
+ * Classes this gem emits:
+ *   .lexxy-variable                 variable token chip (in the editor)
+ *   .lexxy-variable--block          modifier for chips that expand to a block
+ *   .lexxy-variables-menu           the toolbar "insert variable" dropdown panel
+ *   .lexxy-variables-menu__item     a button within that dropdown
+ *   .lexxy-variables-option         option content, cloned into the {{ prompt
+ *   .lexxy-variables-option__header popup AND the toolbar dropdown
+ *   .lexxy-variables-option__name
+ *   .lexxy-variables-option__type
+ *   .lexxy-variables-option__code
+ */
+
+/* Variable token chip. In published pages chips are replaced by resolved values. */
+.lexxy-variable {
+  display: inline-block;
+  padding: 0 0.4em;
+  border-radius: var(--lexxy-variable-radius, 0.375rem);
+  background: var(--lexxy-variable-background, #eef2ff);
+  color: var(--lexxy-variable-color, #3730a3);
+  font-size: 0.875em;
+  white-space: nowrap;
+}
+
+/* For chips that stand in for a rich block (e.g. snippets). Dashed edge hints
+   at "placeholder for a larger block". */
+.lexxy-variable--block {
+  border: var(--lexxy-variable-block-border, 1px dashed #6366f1);
+}
+
+/* Toolbar "insert variable" dropdown. Deliberately a labelled list, not Lexxy's
+   icon-grid toolbar-dropdown-list. */
+.lexxy-variables-menu {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  min-width: var(--lexxy-variables-menu-min-width, 14rem);
+  max-width: var(--lexxy-variables-menu-max-width, min(20rem, 85vw));
+  max-height: var(--lexxy-variables-menu-max-height, 20rem);
+  overflow-y: auto;
+  background: var(--lexxy-variables-menu-background, #fff);
+}
+
+.lexxy-variables-menu__item {
+  display: flex;
+  padding: 0.5rem 0.75rem;
+  border: 0;
+  border-radius: 0.5rem;
+  background: none;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.lexxy-variables-menu__item:hover {
+  background-color: var(--lexxy-variables-menu-item-hover-background, rgba(0, 0, 0, 0.06));
+}
+
+/* Option content, cloned into both the {{ prompt popup (styled by Lexxy) and the
+   toolbar dropdown. Stacks the name over the code and ellipsizes long keys so a
+   narrow popup never wraps mid-token. */
+/* Lexxy caps its prompt popup at 20ch, which wraps names and truncates keys.
+   Raise the cap (Lexxy sets it via :where(), so this plain class wins). */
+.lexxy-prompt-menu {
+  max-inline-size: var(--lexxy-variables-prompt-max-width, min(24rem, 90vw));
+}
+
+.lexxy-variables-option {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.125rem;
+  min-width: 0;
+  max-width: 100%;
+}
+
+.lexxy-variables-option__header {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 0.5rem;
+  width: 100%;
+}
+
+.lexxy-variables-option__name {
+  min-width: 0;
+  font-size: 0.875rem;
+}
+
+/* Type badge (e.g. "Snippet"), shown on the name row only when the list mixes
+   types. Sits to the right without adding a line. */
+.lexxy-variables-option__type {
+  flex-shrink: 0;
+  padding: 0.0625rem 0.375rem;
+  border-radius: 9999px;
+  background: var(--lexxy-variables-option-type-background, rgba(0, 0, 0, 0.06));
+  color: var(--lexxy-variables-option-type-color, #6b7280);
+  font-size: 0.6875rem;
+  line-height: 1.4;
+  white-space: nowrap;
+}
+
+.lexxy-variables-option__code {
+  max-width: 100%;
+  padding: 0;
+  overflow: hidden;
+  background: transparent;
+  font-size: 0.75rem;
+  color: var(--lexxy-variables-option-code-color, #9ca3af);
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: lexxy-variables
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Quinn
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: actiontext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: |
+  Insert and safely resolve variables in Lexxy rich text. The gem gives you an
+  editor button (and a `{{` prompt) for inserting variables, each stored as an
+  Action Text attachment chip rather than literal markup, and resolves each chip
+  to its value at render time. Register new chip types with `register_attachment`:
+  a :value chip resolves to an escaped string, a :fragment 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.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- app/views/lexxy_variables/_prompt.html.erb
+- config/importmap.rb
+- lib/lexxy-variables.rb
+- lib/lexxy_variables.rb
+- lib/lexxy_variables/attachable.rb
+- lib/lexxy_variables/attachment_type.rb
+- lib/lexxy_variables/configuration.rb
+- lib/lexxy_variables/engine.rb
+- lib/lexxy_variables/helper.rb
+- lib/lexxy_variables/pipeline.rb
+- lib/lexxy_variables/placeholder.rb
+- lib/lexxy_variables/registry.rb
+- lib/lexxy_variables/renderers/liquid.rb
+- lib/lexxy_variables/renderers/substitution.rb
+- lib/lexxy_variables/version.rb
+- vendor/javascript/lexxy_variables.js
+- vendor/stylesheets/lexxy_variables.css
+homepage: https://github.com/anquinn/lexxy-variables
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/anquinn/lexxy-variables
+  changelog_uri: https://github.com/anquinn/lexxy-variables/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/anquinn/lexxy-variables/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Insert and safely resolve variables in Lexxy rich text, stored as Action
+  Text attachment chips.
+test_files: []