prosemirror 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c411a333e40240328c4e19d8b5f8870c0f90bad21573b6fc68b503901d2f0b7
-  data.tar.gz: d13dcd8a9fb6001183010cc73c82a6541d6466214fcf59947d01bb5a4e2c0c21
+  metadata.gz: 83299630ad74178efaf62c0e40968ef3e1a085ddba12d9b50684c05b1f27f057
+  data.tar.gz: fbb545591e530721443848ce7f2044aa62338437d2926d480f0baa0f5ef2ef3d
 SHA512:
-  metadata.gz: '0311783f814484b6f3e682c07228590084a97f9a1e555bdc9dbbb61acfd5d88c3ae4688c2b6afada4f1683395df878e0c88f97e4f673dfe106250e017f21d532'
-  data.tar.gz: 35b83befa7e82312b910152784800192d958151497436abba2d279b8d80929430a7062fe3c003f5ec84c3b713a0b8c12693412767fd863f51588d5ba625a3af1
+  metadata.gz: bdcd3ce77eed14f095685bd6d47d7d3d1d7ee0975f869845268487f4e91221dd22b721801ac91c7db3913222c638b1881e0396148bf266a3081155e905cfe011
+  data.tar.gz: af476e5844149a351f8fc4d6b3575cdc256ce23d4ca46c3e4c345ca10700c916f4a7dfd08b4769341e15ea19435c882a13e1bf1a6f50f3df4e7a1701ef478698

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [1.1.0] - 2026-10-26
+
+- `Document#truncate(length, omission: "…")` gives a shorter document, for previews: about that many characters of text, cut at the end of a word, keeping the marks and blocks the text is in.
+- `Document#headings` lists the headings, for a table of contents, with an id unique in the document, made from their text (with Rails' `parameterize` when ActiveSupport is loaded), and `to_html(heading_ids: true)` renders the same ids on them. A heading's own id is kept. The cookbook's heading anchors recipe becomes a table of contents recipe.
+- Tiptap's TextStyle mark, `Prosemirror::Marks::TextStyle`, with the attributes of its TextStyleKit (`color`, `backgroundColor`, `fontFamily`, `fontSize`, `lineHeight`), rendered as a span's `style` and imported from it. As in Tiptap, it isn't in the default schema: add it with `Schema.tiptap.with(Prosemirror::Marks::TextStyle)`. Unsafe CSS values, like `url()`, are invalid.
+- Mark types declare a `priority`, as in Tiptap: the schema orders marks by priority, then as listed, so a mark added with `with` takes its place among the others. Tiptap's link has 1000, and its TextStyle 101.
+- `to_json` raised `JSON::NestingError` for documents nested more than about 50 levels deep, and HTML and Markdown import gave documents up to about 190 levels deep, more than `Prosemirror.parse` accepts. Import now flattens nodes from 90 levels deep, and `to_json` writes documents as deep as `parse` reads: 100 levels.
+- Table cells render their `colwidth` as an attribute, as Tiptap does, so that HTML import gives it back: it was lost. An empty `colwidth` attribute imports as nil, as in Tiptap, rather than an empty array.
+- Markdown import replaces U+0000 with U+FFFD, as the CommonMark spec requires. It was kept, and dropped once the document was rendered to HTML.
+- HTML import reads Tiptap's YouTube and Twitch markup only around a YouTube or Twitch URL. With another URL, it gave an embed that rendered nothing.
+
 ## [1.0.0] - 2026-10-25
 
 ### Public API

data/COOKBOOK.md

@@ -65,30 +65,32 @@ end
 
 Items with several paragraphs or a nested list, and items left empty, render as before.
 
-## Heading anchors
+## Table of contents
 
-To link to a section, give each heading an `id` made from its text, unless the document already has one:
+List the headings as links, and render the document with the same ids on its headings:
 
 ```ruby
-class Heading < Prosemirror::Nodes::Heading
-  prop :id, _String?
-
-  def view_template(&)
-    tag(:"h#{@level}", id: @id || slug, &)
+class TableOfContents < Phlex::HTML
+  def initialize(document)
+    @document = document
   end
 
-  private
-
-  # "Café & co" becomes "cafe-co". In Rails, `node.text_content.parameterize` does the same.
-  def slug
-    slug = node.text_content.unicode_normalize(:nfkd).gsub(/\p{Mn}/, "").downcase.gsub(/[^a-z0-9]+/, "-")
-    slug = slug.delete_prefix("-").delete_suffix("-")
-    slug unless slug.empty?
+  def view_template
+    nav do
+      ul do
+        @document.headings.each do |heading|
+          li(class: "level-#{heading[:level]}") { a(href: "##{heading[:id]}") { heading[:text] } }
+        end
+      end
+    end
   end
 end
+
+render TableOfContents.new(doc)
+render doc.to_phlex(heading_ids: true)
 ```
 
-A node doesn't see the rest of the document, so two headings with the same text get the same `id`.
+Ids are unique in the document: two headings with the same text get `setup` and `setup-2`.
 
 ## Quotes with their author
 
@@ -170,3 +172,23 @@ Prosemirror::Schema.tiptap(
   end
 )
 ```
+
+## Word count
+
+Count the words of a document from its text. A hyphenated word or an elision, like `well-known` or `l’été`, counts as one word, as in word processors:
+
+```ruby
+WORD = /[[:alnum:]]+(?:[-'’][[:alnum:]]+)*/
+
+def word_count(document)
+  document.to_text.scan(WORD).size
+end
+```
+
+To leave code blocks out of the count, remove them first:
+
+```ruby
+word_count(document.transform { |node| (node.type == :code_block) ? nil : node })
+```
+
+Languages written without spaces between words, like Chinese or Japanese, need a segmenter instead.

data/README.md

@@ -53,6 +53,15 @@ doc.select { |node| node in { type: :heading, attrs: { level: 1 } } }
 doc.content.first.text_content
 ```
 
+`headings` lists the headings, for a table of contents, with an id unique in the document. `to_html(heading_ids: true)`, or `to_phlex(heading_ids: true)`, renders the same ids on the headings, so the links work:
+
+```ruby
+doc.headings  # => [{level: 2, text: "Café & co", id: "cafe-co"}, {level: 3, text: "Setup", id: "setup"}]
+doc.to_html(heading_ids: true)  # => "<h2 id=\"cafe-co\">Café &amp; co</h2>…"
+```
+
+Ids come from the heading's text, with a number when two are the same (`setup-2`). A heading's own id, an attribute its type declares or one the editor saved, like Tiptap's UniqueID extension, is kept.
+
 ## Transforming documents
 
 `transform` builds a new document from a block called with each node. The block returns the node to keep, another node, an array of nodes to put in its place, or nil to remove it:
@@ -79,6 +88,13 @@ end
 doc.check  # raises "doc.content[0]: invalid content for blockquote: paragraph text"
 ```
 
+`truncate` gives a shorter document, for previews and listings: about that many characters of text, cut at the end of a word, followed by `omission` (`"…"` by default). It keeps the marks and blocks the text is in, and leaves out what comes after the cut. Trailing punctuation is dropped before the omission, and a block isn't started for less than one of its words. A document short enough is returned as it is.
+
+```ruby
+doc.truncate(200).to_html                 # => "<p>The first <strong>words</strong>…</p>"
+doc.truncate(200, omission: " [more]").to_text
+```
+
 ## HTML import
 
 HTML import uses [Herb](https://herb-tools.dev)'s parser, which never raises on malformed HTML. Add it to your Gemfile:
@@ -132,7 +148,7 @@ doc.to_markdown(html: true)  # underline, highlight, subscript, superscript and
 ```
 
 - Text is escaped, so that it reads back as text: `*`, `_`, `[`, a `#` or `-` that would start a block, HTML-like `<b>`, and URLs that GitHub would turn into links.
-- Markdown has no syntax for underline, highlight, subscript, superscript, image sizes or mentions: by default, only their text or image is written, like `@Ada` for a mention. With `html: true`, they are written as HTML.
+- Markdown has no syntax for underline, highlight, subscript, superscript, text styles, image sizes or mentions: by default, only their text or image is written, like `@Ada` for a mention. With `html: true`, they are written as HTML.
 - Emphasis that CommonMark can't write where it is, like bold on a comma between two letters, is dropped and its text kept.
 - Tables are written as GFM tables. A cell's paragraphs and line breaks are joined with `<br>`, and its other blocks, like lists, are written as HTML.
 - Details are written as `<details>` HTML, as on GitHub, with their content in Markdown.
@@ -195,6 +211,12 @@ strict = Prosemirror.schema.with_options(strict: true)
 Prosemirror::Schema.tiptap(text_align: true)
 ```
 
+Tiptap's TextStyle mark isn't in its StarterKit, nor in `Schema.tiptap`: add `Prosemirror::Marks::TextStyle`, with the attributes of its TextStyleKit: `color`, `backgroundColor`, `fontFamily`, `fontSize` and `lineHeight`, rendered as a span's `style`. HTML import reads them from spans' styles, merging nested spans as Tiptap does. Unlike Tiptap, a span without any of them gets no mark, and values that could load or run something, like `url()`, are invalid.
+
+```ruby
+Prosemirror::Schema.tiptap.with(Prosemirror::Marks::TextStyle)
+```
+
 YouTube and Twitch embeds store the video's URL in `src`, and render an iframe of its embed URL, built from the video's id: other URLs render nothing. HTML import reads Tiptap's markup, and also iframes of embed URLs without it. Twitch only plays embeds on the domain they name, so set it in a subclass, as Tiptap's `parent` option. YouTube's `nocookie` option is a subclass too:
 
 ```ruby
@@ -331,6 +353,14 @@ BUNDLE_GEMFILE=benchmark/Gemfile bundle install
 BUNDLE_GEMFILE=benchmark/Gemfile bundle exec ruby benchmark/run.rb
 ```
 
+`rake fuzz` imports random HTML and Markdown, made by mutating the test fixtures, for a minute. It reports inputs that raise, give an invalid document, or don't survive rendering and importing again, each shrunk to a small example to add as a fixture:
+
+```sh
+SECONDS=600 bundle exec rake fuzz   # longer
+SEED=1234 bundle exec rake fuzz     # repeat a run
+STRICT=1 bundle exec rake fuzz      # a round trip must give the same document
+```
+
 To install this gem onto your local machine, run `bundle exec rake install`.
 
 To release a new version, update the version number in `version.rb` and the changelog, and merge them into main. Then tag the version and push the tag:

data/TYPES.md

@@ -60,8 +60,9 @@ Type names are snake_case Symbols in Ruby. On input, camelCase works too (`image
 | `excludes "_"` | marks of the same type | The marks this one can't be combined with: names or groups, `"_"` for all. A link excludes other links, and Tiptap's `code` excludes all marks. |
 | `spanning false` | true | Render one element per text node, instead of one for adjacent nodes with the same mark. |
 | `code` | false | The mark holds code, as ProseMirror's `code`. Not used by this gem yet. |
+| `priority 101` | 100 | The mark's place in the schema, as Tiptap's `priority`: higher first. Tiptap's link has 1000, and its TextStyle 101. |
 
-The order of marks in the schema sorts the marks of a node, and nests their elements: the first mark is the outermost element.
+The order of marks in the schema sorts the marks of a node, and nests their elements: the first mark is the outermost element. Marks are ordered by priority, then in the order they're listed and added with `with`, so a mark added with `with` takes the same place as in Tiptap when it declares Tiptap's priority.
 
 ## Content expressions
 
@@ -122,6 +123,7 @@ Without `view_template`, the content is rendered without a wrapping element. The
 | `render_content(nodes)` | Renders any list of nodes, with their marks, for example only some of the node's children. |
 | `safe_url(url)` | The URL after the schema's `resolve_url`, when its scheme is allowed, or nil. Use it for every URL from the document. |
 | `prosemirror_schema` | The schema of the document being rendered. |
+| `heading_id` | In a heading type, its id from `Document#headings`, when the document is rendered with `heading_ids: true`, or nil. A subclass of the built-in heading renders it with `id: heading_id`. |
 
 Phlex escapes text and attribute values, but doesn't check URLs: pass them through `safe_url`.
 

data/lib/prosemirror/document.rb

@@ -33,17 +33,38 @@ module Prosemirror
       end.to_a
     end
 
-    # The document as HTML. The string is `html_safe` when ActiveSupport is loaded.
-    def to_html
-      html = to_phlex.call
+    # The headings, for a table of contents, with their level, their text, and an id unique in the document:
+    #
+    #   doc.headings # => [{level: 2, text: "Café & co", id: "cafe-co"}, {level: 2, text: "Café & co", id: "cafe-co-2"}]
+    #
+    # A heading's own `id`, an attribute its type declares or one the editor added, like Tiptap's UniqueID
+    # extension, is its id. Others get one from their text. `to_html(heading_ids: true)` renders the same ids.
+    def headings
+      heading_ids.map { |node, id| {level: node.attrs[:level], text: node.text_content, id:} }
+    end
+
+    # The document as HTML, with `heading_ids: true` the ids of `headings` on the headings. The string is
+    # `html_safe` when ActiveSupport is loaded.
+    def to_html(heading_ids: false)
+      html = to_phlex(heading_ids:).call
       html.respond_to?(:html_safe) ? html.html_safe : html
     end
 
     # A Phlex component rendering the document, to render it inside another Phlex component:
     #
     #   render doc.to_phlex
-    def to_phlex
-      HTMLRenderer.new(self)
+    def to_phlex(heading_ids: false)
+      HTMLRenderer.new(self, heading_ids:)
+    end
+
+    # The id of each heading node, in order. Keyed by identity: two headings with the same text are equal.
+    # @api private
+    def heading_ids
+      nodes = select { |node| schema.node_type(node.type)&.<=(Nodes::Heading) }
+      taken = nodes.filter_map { |node| own_id(node) }.to_set
+      nodes.each_with_object({}.compare_by_identity) do |node, ids|
+        ids[node] = own_id(node) || unique_id(slug(node.text_content), taken)
+      end
     end
 
     # Lets Rails render the document in ERB templates and ViewComponents: `<%= render doc %>`.
@@ -71,8 +92,9 @@ module Prosemirror
       to_h
     end
 
-    def to_json(*)
-      to_h.to_json(*)
+    # As deep as `Prosemirror.parse` accepts: the JSON gem's default limit allows about 50 nodes.
+    def to_json(*args)
+      args.empty? ? JSON.generate(to_h, max_nesting: JSONParser::MAX_NESTING) : to_h.to_json(*args)
     end
 
     def text_content
@@ -96,6 +118,31 @@ module Prosemirror
       Document.new(Transformer.new(schema, &).call(root), schema: schema)
     end
 
+    # A shorter document, for previews: about `length` characters of text, cut at the end of a word, with
+    # `omission` after it. It keeps its structure: the marks and blocks the text is in, and what comes before
+    # the cut. What comes after is left out. The document itself when its text is short enough.
+    #
+    #   doc.truncate(200).to_html # => "<p>The first <strong>words</strong>…</p>"
+    def truncate(length, omission: "…")
+      cut_index, cut_text = cut(length)
+      return self unless cut_index
+
+      seen = 0
+      content = Transformer.new(schema, report: false) do |node|
+        if node.text?
+          seen += 1
+          if seen - 1 < cut_index then node
+          elsif seen - 1 == cut_index then node.with(text: cut_text + omission)
+          end
+        elsif seen > cut_index && (node.content.empty? || schema.node_type(node.type)&.leaf?)
+          nil
+        else
+          node
+        end
+      end.call(root)
+      Document.new(content, schema: schema)
+    end
+
     # Raises InvalidDocument for the first problem with the schema: an unknown node or mark type, invalid
     # attributes, content that doesn't match a content expression, or marks a node doesn't allow. Returns
     # the document.
@@ -122,6 +169,58 @@ module Prosemirror
 
     private
 
+    # Where to cut the text to keep about `length` characters, at the end of a word: the index of the last
+    # text node to keep, and its kept text, without trailing spaces and punctuation. Nil when the text is
+    # short enough. A first word longer than `length` is cut inside it.
+    def cut(length)
+      texts = select(&:text?)
+      remaining = length
+      texts.each_with_index do |node, index|
+        text = node.text
+        if text.length <= remaining
+          remaining -= text.length
+          next unless remaining.zero? && index < texts.size - 1
+
+          return [index, trim_end(text)]
+        end
+
+        word_end = text[0, remaining + 1].rindex(/\s/)
+        kept = word_end ? trim_end(text[0, word_end]) : ""
+        return [index, kept] unless kept.empty?
+        return [index, text[0, remaining]] if index.zero?
+
+        return [index - 1, trim_end(texts[index - 1].text)]
+      end
+      nil
+    end
+
+    def trim_end(text) = text.sub(/[[:space:][:punct:]]+\z/, "")
+
+    def own_id(node)
+      id = node.attrs[:id] || node.unknown_attrs["id"]
+      id if id.is_a?(String) && !id.empty?
+    end
+
+    # "Café & co" becomes "cafe-co", with Rails' `parameterize` when ActiveSupport is loaded, so that the
+    # app's I18n transliteration rules apply. Text without letters or digits becomes "section".
+    def slug(text)
+      slug = if defined?(ActiveSupport::Inflector.parameterize)
+        ActiveSupport::Inflector.parameterize(text)
+      else
+        text.unicode_normalize(:nfkd).gsub(/\p{Mn}/, "").downcase.gsub(/[^a-z0-9]+/, "-").delete_prefix("-").delete_suffix("-")
+      end
+      slug.empty? ? "section" : slug
+    end
+
+    # The slug, or with a number after it when it's taken: "setup", "setup-2".
+    def unique_id(slug, taken)
+      id = slug
+      number = 1
+      id = "#{slug}-#{number += 1}" while taken.include?(id)
+      taken << id
+      id
+    end
+
     def add_urls(urls, type, attrs)
       type&.url_attributes&.each do |name|
         value = attrs[name]

data/lib/prosemirror/extensions/text_align.rb

@@ -27,7 +27,7 @@ module Prosemirror
       class Heading < Nodes::Heading
         include TextAlign
 
-        def view_template(&) = tag(:"h#{@level}", style: text_align_style, &)
+        def view_template(&) = tag(:"h#{@level}", id: heading_id, style: text_align_style, &)
       end
     end
   end

data/lib/prosemirror/html_parser.rb

@@ -19,6 +19,11 @@ module Prosemirror
     IGNORE_TAGS = %w[head noscript object script style title].to_set.freeze
     LIST_TAGS = %w[ol ul].to_set.freeze
 
+    # How many nodes can be open before elements stop opening new ones, and are unwrapped like elements without
+    # a rule, so that documents aren't deeper than JSON documents can be. The rest leaves room for the nodes
+    # that wrap content where it doesn't fit, like a table's row and cell.
+    MAX_OPEN = JSONParser::MAX_DEPTH - 10
+
     PRESERVE_WS = 1
     PRESERVE_WS_FULL = 2
 
@@ -284,7 +289,7 @@ module Prosemirror
 
         if rule ? rule.ignore : IGNORE_TAGS.include?(dom.name)
           ignore_fallback(dom, marks)
-        elsif !rule || rule.skip || rule.close_parent
+        elsif !rule || rule.skip || rule.close_parent || (rule.node? && !match.type.leaf? && @nodes.size >= MAX_OPEN)
           add_element_without_rule(dom, marks, rule, top)
         else
           inner_marks = read_styles(dom, marks)

data/lib/prosemirror/html_renderer.rb

@@ -7,15 +7,18 @@ module Prosemirror
   class HTMLRenderer < Phlex::HTML
     include Rendering
 
-    def initialize(document)
+    def initialize(document, heading_ids: false)
       super()
       @document = document
+      @heading_ids = heading_ids
       @_prosemirror_schema = document.schema
     end
 
-    # The document's URLs are resolved at once, with the schema's `resolve_urls`, for each rendering.
+    # The document's URLs are resolved at once, with the schema's `resolve_urls`, for each rendering, and so
+    # are its heading ids, which need the whole document to be unique.
     def view_template
       @_prosemirror_urls = prosemirror_schema.resolve_urls(@document.urls) if prosemirror_schema.resolve_urls?
+      @_prosemirror_heading_ids = @document.heading_ids if @heading_ids
       render_content([@document.root])
     end
   end

data/lib/prosemirror/json_parser.rb

@@ -7,6 +7,9 @@ module Prosemirror
   # @api private
   class JSONParser
     MAX_DEPTH = 100
+    # The JSON nesting of a document MAX_DEPTH deep: a node at that depth is an object nested 2 × MAX_DEPTH + 1
+    # deep, and its marks, a mark, the mark's attributes and an array in them add 4.
+    MAX_NESTING = (MAX_DEPTH * 2) + 5
     EMPTY = [].freeze
 
     def initialize(schema)
@@ -19,7 +22,7 @@ module Prosemirror
 
     def parse(json)
       # Frozen strings go into nodes without being copied.
-      hash = json.is_a?(String) ? JSON.parse(json, max_nesting: (MAX_DEPTH * 2) + 2, freeze: true) : json
+      hash = json.is_a?(String) ? JSON.parse(json, max_nesting: MAX_NESTING, freeze: true) : json
       raise ArgumentError, "expected a Hash or a JSON String, got #{json.class}" unless hash.is_a?(Hash)
 
       @path = ["doc"]

data/lib/prosemirror/mark_type.rb

@@ -45,6 +45,14 @@ module Prosemirror
         inherited_setting(:@group, [])
       end
 
+      # The mark's place in its schema, as Tiptap's `priority`: marks with a higher priority come first, and
+      # marks with the same priority keep the schema's order. Defaults to 100.
+      def priority(value = nil)
+        return @priority = value if value
+
+        inherited_setting(:@priority, 100)
+      end
+
       # The mark's Markdown syntax, as prosemirror-markdown's MarkSerializerSpec:
       # - `open` and `close`: strings, or blocks called with the MarkdownSerializer, the mark, the parent node
       #   and the index of the marked node;

data/lib/prosemirror/markdown/builder.rb

@@ -13,6 +13,7 @@ module Prosemirror
     #   stays as text.
     # - Code blocks lose their final newline, as in prosemirror-markdown.
     # - YAML front matter, between `---` lines at the start, is dropped.
+    # - U+0000 is replaced with U+FFFD, as the CommonMark spec requires.
     # @api private
     class Builder
       MAX_DEPTH = HTML::Builder::MAX_DEPTH
@@ -47,7 +48,7 @@ module Prosemirror
       # A root Element holding the content.
       def call(markdown)
         self.class.load_commonmarker
-        markdown = UTF8.string(markdown)
+        markdown = UTF8.string(markdown).tr("\u0000", "\uFFFD")
         document = parse(markdown)
         return from_html(document) if raw_html?(document) && HTML::Builder.herb?
 

data/lib/prosemirror/marks/link.rb

@@ -4,6 +4,7 @@ module Prosemirror
   module Marks
     # Tiptap's link. Without an allowed `href`, its text is rendered without a link.
     class Link < MarkType
+      priority 1000 # As in Tiptap: the outermost mark.
       prop :href, _String(length: 1..), url: true
       prop :target, _String?
       prop :rel, _String?

data/lib/prosemirror/marks/text_style.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  module Marks
+    # Tiptap's TextStyle, with the attributes of its TextStyleKit: Color, BackgroundColor, FontFamily, FontSize
+    # and LineHeight, each rendered as a CSS property of a span. Not in `Schema.tiptap`, as in Tiptap's
+    # StarterKit: add it with `Schema.tiptap.with(Prosemirror::Marks::TextStyle)`.
+    #
+    # Unlike Tiptap, a span without any of these properties gets no mark, and a missing property is nil rather
+    # than "". Values that could load or run something, like `url()`, are invalid.
+    class TextStyle < MarkType
+      priority 101 # As in Tiptap: right after links.
+      # CSS values without `url()`, `expression()`, escapes or comments, nor `;` or braces that would end the
+      # declaration.
+      VALUE = %r{\A(?!.*(?:url\s*\(|expression\s*\(|\\|/\*))[\w\s#%.,'"()+-]+\z}im
+      # Property names, and the CSS property each one renders.
+      PROPERTIES = {
+        color: "color", background_color: "background-color", font_family: "font-family",
+        font_size: "font-size", line_height: "line-height"
+      }.freeze
+
+      PROPERTIES.each do |name, property|
+        prop name, _String?(VALUE), json: Naming.camel(name), parse_html: ->(element) { TextStyle.style_of(element, property) }
+      end
+
+      parse_html(tag: "span[style]", consuming: false) do |element|
+        styled = PROPERTIES.each_value.any? { |property| style_of(element, property) }
+        styled ? {} : false
+      end
+
+      def view_template(&)
+        styles = PROPERTIES.filter_map do |name, property|
+          value = instance_variable_get(:"@#{name}")
+          "#{property}: #{value}" if value
+        end
+        styles.empty? ? yield : span(style: styles.join("; "), &)
+      end
+
+      # The property in the span's style, or in the spans around it, whose styles Tiptap merges into the
+      # innermost one. Colors lose their quotes, as in Tiptap.
+      def self.style_of(element, property)
+        while element&.element? && element.name == "span"
+          value = element.style[property]
+          return property.end_with?("color") ? value.delete(%('")) : value if value && !value.empty?
+
+          element = element.parent
+        end
+      end
+    end
+  end
+end

data/lib/prosemirror/nodes/heading.rb

@@ -9,7 +9,7 @@ module Prosemirror
       prop :level, _Integer(1..6), default: 1, &Coerce::INTEGER
       (1..6).each { |level| parse_html tag: "h#{level}", attrs: {level:} }
 
-      def view_template(&) = tag(:"h#{@level}", &)
+      def view_template(&) = tag(:"h#{@level}", id: heading_id, &)
 
       def to_markdown(markdown, _parent, _index)
         markdown.write("#{"#" * @level} ")

data/lib/prosemirror/nodes/table_cell.rb

@@ -10,7 +10,7 @@ module Prosemirror
       prop :colspan, _Integer(1..), default: 1, &Coerce::INTEGER
       prop :rowspan, _Integer(1..), default: 1, &Coerce::INTEGER
       prop :colwidth, _Array?(_Integer(1..)),
-        parse_html: ->(element) { element["colwidth"]&.split(",")&.map(&:to_i) }
+        parse_html: ->(element) { element["colwidth"].then { |value| value.split(",").map(&:to_i) unless value.to_s.empty? } }
       # From the `text-align` style, or the old `align` attribute.
       prop :align, _Union?(*ALIGNMENTS), parse_html: lambda { |element|
         (element.style["text-align"] || element["align"]).to_s.strip.downcase.then { |value| value if ALIGNMENTS.include?(value) }
@@ -26,7 +26,7 @@ module Prosemirror
 
       def cell_attributes
         {colspan: (@colspan unless @colspan == 1), rowspan: (@rowspan unless @rowspan == 1),
-         style: @align && "text-align: #{@align}"}
+         colwidth: @colwidth&.join(","), style: @align && "text-align: #{@align}"}
       end
     end
   end

data/lib/prosemirror/nodes/twitch.rb

@@ -20,9 +20,11 @@ module Prosemirror
       prop :muted, _Boolean, default: false, parse_html: ->(element) { Twitch.from_embed_url(element["src"])&.fetch(:muted) }
       prop :time, _String?, parse_html: ->(element) { Twitch.from_embed_url(element["src"])&.fetch(:time) }
 
-      # Tiptap's markup, `<div data-twitch-video><iframe>`, or an iframe of a Twitch embed URL.
+      # Tiptap's markup, `<div data-twitch-video><iframe>`, or an iframe of a Twitch embed URL. Not with a URL
+      # it can't render.
       parse_html(tag: "iframe[src]") do |element|
-        (element.parent&.key?("data-twitch-video") || Twitch.from_embed_url(element["src"])) ? {} : false
+        src = element["src"]
+        (Twitch.from_embed_url(src) || (element.parent&.key?("data-twitch-video") && Twitch.identify(src))) ? {} : false
       end
 
       def view_template

data/lib/prosemirror/nodes/youtube.rb

@@ -20,9 +20,11 @@ module Prosemirror
       prop :width, _Integer?(1..), default: 640, &Coerce::INTEGER
       prop :height, _Integer?(1..), default: 480, &Coerce::INTEGER
 
-      # Tiptap's markup, `<div data-youtube-video><iframe>`, or an iframe of a YouTube embed URL.
+      # Tiptap's markup, `<div data-youtube-video><iframe>`, or an iframe of a YouTube embed URL. Not with a URL
+      # it can't render.
       parse_html(tag: "iframe[src]") do |element|
-        (element.parent&.key?("data-youtube-video") || Youtube.from_embed_url(element["src"])) ? {} : false
+        src = element["src"]
+        (Youtube.from_embed_url(src) || (element.parent&.key?("data-youtube-video") && Youtube.embed_url(src))) ? {} : false
       end
 
       def view_template

data/lib/prosemirror/rendering.rb

@@ -19,6 +19,12 @@ module Prosemirror
       prosemirror_schema.safe_url(url, @_prosemirror_urls)
     end
 
+    # The heading's id from `Document#headings`, when the document is rendered with `heading_ids: true`.
+    # Otherwise nil.
+    def heading_id
+      @_prosemirror_heading_ids&.[](node)
+    end
+
     private
 
     def render_fragment(nodes, depth)
@@ -65,6 +71,7 @@ module Prosemirror
     def prepare(component)
       component.instance_variable_set(:@_prosemirror_schema, prosemirror_schema)
       component.instance_variable_set(:@_prosemirror_urls, @_prosemirror_urls)
+      component.instance_variable_set(:@_prosemirror_heading_ids, @_prosemirror_heading_ids)
       component
     end
   end

data/lib/prosemirror/schema.rb

@@ -39,7 +39,7 @@ module Prosemirror
           Nodes::TaskItem, Nodes::Details, Nodes::DetailsSummary, Nodes::DetailsContent, Nodes::Youtube,
           Nodes::Twitch, Nodes::Mention
         ],
-        # In Tiptap's order, which sorts and nests marks.
+        # In Tiptap's order, which sorts and nests marks: by priority, then as listed.
         marks: [
           Marks::Link, Marks::Bold, Marks::Code, Marks::Italic, Marks::Strike, Marks::Underline,
           Marks::Subscript, Marks::Superscript, Marks::Highlight
@@ -62,6 +62,8 @@ module Prosemirror
     end
 
     def after_initialize
+      # Marks sort and nest in this order, so a mark added with `with` takes its place by priority.
+      @marks = @marks.each_with_index.sort_by { |type, index| [-type.priority, index] }.map(&:first).freeze
       @node_lookup = lookup(@nodes)
       @mark_lookup = lookup(@marks)
       @node_names = spellings(@node_lookup)

data/lib/prosemirror/transformer.rb

@@ -10,10 +10,12 @@ module Prosemirror
   # Document#check.
   # @api private
   class Transformer
-    def initialize(schema, &block)
+    # With `report: false`, the required nodes are added without reporting them, when adding them is expected.
+    def initialize(schema, report: true, &block)
       raise ArgumentError, "transform needs a block" unless block
 
       @schema = schema
+      @report = report
       @block = block
     end
 
@@ -75,7 +77,7 @@ module Prosemirror
       return nil if nodes.include?(nil)
 
       names = types.map { |type| @schema.json_type_name(type.type_name) }.join(", ")
-      @schema.report("added required #{names} to #{@schema.json_type_name(node.type)}", path: path)
+      @schema.report("added required #{names} to #{@schema.json_type_name(node.type)}", path: path) if @report
       nodes
     end
   end

data/lib/prosemirror/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosemirror
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosemirror
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Hans Lemuet
@@ -99,6 +99,7 @@ files:
 - lib/prosemirror/marks/strike.rb
 - lib/prosemirror/marks/subscript.rb
 - lib/prosemirror/marks/superscript.rb
+- lib/prosemirror/marks/text_style.rb
 - lib/prosemirror/marks/underline.rb
 - lib/prosemirror/naming.rb
 - lib/prosemirror/node.rb
@@ -138,7 +139,6 @@ files:
 - lib/prosemirror/type_definition.rb
 - lib/prosemirror/utf8.rb
 - lib/prosemirror/version.rb
-- sig/prosemirror.rbs
 homepage: https://github.com/etaminstudio/prosemirror
 licenses:
 - MIT

data/sig/prosemirror.rbs

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