rails-domternal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5648277022380eaaf7c2e1f337474924ca9bb1758698d2aa552e7d1ba03f9ae7
+  data.tar.gz: 9afacf5e4682b49222aef0c38a7fe0b744bf215268cf6564b7ddbc5616a4e6be
+SHA512:
+  metadata.gz: 99b5adcbf3a02f8b2ed0612084ab67581898d743cc3f9c35bff333a4f19c7c8766d3ad1df6d310ea60d8f9398242ceafa1d987c476bccf3e583dbbd49c5a2298
+  data.tar.gz: 65993a4507b4400482809116c71e611381b2dbcff12cc085f32132e7e69ca8ec7193ec7ca754ccf2bbe0ff9506a0a23f2e41ecaee7cc2b971e515dfec8e69dbb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright 2026 Stefan
+
+MIT License
+
+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,123 @@
+# Rails::Domternal
+
+A [Domternal](https://github.com/domternal/domternal) (ProseMirror-based) rich text editor
+integration for Rails, shaped as a drop-in replacement for ActionText:
+
+- `has_rich_domternal :body` — a dependent rich text model, mirroring `has_rich_text`.
+- `f.domternal_area :body` / `domternal_content post.body` — form and display helpers,
+  mirroring `rich_text_area` / the `<trix-editor>` tag pair.
+- `<domternal-editor>` — a self-registering custom element (no Stimulus dependency) that
+  mounts the editor and syncs a hidden input on every change.
+- Active Storage-backed image uploads, wired through the same
+  `data-direct-upload-url` / `data-blob-url-template` convention ActionText uses.
+- `rails g domternal:install` — detects importmap-rails vs. a Node/Bun bundler and wires up
+  the JS accordingly.
+
+See `demo/` for a working Rails 8 app (importmap + Propshaft) with a `Post` model using
+`has_rich_domternal`.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "rails-domternal"
+```
+
+Then:
+
+```bash
+bundle install
+bin/rails g domternal:install
+bin/rails db:migrate
+```
+
+## Usage
+
+```ruby
+class Post < ApplicationRecord
+  has_rich_domternal :body, extensions: %i[starter_kit image table]
+end
+```
+
+```erb
+<%= form_with model: @post do |form| %>
+  <%= form.domternal_area :body %>
+<% end %>
+
+<%= domternal_content @post.body %>
+```
+
+Configure defaults in `config/initializers/domternal.rb` (generated by the install task) —
+see `Rails::Domternal::Configuration` for the full list of options (default extensions,
+toolbar, theme, sanitizer allowlist, upload limits).
+
+### Extensions
+
+Extensions are referenced by symbolic name (`:starter_kit`, `:image`, `:table`, `:mention`,
+`:markdown`, `:emoji`, `:math`, `:code_block`, `:toc`, `:block_controls`, `:details`),
+resolved server-side by `Rails::Domternal::ExtensionRegistry` (fails fast on typos) and
+lazy-loaded client-side by `app/assets/javascripts/domternal/extensions.js`. Register a
+custom extension with:
+
+```ruby
+Rails::Domternal.extension_registry.register(:my_extension)
+```
+
+```js
+import { registerExtension } from "domternal/extensions"
+registerExtension("my_extension", async () => (await import("my-extension-package")).MyExtension)
+```
+
+### Toolbar modes
+
+`toolbar:` (on `has_rich_domternal`, `domternal_area`, or the global config) accepts:
+
+- `:full` (default) / `:minimal` — a fixed `DomternalToolbar`.
+- `:notion` — no fixed toolbar; instead a selection bubble menu handles inline formatting
+  and a "+" floating menu (shown only via the block handle's button) inserts blocks. Pair
+  this with the `:block_controls` extension, which supplies the drag handle, block context
+  menu, slash command, smart paste, and keyboard reorder:
+
+  ```ruby
+  has_rich_domternal :internal_notes, extensions: %i[starter_kit block_controls toc], toolbar: :notion
+  ```
+- `false` — no chrome at all, just the raw editable surface.
+
+### Content styling
+
+`rails g domternal:install` also generates a baseline typography stylesheet (headings,
+lists, blockquotes, code, tables — none of which Domternal's own theme opinionates on)
+scoped to `.domternal-content`/`<domternal-editor>`, covering both the live editor and
+`domternal_content` read-only output. It's generated once and meant to be edited freely.
+
+By default it autodetects `tailwindcss-rails` (`app/assets/tailwind/application.css`) and
+generates a `@apply`-based version wired into your existing Tailwind build; otherwise it
+generates plain CSS under `app/assets/stylesheets/`. Force either explicitly with
+`rails g domternal:install --stylesheet=tailwind` (or `=css`).
+
+### JavaScript delivery
+
+The install generator pins `@domternal/*` packages from [esm.sh](https://esm.sh) by default
+for importmap apps. Cross-package peer dependencies (`@domternal/core`, `@domternal/pm`) are
+explicitly shared via `?external=` params and a `@domternal/pm/` prefix pin — omitting this
+causes ProseMirror's plugin registry to load twice and crash with "Adding different
+instances of a keyed plugin." For jsbundling/npm apps, the generator installs the real npm
+packages and copies the gem's JS source into `app/javascript/domternal`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test`
+to run the tests. You can also run `bin/console` for an interactive prompt.
+
+To try it against a real app, see `demo/` — it references this gem via a `path:` Gemfile
+entry, so changes to the gem are picked up immediately.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/getrestful/rails-domternal.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/app/assets/javascripts/domternal/direct_upload.js

@@ -0,0 +1,26 @@
+// Bridges the Domternal image extension's `uploadHandler` (a `(file) => Promise<string url>`
+// callback) to Active Storage direct uploads, matching the convention ActionText's
+// rich_textarea_tag uses for its `data-direct-upload-url` / `data-blob-url-template`.
+import { DirectUpload } from "@rails/activestorage"
+
+export function createUploadHandler({ directUploadUrl, blobUrlTemplate, onUploadError }) {
+  return function uploadHandler(file) {
+    return new Promise((resolve, reject) => {
+      const upload = new DirectUpload(file, directUploadUrl)
+
+      upload.create((error, blob) => {
+        if (error) {
+          onUploadError?.(error, file)
+          reject(error)
+          return
+        }
+
+        const url = blobUrlTemplate
+          .replace(":signed_id", blob.signed_id)
+          .replace(":filename", encodeURIComponent(blob.filename))
+
+        resolve(url)
+      })
+    })
+  }
+}

data/app/assets/javascripts/domternal/element.js

@@ -0,0 +1,135 @@
+import { resolveExtensions } from "domternal/extensions"
+import { createUploadHandler } from "domternal/direct_upload"
+
+// <domternal-editor input="..." data-extensions="starter_kit image" data-toolbar="full" ...>
+//
+// Mirrors <trix-editor>: a self-registering custom element that mounts the editor and
+// keeps a linked hidden <input> in sync on every change, so it drops into a form exactly
+// like ActionText's rich_textarea_tag output does.
+export class DomternalEditorElement extends HTMLElement {
+  static get observedAttributes() {
+    return ["editable"]
+  }
+
+  connectedCallback() {
+    if (this._mounted) return
+    this._mounted = true
+    this._mount()
+  }
+
+  disconnectedCallback() {
+    this._toolbar?.destroy()
+    this._bubbleMenu?.destroy()
+    this._floatingMenu?.destroy()
+    this._notionColorPicker?.destroy()
+    this._wrapper?.destroy()
+    this._mounted = false
+  }
+
+  attributeChangedCallback(name, _oldValue, newValue) {
+    if (name === "editable" && this._wrapper) {
+      this._wrapper.setEditable(newValue !== "false")
+    }
+  }
+
+  get input() {
+    const id = this.getAttribute("input")
+    return id ? document.getElementById(id) : null
+  }
+
+  // The wrapper's current HTML, or "" before the editor has mounted.
+  get value() {
+    return this._wrapper?.htmlContent ?? ""
+  }
+
+  async _mount() {
+    const input = this.input
+    if (!input) {
+      throw new Error(`[domternal] <domternal-editor> could not find its input (input="${this.getAttribute("input")}")`)
+    }
+
+    this.classList.add("dm-editor")
+    this.innerHTML = `
+      <div class="domternal-toolbar" part="toolbar"></div>
+      <div class="domternal-surface" part="surface"></div>
+    `
+    const toolbarHost = this.querySelector(".domternal-toolbar")
+    const surfaceHost = this.querySelector(".domternal-surface")
+
+    const extensionNames = (this.dataset.extensions || "starter_kit image").split(/\s+/).filter(Boolean)
+    const uploadHandler = createUploadHandler({
+      directUploadUrl: this.dataset.directUploadUrl,
+      blobUrlTemplate: this.dataset.blobUrlTemplate,
+      onUploadError: (error, file) => this._dispatchUploadError(error, file)
+    })
+
+    const extensions = await resolveExtensions(extensionNames, {
+      image: {
+        uploadHandler,
+        allowedMimeTypes: (this.dataset.allowedMimeTypes || "").split(/\s+/).filter(Boolean) || undefined,
+        maxFileSize: this.dataset.maxFileSize ? Number(this.dataset.maxFileSize) : undefined
+      }
+    })
+
+    const { DomternalEditor, DomternalToolbar, DomternalBubbleMenu, DomternalFloatingMenu, DomternalNotionColorPicker } =
+      await import("@domternal/vanilla")
+
+    this._wrapper = new DomternalEditor(surfaceHost, {
+      extensions,
+      content: input.value,
+      editable: this.getAttribute("editable") !== "false",
+      onUpdate: ({ editor }) => this._syncInput(editor),
+      onFocus: () => this._dispatch("domternal:focus"),
+      onBlur: () => this._dispatch("domternal:blur")
+    })
+
+    const toolbarMode = this.dataset.toolbar || "full"
+    const editor = this._wrapper.editor
+
+    if (toolbarMode === "notion") {
+      // Notion-style: no fixed toolbar. A selection bubble menu handles inline formatting,
+      // a "+" floating menu (triggered only via the block handle's button, not on every
+      // empty paragraph) inserts blocks, and the block handle/slash command/drag-reorder
+      // themselves come from the "block_controls" extensions — add that to `extensions:`
+      // on has_rich_domternal for this to have anything to control.
+      toolbarHost.remove()
+
+      const bubbleHost = document.createElement("div")
+      bubbleHost.className = "dm-bubble-menu"
+      this.appendChild(bubbleHost)
+      this._bubbleMenu = new DomternalBubbleMenu(bubbleHost, { editor })
+
+      const floatingHost = document.createElement("div")
+      floatingHost.className = "dm-floating-menu"
+      this.appendChild(floatingHost)
+      this._floatingMenu = new DomternalFloatingMenu(floatingHost, { editor, requireExplicitTrigger: true })
+
+      this._notionColorPicker = new DomternalNotionColorPicker({ editor })
+    } else if (toolbarMode !== "false") {
+      this._toolbar = new DomternalToolbar(toolbarHost, { editor })
+    } else {
+      toolbarHost.remove()
+    }
+
+    this._dispatch("domternal:initialize")
+  }
+
+  _syncInput(editor) {
+    const input = this.input
+    if (!input) return
+    input.value = editor.getHTML()
+    this._dispatch("domternal:change")
+  }
+
+  _dispatch(type, detail = {}) {
+    this.dispatchEvent(new CustomEvent(type, { bubbles: true, detail: { element: this, ...detail } }))
+  }
+
+  _dispatchUploadError(error, file) {
+    this._dispatch("domternal:upload-error", { error, file })
+  }
+}
+
+if (!customElements.get("domternal-editor")) {
+  customElements.define("domternal-editor", DomternalEditorElement)
+}

data/app/assets/javascripts/domternal/extensions.js

@@ -0,0 +1,56 @@
+// Symbolic extension names -> lazy-loaded Domternal extensions. Kept in sync with
+// Rails::Domternal::ExtensionRegistry (lib/rails/domternal/extension_registry.rb), which
+// validates `has_rich_domternal extensions: [...]` server-side against the same names.
+const registry = new Map([
+  ["starter_kit", async () => (await import("@domternal/core")).StarterKit],
+  ["image", async (options) => {
+    const { Image } = await import("@domternal/extension-image")
+    return Image.configure(options.image || {})
+  }],
+  ["table", async () => {
+    const { Table, TableRow, TableCell, TableHeader } = await import("@domternal/extension-table")
+    return [Table, TableRow, TableCell, TableHeader]
+  }],
+  ["mention", async () => (await import("@domternal/extension-mention")).Mention],
+  ["markdown", async () => (await import("@domternal/extension-markdown")).Markdown],
+  ["emoji", async () => (await import("@domternal/extension-emoji")).Emoji],
+  ["math", async () => {
+    const { MathBlock, MathInline, MathEditing } = await import("@domternal/extension-math")
+    return [MathBlock, MathInline, MathEditing]
+  }],
+  ["code_block", async () => (await import("@domternal/extension-code-block-lowlight")).CodeBlockLowlight],
+  ["toc", async () => {
+    const { UniqueID } = await import("@domternal/core")
+    const { TableOfContents, TableOfContentsBlock } = await import("@domternal/extension-toc")
+    return [UniqueID, TableOfContents, TableOfContentsBlock]
+  }],
+  // The Notion-style block UX (drag handle, block context menu, slash command, smart
+  // paste, keyboard reorder) ships as five separate extensions rather than one bundle.
+  ["block_controls", async () => {
+    const { BlockHandle, BlockContextMenu, KeyboardReorder, SlashCommand, SmartPaste, FloatingMenu } =
+      await import("@domternal/extension-block-controls")
+    return [BlockHandle, BlockContextMenu, KeyboardReorder, SlashCommand, SmartPaste, FloatingMenu]
+  }],
+  ["details", async () => {
+    const { Details, DetailsSummary, DetailsContent } = await import("@domternal/extension-details")
+    return [Details, DetailsSummary, DetailsContent]
+  }],
+])
+
+export function registerExtension(name, loader) {
+  registry.set(name, loader)
+}
+
+export async function resolveExtensions(names, options = {}) {
+  const resolved = await Promise.all(names.map(async (name) => {
+    const loader = registry.get(name)
+    if (!loader) {
+      throw new Error(
+        `[domternal] Unknown extension "${name}". Registered: ${Array.from(registry.keys()).join(", ")}. ` +
+        "Register custom extensions with registerExtension() from \"domternal/extensions\"."
+      )
+    }
+    return loader(options)
+  }))
+  return resolved.flat()
+}

data/app/assets/javascripts/domternal/index.js

@@ -0,0 +1,7 @@
+// Entry point for `import "domternal"`. The install generator pins this whole directory
+// (`pin_all_from ..., under: "domternal"`), so sibling files import each other by bare
+// specifier (e.g. "domternal/extensions") rather than by relative path — Propshaft/Sprockets
+// fingerprint each file independently, and a relative "./extensions.js" import would resolve
+// against the browser's literal (un-fingerprinted) URL and 404.
+export { DomternalEditorElement } from "domternal/element"
+export { registerExtension } from "domternal/extensions"

data/app/helpers/domternal/tag_helper.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+require "action_view/helpers/tags/placeholderable"
+
+module Domternal
+  module TagHelper
+    cattr_accessor(:id, instance_accessor: false) { 0 }
+
+    # Renders a hidden field plus a <domternal-editor> custom element that mounts the
+    # editor and keeps the hidden field's value in sync on every change — the same shape
+    # as ActionText's rich_textarea_tag/<trix-editor> pair.
+    #
+    # #### Options
+    # *   `:extensions` - symbolic extension names (see Rails::Domternal::ExtensionRegistry).
+    #     Defaults to the attribute's `has_rich_domternal` declaration, or
+    #     `Rails::Domternal.configuration.default_extensions`.
+    # *   `:toolbar` - :full, :minimal, :notion, or false. Same defaulting as `:extensions`.
+    # *   `[:data][:direct_upload_url]` - defaults to `rails_direct_uploads_url`.
+    # *   `[:data][:blob_url_template]` - defaults to `rails_service_blob_url(":signed_id", ":filename")`.
+    def domternal_area_tag(name, value = nil, options = {}, &block)
+      value = capture(&block) if value.nil? && block_given?
+      options = options.symbolize_keys
+      form = options.delete(:form)
+      extensions = Array(options.delete(:extensions) || Rails::Domternal.configuration.default_extensions)
+      toolbar = options.key?(:toolbar) ? options.delete(:toolbar) : Rails::Domternal.configuration.toolbar
+
+      options[:input] ||= "domternal_input_#{Domternal::TagHelper.id += 1}"
+      options[:class] ||= "domternal-content"
+
+      options[:data] ||= {}
+      options[:data][:direct_upload_url] ||= main_app.rails_direct_uploads_url
+      options[:data][:blob_url_template] ||= main_app.rails_service_blob_url(":signed_id", ":filename")
+      options[:data][:extensions] ||= extensions.join(" ")
+      options[:data][:toolbar] ||= toolbar.to_s
+      options[:data][:theme] ||= Rails::Domternal.configuration.theme.to_s
+      options[:data][:max_file_size] ||= Rails::Domternal.configuration.max_file_size
+      options[:data][:allowed_mime_types] ||= Rails::Domternal.configuration.allowed_mime_types.join(" ")
+
+      editor_tag = content_tag("domternal-editor", "", options)
+      input_tag = hidden_field_tag(name, value.to_s, id: options[:input], form: form)
+
+      input_tag + editor_tag
+    end
+
+    def domternal_content(value)
+      content_tag(:div, value.to_s.html_safe, class: "domternal-content") # rubocop:disable Rails/OutputSafety -- sanitized by Domternal::RichText before persistence
+    end
+  end
+end
+
+module ActionView::Helpers
+  class Tags::Domternal < Tags::Base
+    include Tags::Placeholderable
+
+    delegate :dom_id, to: ActionView::RecordIdentifier
+
+    def render(&block)
+      options = @options.stringify_keys
+      add_default_name_and_field(options)
+      options["input"] ||= dom_id(object, [options["id"], :domternal_input].compact.join("_")) if object
+
+      attribute_options = object.class.try(:domternal_attributes)&.dig(@method_name.to_sym) || {}
+      options["extensions"] ||= attribute_options[:extensions]
+      options["toolbar"] = attribute_options[:toolbar] unless options.key?("toolbar")
+
+      html_tag = @template_object.domternal_area_tag(
+        options.delete("name"), options.fetch("value") { value }, options.except("value"), &block
+      )
+      error_wrapping(html_tag)
+    end
+  end
+
+  module FormHelper
+    # Returns a domternal_area_tag for the given object/method — see FormBuilder#domternal_area.
+    def domternal_area(object_name, method, options = {}, &block)
+      Tags::Domternal.new(object_name, method, self, options).render(&block)
+    end
+  end
+
+  class FormBuilder
+    # Wraps ActionView::Helpers::FormHelper#domternal_area for form builders:
+    #
+    #     <%= form_with model: @post do |f| %>
+    #       <%= f.domternal_area :body %>
+    #     <% end %>
+    def domternal_area(method, options = {}, &block)
+      @template.domternal_area(@object_name, method, objectify_options(options), &block)
+    end
+  end
+end

data/app/models/domternal/rich_text.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Domternal
+  # Holds the HTML body + Active Storage embeds for a single has_rich_domternal attribute.
+  # Body is stored as the same sanitized HTML the Domternal editor renders/re-parses
+  # (Domternal's `Editor`/`DomternalEditor` accept HTML directly as `content`), so no
+  # separate JSON<->HTML conversion step is needed on the Ruby side.
+  class RichText < ActiveRecord::Base
+    self.table_name = "domternal_rich_texts"
+
+    belongs_to :record, polymorphic: true, touch: true
+    has_many_attached :embeds
+
+    before_validation :sanitize_body
+    before_validation :attach_embedded_blobs
+
+    delegate :blank?, :present?, :empty?, to: :to_plain_text
+
+    def to_s
+      body.to_s.html_safe # rubocop:disable Rails/OutputSafety -- sanitized in #sanitize_body before persistence
+    end
+
+    def to_plain_text
+      body.to_s.gsub(/<[^>]*>/, " ").gsub(/\s+/, " ").strip
+    end
+
+    private
+
+    def sanitize_body
+      return if body.blank?
+
+      config = Rails::Domternal.configuration
+      sanitizer_class = Rails::HTML::Sanitizer.best_supported_vendor.safe_list_sanitizer
+      self.body = sanitizer_class.new.sanitize(
+        body,
+        tags: config.sanitizer_allowed_tags,
+        attributes: config.sanitizer_allowed_attributes
+      )
+    end
+
+    # Blob URLs embedded by the Domternal image extension's upload handler look like
+    # /rails/active_storage/blobs/redirect/:signed_id/:filename (see
+    # app/assets/javascripts/domternal/direct_upload.js). Extracting the signed_id lets us
+    # attach the blob for lifecycle management (dependent: :destroy, backup/admin visibility)
+    # without needing a custom attachment tag/model the way ActionText does.
+    def attach_embedded_blobs
+      return if body.blank?
+
+      signed_ids = body.to_s.scan(%r{/rails/active_storage/blobs/(?:redirect|proxy)/([^/]+)/}).flatten.uniq
+      self.embeds = signed_ids.filter_map { |signed_id| ActiveStorage::Blob.find_signed(signed_id) }
+    end
+  end
+end

data/db/migrate/20260101000000_create_domternal_tables.rb

@@ -0,0 +1,25 @@
+class CreateDomternalTables < ActiveRecord::Migration[7.1]
+  def change
+    primary_key_type, foreign_key_type = primary_and_foreign_key_types
+
+    create_table :domternal_rich_texts, id: primary_key_type do |t|
+      t.string :name, null: false
+      t.text :body
+      t.references :record, null: false, polymorphic: true, index: false, type: foreign_key_type
+
+      t.timestamps
+
+      t.index [:record_type, :record_id, :name], name: "index_domternal_rich_texts_uniqueness", unique: true
+    end
+  end
+
+  private
+
+  def primary_and_foreign_key_types
+    config = Rails.configuration.generators
+    setting = config.options[config.orm][:primary_key_type]
+    primary_key_type = setting || :primary_key
+    foreign_key_type = setting || :bigint
+    [primary_key_type, foreign_key_type]
+  end
+end

data/lib/generators/domternal/install/install_generator.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Domternal
+  module Generators
+    # rails g domternal:install
+    #
+    # Detects whether the host app uses importmap-rails or a Node/Bun bundler
+    # (jsbundling-rails, vite_rails, ...) and wires up the JS accordingly, mirroring
+    # ActionText's install generator (lib/generators/action_text/install/install_generator.rb).
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      source_paths << File.expand_path("../../../../app/assets/javascripts", __dir__)
+
+      # @domternal/vanilla and every @domternal/extension-* package declare @domternal/core
+      # (and, transitively, @domternal/pm — the ProseMirror re-export used for plugin
+      # identity) as peer dependencies. esm.sh only emits real `import` statements for a
+      # peer (rather than inlining its own private copy) when it's passed via `?external=`,
+      # so every consumer below must externalize the same set — otherwise two different
+      # copies of ProseMirror's Plugin/PluginKey classes end up on the page and construction
+      # fails with "Adding different instances of a keyed plugin". @domternal/pm's own
+      # subpaths (state, view, model, ...) are covered by a single prefix pin instead of
+      # being listed one by one.
+      CORE_PACKAGE = "@domternal/core"
+      PM_PACKAGE = "@domternal/pm"
+
+      NPM_PACKAGES = {
+        CORE_PACKAGE => nil,
+        "@domternal/vanilla" => [CORE_PACKAGE],
+        "@domternal/extension-image" => [CORE_PACKAGE, PM_PACKAGE]
+      }.freeze
+
+      OPTIONAL_NPM_PACKAGES = %w[
+        @domternal/extension-table @domternal/extension-mention @domternal/extension-markdown
+        @domternal/extension-emoji @domternal/extension-math @domternal/extension-code-block-lowlight
+        @domternal/extension-toc @domternal/extension-block-controls @domternal/extension-details
+      ].index_with { [CORE_PACKAGE, PM_PACKAGE] }.freeze
+
+      class_option :npm_version, type: :string, default: "latest",
+        desc: "Version/dist-tag used when pinning @domternal/* packages"
+
+      class_option :stylesheet, type: :string, default: nil, enum: %w[css tailwind],
+        desc: "Format for the generated content typography stylesheet. Defaults to " \
+          "autodetecting app/assets/tailwind/application.css (tailwindcss-rails)."
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/domternal.rb"
+      end
+
+      def create_stylesheet
+        template "domternal.css.erb", "app/assets/stylesheets/domternal.css"
+        say <<~INSTRUCTIONS, :green
+          Add `<%= stylesheet_link_tag "domternal" %>` to your layout (next to your
+          application stylesheet tag) to load the Domternal theme and editor styles.
+        INSTRUCTIONS
+
+        create_content_stylesheet
+      end
+
+      def create_migrations
+        rails_command "railties:install:migrations FROM=active_storage,domternal", inline: true
+      end
+
+      def wire_up_javascript
+        if using_importmap?
+          wire_up_importmap
+        elsif using_jsbundling?
+          wire_up_jsbundling
+        else
+          say <<~INSTRUCTIONS, :yellow
+            Could not detect importmap-rails or a package.json — add the Domternal JS
+            yourself. See #{__dir__}/../../../../README.md for both approaches.
+          INSTRUCTIONS
+        end
+      end
+
+      def show_readme
+        say <<~INSTRUCTIONS, :green
+
+          Domternal is installed. Next steps:
+
+            1. bin/rails db:migrate
+            2. In a model:      has_rich_domternal :body
+            3. In a form:       <%= form.domternal_area :body %>
+            4. To render:       <%= domternal_content @post.body %>
+        INSTRUCTIONS
+      end
+
+      private
+
+      def npm_version
+        options["npm_version"]
+      end
+
+      def using_importmap?
+        Pathname(destination_root).join("config/importmap.rb").exist?
+      end
+
+      def using_jsbundling?
+        Pathname(destination_root).join("package.json").exist?
+      end
+
+      def tailwind_stylesheet?
+        options["stylesheet"] == "tailwind" ||
+          (options["stylesheet"].nil? && tailwind_entry_path.exist?)
+      end
+
+      def tailwind_entry_path
+        Pathname(destination_root).join("app/assets/tailwind/application.css")
+      end
+
+      def create_content_stylesheet
+        if tailwind_stylesheet?
+          template "domternal_content.tailwind.css.erb", "app/assets/tailwind/domternal_content.css"
+          import_line = %(@import "./domternal_content.css";\n)
+          if tailwind_entry_path.exist?
+            append_to_file tailwind_entry_path.to_s, import_line unless
+              tailwind_entry_path.read.include?(import_line.strip)
+            say "Generated app/assets/tailwind/domternal_content.css (Tailwind @apply) and " \
+              "imported it into application.css — it's built into your existing tailwind.css, " \
+              "no extra <link> tag needed.", :green
+          else
+            say 'Generated app/assets/tailwind/domternal_content.css — add ' \
+              '`@import "./domternal_content.css";` to your Tailwind entrypoint yourself ' \
+              "(no app/assets/tailwind/application.css found to wire it into automatically).", :yellow
+          end
+        else
+          template "domternal_content.css.erb", "app/assets/stylesheets/domternal_content.css"
+          say 'Add `<%= stylesheet_link_tag "domternal_content" %>` to your layout to load ' \
+            "the generated content typography.", :green
+        end
+      end
+
+      def using_bun?
+        using_jsbundling? && Pathname(destination_root).join("bun.config.js").exist?
+      end
+
+      def wire_up_importmap
+        importmap_path = Pathname(destination_root).join("config/importmap.rb")
+
+        pins = +"\n# rails-domternal\n"
+        pins << %(pin_all_from Rails::Domternal::Engine.root.join("app/assets/javascripts/domternal"), under: "domternal", preload: true\n)
+        pins << %(pin "@rails/activestorage", to: "activestorage.esm.js", preload: true\n) unless
+          importmap_path.read.include?('"@rails/activestorage"')
+
+        pins << %(pin "#{PM_PACKAGE}/", to: "https://esm.sh/#{PM_PACKAGE}@#{npm_version}/"\n)
+
+        all_packages.each do |package, externals|
+          url = "https://esm.sh/#{package}@#{npm_version}"
+          url += "?external=#{externals.join(",")}" if externals.present?
+          preload = package == CORE_PACKAGE
+          pins << %(pin "#{package}", to: "#{url}"#{preload ? "" : ", preload: false"}\n)
+        end
+
+        append_to_file importmap_path.to_s, pins
+        say "Pinned domternal + @domternal/* packages (via esm.sh) in config/importmap.rb", :green
+
+        application_js = Pathname(destination_root).join("app/javascript/application.js")
+        if application_js.exist?
+          append_to_file application_js.to_s, %(import "domternal"\n) unless
+            application_js.read.include?('import "domternal"')
+        else
+          say 'Add `import "domternal"` to your JS entrypoint.', :yellow
+        end
+      end
+
+      def all_packages
+        NPM_PACKAGES.merge(OPTIONAL_NPM_PACKAGES)
+      end
+
+      def wire_up_jsbundling
+        say "Installing JavaScript dependencies", :green
+        packages = (all_packages.keys + ["@domternal/theme"]).map { |p| "#{p}@#{npm_version}" }
+        if using_bun?
+          run "bun add #{packages.join(" ")}"
+        else
+          run "npm install #{packages.join(" ")}"
+        end
+
+        directory "domternal", "app/javascript/domternal"
+
+        destination = Pathname(destination_root)
+        application_js = destination.join("app/javascript/application.js")
+        if application_js.exist?
+          append_to_file application_js.to_s, %(\nimport "domternal/index"\n)
+        else
+          say "Add `import \"domternal/index\"` to your JS entrypoint.", :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/domternal/install/templates/domternal.css.erb

@@ -0,0 +1,27 @@
+/*
+ * Domternal theme — loaded from jsDelivr by default so it works regardless of asset
+ * strategy. If you'd rather bundle it (cssbundling-rails/npm), remove this @import,
+ * `npm add @domternal/theme`, and `@import "@domternal/theme/scss"` from your own
+ * stylesheet entrypoint instead.
+ */
+@import url("https://cdn.jsdelivr.net/npm/@domternal/theme@<%= npm_version %>/dist/domternal-theme.css");
+
+domternal-editor {
+  display: block;
+  border: 1px solid var(--dm-border-color, #d0d5dd);
+  border-radius: 6px;
+}
+
+domternal-editor .domternal-surface {
+  padding: 0.75rem 1rem;
+  min-height: 12rem;
+}
+
+domternal-editor .domternal-toolbar {
+  border-bottom: 1px solid var(--dm-border-color, #d0d5dd);
+}
+
+.domternal-content img {
+  max-width: 100%;
+  height: auto;
+}

data/lib/generators/domternal/install/templates/domternal_content.css.erb

@@ -0,0 +1,56 @@
+/*
+ * Baseline typography for Domternal content — applies to both the live editor surface
+ * (`<domternal-editor>`) and read-only output (`domternal_content`, class="domternal-content").
+ * Generated once by `domternal:install` and not touched again — edit freely.
+ */
+.domternal-content h1, domternal-editor h1 { font-size: 1.875rem; font-weight: 700; line-height: 1.2; margin: 1.5rem 0 0.75rem; }
+.domternal-content h2, domternal-editor h2 { font-size: 1.5rem; font-weight: 700; line-height: 1.25; margin: 1.25rem 0 0.5rem; }
+.domternal-content h3, domternal-editor h3 { font-size: 1.25rem; font-weight: 600; line-height: 1.3; margin: 1rem 0 0.5rem; }
+.domternal-content h4, domternal-editor h4,
+.domternal-content h5, domternal-editor h5,
+.domternal-content h6, domternal-editor h6 { font-size: 1.0625rem; font-weight: 600; margin: 1rem 0 0.5rem; }
+
+.domternal-content p, domternal-editor p { margin: 0.75rem 0; }
+
+.domternal-content ul, domternal-editor ul { list-style: disc; padding-left: 1.5rem; margin: 0.75rem 0; }
+.domternal-content ol, domternal-editor ol { list-style: decimal; padding-left: 1.5rem; margin: 0.75rem 0; }
+.domternal-content li, domternal-editor li { margin: 0.25rem 0; }
+.domternal-content li > ul, domternal-editor li > ul,
+.domternal-content li > ol, domternal-editor li > ol { margin: 0.25rem 0; }
+
+.domternal-content blockquote, domternal-editor blockquote {
+  border-left: 3px solid #d0d5dd;
+  padding-left: 1rem;
+  margin: 0.75rem 0;
+  color: #475467;
+  font-style: italic;
+}
+
+.domternal-content code, domternal-editor code {
+  background: #f2f4f7;
+  border-radius: 4px;
+  padding: 0.125rem 0.375rem;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.875em;
+}
+
+.domternal-content pre, domternal-editor pre {
+  background: #101828;
+  color: #f2f4f7;
+  border-radius: 6px;
+  padding: 0.75rem 1rem;
+  overflow-x: auto;
+  margin: 0.75rem 0;
+}
+.domternal-content pre code, domternal-editor pre code { background: transparent; padding: 0; }
+
+.domternal-content a, domternal-editor a { color: #175cd3; text-decoration: underline; }
+
+.domternal-content img, domternal-editor img { max-width: 100%; height: auto; border-radius: 4px; }
+
+.domternal-content table, domternal-editor table { border-collapse: collapse; width: 100%; margin: 0.75rem 0; }
+.domternal-content th, domternal-editor th,
+.domternal-content td, domternal-editor td { border: 1px solid #d0d5dd; padding: 0.375rem 0.625rem; }
+.domternal-content th, domternal-editor th { font-weight: 600; background: #f9fafb; }
+
+.domternal-content hr, domternal-editor hr { border: none; border-top: 1px solid #d0d5dd; margin: 1.5rem 0; }

data/lib/generators/domternal/install/templates/domternal_content.tailwind.css.erb

@@ -0,0 +1,36 @@
+/*
+ * Baseline typography for Domternal content — applies to both the live editor surface
+ * (`<domternal-editor>`) and read-only output (`domternal_content`, class="domternal-content").
+ * Generated once by `domternal:install` and not touched again — edit freely, e.g. swap the
+ * @apply utilities below for your own design tokens.
+ */
+.domternal-content, domternal-editor {
+  h1 { @apply text-3xl font-bold leading-tight mt-6 mb-3; }
+  h2 { @apply text-2xl font-bold leading-snug mt-5 mb-2; }
+  h3 { @apply text-xl font-semibold mt-4 mb-2; }
+  h4, h5, h6 { @apply text-lg font-semibold mt-4 mb-2; }
+
+  p { @apply my-3; }
+
+  ul { @apply list-disc pl-6 my-3; }
+  ol { @apply list-decimal pl-6 my-3; }
+  li { @apply my-1; }
+  li > ul, li > ol { @apply my-1; }
+
+  blockquote { @apply border-l-4 border-gray-300 pl-4 my-3 text-gray-600 italic; }
+
+  code { @apply bg-gray-100 rounded px-1.5 py-0.5 font-mono text-sm; }
+
+  pre { @apply bg-gray-900 text-gray-100 rounded-md px-4 py-3 my-3 overflow-x-auto; }
+  pre code { @apply bg-transparent p-0; }
+
+  a { @apply text-blue-700 underline; }
+
+  img { @apply max-w-full h-auto rounded; }
+
+  table { @apply border-collapse w-full my-3; }
+  th, td { @apply border border-gray-300 px-2.5 py-1.5; }
+  th { @apply font-semibold bg-gray-50; }
+
+  hr { @apply border-t border-gray-300 my-6; }
+}

data/lib/generators/domternal/install/templates/initializer.rb

@@ -0,0 +1,24 @@
+# Configuration for rails-domternal, a Domternal (https://github.com/domternal/domternal)
+# editor integration shaped like ActionText. See Rails::Domternal::Configuration for the
+# full list of options.
+Rails::Domternal.configure do |config|
+  # Symbolic extension keys resolved client-side by app/assets/javascripts/domternal/extensions.js
+  # and validated server-side by Rails::Domternal::ExtensionRegistry. Override per-attribute with
+  # `has_rich_domternal :body, extensions: %i[starter_kit image table]`.
+  # config.default_extensions = %i[starter_kit image]
+
+  # :full, :minimal, :notion, or false — overridable per has_rich_domternal/domternal_area call.
+  # config.toolbar = :full
+
+  # :light, :dark, or :auto
+  # config.theme = :light
+
+  # config.allowed_mime_types = %w[image/png image/jpeg image/gif image/webp image/svg+xml image/avif]
+  # config.max_file_size = 10.megabytes
+
+  # Tags/attributes let through the safelist sanitizer applied to incoming bodies before they're
+  # persisted. Widen this if you enable extensions (e.g. extension-table, extension-details) that
+  # introduce markup not covered by the defaults.
+  # config.sanitizer_allowed_tags += %w[]
+  # config.sanitizer_allowed_attributes += %w[]
+end

data/lib/rails/domternal/attribute.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Rails
+  module Domternal
+    module Attribute
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Declares a dependent Domternal::RichText association, mirroring ActionText's
+        # `has_rich_text`. Example:
+        #
+        #     class Post < ApplicationRecord
+        #       has_rich_domternal :body, extensions: %i[starter_kit image table], toolbar: :full
+        #     end
+        #
+        #     post.body = "<p>Hello <strong>World</strong>!</p>"
+        #     post.body.to_s
+        #
+        # `extensions:` and `toolbar:` are per-attribute overrides of
+        # Rails::Domternal.configuration.default_extensions/toolbar; both are rendered into
+        # the `domternal_area` form tag's data attributes so the client knows what to load.
+        def has_rich_domternal(name, extensions: nil, toolbar: nil)
+          extensions&.each { |extension| Rails::Domternal.extension_registry.fetch!(extension) }
+
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{name}
+              rich_domternal_#{name} || build_rich_domternal_#{name}
+            end
+
+            def #{name}?
+              rich_domternal_#{name}.present?
+            end
+
+            def #{name}=(body)
+              self.#{name}.body = body
+            end
+          CODE
+
+          has_one :"rich_domternal_#{name}", -> { where(name: name) },
+            class_name: "Domternal::RichText", as: :record, inverse_of: :record,
+            autosave: true, dependent: :destroy
+
+          scope :"with_rich_domternal_#{name}", -> { includes("rich_domternal_#{name}") }
+
+          domternal_attributes[name.to_sym] = {
+            extensions: extensions || Rails::Domternal.configuration.default_extensions,
+            toolbar: toolbar.nil? ? Rails::Domternal.configuration.toolbar : toolbar
+          }
+        end
+
+        # Eager loads all dependent Domternal::RichText models in bulk.
+        def with_all_rich_domternal
+          includes(domternal_association_names)
+        end
+
+        def domternal_association_names
+          reflect_on_all_associations(:has_one).collect(&:name).select { |n| n.start_with?("rich_domternal_") }
+        end
+
+        # Options passed to `has_rich_domternal`, keyed by attribute name. Read by
+        # Domternal::TagHelper to fill in the `domternal_area` tag's config without the
+        # caller having to repeat them.
+        def domternal_attributes
+          @domternal_attributes ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/rails/domternal/configuration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rails
+  module Domternal
+    class Configuration
+      # Symbolic extension keys resolved client-side by app/assets/javascripts/domternal/extensions.js
+      attr_accessor :default_extensions
+
+      # :full, :minimal, :notion, or false. :notion swaps the fixed toolbar for a
+      # selection bubble menu + a "+" floating menu, matching the block handle/slash
+      # command UI the :block_controls extension adds — pair the two.
+      attr_accessor :toolbar
+
+      # :light, :dark, or :auto
+      attr_accessor :theme
+
+      # :importmap, :jsbundling, or :cdn — how the install generator wires up JS. Informational
+      # at runtime; only the generator branches on it.
+      attr_accessor :asset_strategy
+
+      # npm dist-tag/version used when pinning packages from a CDN (importmap/:cdn strategies).
+      attr_accessor :npm_version
+
+      attr_accessor :allowed_mime_types
+      attr_accessor :max_file_size
+
+      # HTML tags/attributes allowed through the safelist sanitizer applied to incoming bodies.
+      attr_accessor :sanitizer_allowed_tags
+      attr_accessor :sanitizer_allowed_attributes
+
+      def initialize
+        @default_extensions = %i[starter_kit image]
+        @toolbar = :full
+        @theme = :light
+        @asset_strategy = :importmap
+        @npm_version = "latest"
+        @allowed_mime_types = %w[image/png image/jpeg image/gif image/webp image/svg+xml image/avif]
+        @max_file_size = 10.megabytes
+
+        @sanitizer_allowed_tags = %w[
+          p br div span
+          h1 h2 h3 h4 h5 h6
+          strong em b i u s del ins mark sub sup code pre
+          ul ol li blockquote
+          a img figure figcaption
+          table thead tbody tr th td
+          hr details summary
+        ]
+        @sanitizer_allowed_attributes = %w[
+          href src alt title width height loading crossorigin
+          colspan rowspan align style class data-type data-id data-label
+        ]
+      end
+    end
+  end
+end

data/lib/rails/domternal/engine.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module Rails
+  module Domternal
+    class Engine < ::Rails::Engine
+      isolate_namespace Rails::Domternal
+      engine_name "domternal"
+
+      config.domternal = Rails::Domternal.configuration
+
+      initializer "domternal.assets" do |app|
+        if app.config.respond_to?(:assets)
+          app.config.assets.paths << root.join("app/assets/javascripts")
+          app.config.assets.precompile += %w[domternal/index.js]
+        end
+      end
+
+      initializer "domternal.active_storage" do
+        require "active_storage/engine"
+      end
+
+      initializer "domternal.helper" do
+        ActiveSupport.on_load(:action_controller_base) do
+          helper ::Domternal::TagHelper
+        end
+      end
+
+      initializer "domternal.attribute" do
+        ActiveSupport.on_load(:active_record) do
+          include Rails::Domternal::Attribute
+        end
+      end
+    end
+  end
+end

data/lib/rails/domternal/extension_registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rails
+  module Domternal
+    # Ruby-side mirror of app/assets/javascripts/domternal/extensions.js — kept in sync
+    # so `has_rich_domternal extensions: [...]` can fail fast on typos instead of only
+    # erroring in the browser console.
+    class ExtensionRegistry
+      UnknownExtensionError = Class.new(StandardError)
+
+      def initialize
+        @known = %i[
+          starter_kit image table mention markdown emoji math
+          code_block toc block_controls details
+        ].to_set
+      end
+
+      def register(name)
+        @known << name.to_sym
+      end
+
+      def known?(name)
+        @known.include?(name.to_sym)
+      end
+
+      def fetch!(name)
+        unless known?(name)
+          raise UnknownExtensionError,
+            "Unknown Domternal extension #{name.inspect}. Known extensions: #{@known.to_a.sort.inspect}. " \
+            "Register custom ones with Rails::Domternal.extension_registry.register(:my_extension) " \
+            "and app/assets/javascripts/domternal/extensions.js's registerExtension()."
+        end
+        name.to_sym
+      end
+    end
+  end
+end

data/lib/rails/domternal/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rails
+  module Domternal
+    VERSION = "0.1.0"
+  end
+end

data/lib/rails/domternal.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "domternal/version"
+require_relative "domternal/configuration"
+require_relative "domternal/extension_registry"
+require_relative "domternal/attribute"
+
+module Rails
+  module Domternal
+    class Error < StandardError; end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def extension_registry
+        @extension_registry ||= ExtensionRegistry.new
+      end
+    end
+  end
+end
+
+require_relative "domternal/engine" if defined?(::Rails::Engine)

data/lib/rails-domternal.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "rails/domternal"

data/sig/rails/domternal.rbs

@@ -0,0 +1,6 @@
+module Rails
+  module Domternal
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: rails-domternal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stefan
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Wraps the Domternal (ProseMirror-based) editor with a has_rich_domternal
+  model attribute, a domternal_area form helper, and Active Storage-backed image uploads
+  so it can be adopted with the same shape as ActionText.
+email:
+- stefan@getrestful.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/domternal/direct_upload.js
+- app/assets/javascripts/domternal/element.js
+- app/assets/javascripts/domternal/extensions.js
+- app/assets/javascripts/domternal/index.js
+- app/helpers/domternal/tag_helper.rb
+- app/models/domternal/rich_text.rb
+- db/migrate/20260101000000_create_domternal_tables.rb
+- lib/generators/domternal/install/install_generator.rb
+- lib/generators/domternal/install/templates/domternal.css.erb
+- lib/generators/domternal/install/templates/domternal_content.css.erb
+- lib/generators/domternal/install/templates/domternal_content.tailwind.css.erb
+- lib/generators/domternal/install/templates/initializer.rb
+- lib/rails-domternal.rb
+- lib/rails/domternal.rb
+- lib/rails/domternal/attribute.rb
+- lib/rails/domternal/configuration.rb
+- lib/rails/domternal/engine.rb
+- lib/rails/domternal/extension_registry.rb
+- lib/rails/domternal/version.rb
+- sig/rails/domternal.rbs
+homepage: https://github.com/getrestful/rails-domternal
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/getrestful/rails-domternal
+  source_code_uri: https://github.com/getrestful/rails-domternal
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Domternal rich text editor with notion style UI and integration for Rails,
+  as a drop-in ActionText replacement.
+test_files: []