yrby 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e731133b862944bb0475e1175d59c1d365924a5da722a395624426044371413
-  data.tar.gz: 1ec6b9298ecb11609d3d93279ecd5239f54b10ae5e7cd5f9d1b7deffe75288b6
+  metadata.gz: ea4b274bb5d8928c48900e3fe08b1e2b5d93c7e9970fe8ee6d453366e2c2c9be
+  data.tar.gz: 6df2e03ac56e522e1ba854266dd193124514d0fe5f756ad79f1038e4704103b9
 SHA512:
-  metadata.gz: 3b0d016da20f2bd97529fdf0fce808a771e4997d9834f5be9234ef6f0225485f72fa3854cd7a362ff72275f84f3fa8003ac0cd42efea55028c07879fa6b9da1a
-  data.tar.gz: da77acc0583feb5e7cbb4da0076c6fd3053c11fb64a6aa4c33d708a31220a49e67f1cadf6c5ea27f67c9dd5b9c655285a004dbe70acea1133a232c606d8f7ccb
+  metadata.gz: e45d38cf54bf43b63a72e0127c89aedd3f5c713a7677afddbdd5c2b4c702af1d755bc1c15fdf22d0f118d9611dc7dd06843efb7ec94cb89d6a898cf6f6d44b30
+  data.tar.gz: 651268d3b107633e104e346840083bcf5b1ecda00ae3d4586ed89cdb235b8bda34df34c6d60fcde23fdd47b18d0439ff9fca5e36683322799fc66d86157923bb

data/CHANGELOG.md

@@ -6,6 +6,37 @@ to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-03
+
+### Added
+
+- `unknown_types` on `Y::Lexical` and `Y::ProseMirror`, and so on `Y::Lexxy`
+  and `Y::Tiptap`. It lists the node types in a document that neither the
+  built-in schema nor a rule handles, which are the ones `to_html` can't fully
+  render. Render a real document from your editor in a test and assert the list
+  is empty.
+- The renderer crates export `escape_text` and `escape_attr` for callers that
+  build their own markup (`lexical-yjs-html` 0.1.4, `prosemirror-yjs-html`
+  0.1.5).
+
+### Changed
+
+- The demo app and the render-parity test run on Lexxy 1.0. `Y::Lexxy`
+  output matches Lexxy 1.0's own `value`, including image alt text edited
+  after the document syncs.
+
+### Fixed
+
+- The Lexical renderers keep the text of an unknown inline wrapper, such as a
+  mark with no rule. The text renders without the wrapper. Before, the whole
+  node rendered as nothing, so its text was missing from the HTML.
+- `Y::Lexxy`'s list-item rule escapes the stored `__checked` and `__value`
+  attributes. Collaborators write those attributes, and a crafted value could
+  break out of the HTML attribute. Normal values (booleans and integers) render
+  the same as before.
+- The crate READMEs' callback examples escape the values they insert, and both
+  READMEs describe how unknown node types render.
+
 ## [0.8.0] - 2026-10-01
 
 This release ships alongside yrby-client 0.6.0, and the client entries below

data/Cargo.lock

@@ -229,7 +229,7 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "lexical-yjs-html"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "serde_json",
  "yjs-html-core",
@@ -348,7 +348,7 @@ dependencies = [
 
 [[package]]
 name = "prosemirror-yjs-html"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "serde_json",
  "yjs-html-core",

data/README.md

@@ -338,12 +338,12 @@ every editor configures its own. `Y::Lexical` is the core Lexical base
 (paragraphs, headings, quotes, code, lists, tables, links, and the full
 text-format model), and other Lexical editors extend it with rules.
 
-It handles every node in the Lexxy 0.9.x set: paragraphs, headings, every text
-format and their combinations, links, the four list types with nesting,
-blockquotes, code blocks, tabs and soft breaks, horizontal rules, tables with
-header cells, image galleries, and ActionText attachments. Uploads and mentions
-both render as `<action-text-attachment>` elements, which ActionText can
-re-render.
+It handles every node in Lexxy 1.0, which has the same set as 0.9.x:
+paragraphs, headings, every text format and their combinations, links, the
+four list types with nesting, blockquotes, code blocks, tabs and soft breaks,
+horizontal rules, tables with header cells, image galleries, and ActionText
+attachments. Uploads and mentions both render as `<action-text-attachment>`
+elements, which ActionText can re-render.
 
 The Lexical support has the same two layers. `Y::Lexical` handles core Lexical
 structure natively, and everything Lexxy adds is in `Y::Lexxy`'s rule set,
@@ -401,6 +401,13 @@ attribute names your templates and blocks will read, and `children` and `text`
 tell you which `contains:` to pick. Child block types mean `:blocks`, and text
 means `:inline`.
 
+`unknown_types` lists the types whose `handled` is nil. `to_html` still
+renders them as well as it can. An unknown container or inline wrapper renders
+its children without its own markup, so its text stays. A node that keeps its
+content only in its attributes renders nothing. Either way, the node's markup is
+missing from the HTML, and nothing raises. When you add editor nodes, add a test
+that renders a real document and asserts `unknown_types` is empty.
+
 When a declarative rule can't express the markup, give the node a block:
 
 ```ruby

data/ext/yrby/crates/lexical-html/Cargo.toml

@@ -3,7 +3,7 @@ name = "lexical-yjs-html"
 description = "Render Lexical-shaped yrs documents to HTML, no browser or Node required"
 repository = "https://github.com/jpcamara/yrby"
 readme = "README.md"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]

data/ext/yrby/crates/lexical-html/src/lib.rs

@@ -697,8 +697,15 @@ fn render_inline<T: ReadTxn>(
                         None => render_link(txn, &child, depth, em, rules),
                     }
                 } else if ruled_inline && !is_builtin(&ty) {
-                    if let Some(rule) = rules.nodes.get(ty.as_str()) {
-                        render_rule_inline(txn, &child, &ty, rule, depth, em, rules);
+                    match rules.nodes.get(ty.as_str()) {
+                        Some(rule) => render_rule_inline(txn, &child, &ty, rule, depth, em, rules),
+                        // An unknown inline wrapper, such as a mark with no
+                        // rule, renders its text without the wrapper, the same
+                        // way unknown blocks do. Its text is kept.
+                        None if depth < MAX_INLINE_DEPTH => {
+                            render_inline(txn, &child, depth + 1, ruled_inline, em, rules);
+                        }
+                        None => {}
                     }
                 }
                 // Nested blocks are rendered by their parent block's renderer.
@@ -956,15 +963,18 @@ fn elem_type<T: ReadTxn>(txn: &T, e: &XmlElementRef) -> String {
 }
 
 /// Text-content escaping, matching what the browser's serializer emits:
-/// `&`, `<`, `>` escaped; quotes left alone in text.
-fn escape_text(s: &str) -> String {
+/// `&`, `<`, `>` escaped; quotes left alone in text. Public for splice
+/// callers. Values read from a deferred segment's attributes come from
+/// collaborators, so escape anything you put into markup.
+pub fn escape_text(s: &str) -> String {
     s.replace('&', "&amp;")
         .replace('<', "&lt;")
         .replace('>', "&gt;")
 }
 
-/// Attribute-value escaping: text escaping plus `"`.
-fn escape_attr(s: &str) -> String {
+/// Attribute-value escaping: text escaping plus `"`. Public for splice
+/// callers, for document values interpolated into attribute positions.
+pub fn escape_attr(s: &str) -> String {
     escape_text(s).replace('"', "&quot;")
 }
 
@@ -1140,6 +1150,28 @@ mod tests {
         assert!(html.contains("<p>Before gallery</p>"));
     }
 
+    /// An unknown inline wrapper never drops its text. The fixture is a
+    /// real capture: two collaborating editors typed "Collab #ruby rocks
+    /// and #peer too", the word "rocks" wrapped in @lexical/mark's
+    /// MarkNode and the hashtags as @lexical/hashtag TextNode runs. With
+    /// no rules, the mark's wrapper is lost but "rocks" survives, and
+    /// hashtags render as their text.
+    #[test]
+    fn unknown_inline_wrappers_keep_their_text() {
+        let bytes = include_bytes!("fixtures/mark_hashtag.bin");
+        let doc = Doc::new();
+        doc.transact_mut()
+            .apply_update(Update::decode_v1(bytes).unwrap())
+            .unwrap();
+        let txn = doc.transact();
+        let frag = txn.get_xml_fragment("root").unwrap();
+        let html = render(&txn, &frag).unwrap();
+
+        assert!(html.contains("rocks"), "marked text survives without a rule: {html}");
+        assert!(!html.contains("<mark"), "no wrapper is invented for it: {html}");
+        assert!(html.contains("#ruby"), "hashtag text survives: {html}");
+    }
+
     #[test]
     fn format_runs_match_lexxys_export_algorithm() {
         // Singles take their semantic tag; the span for plain text unwraps.

data/ext/yrby/crates/prosemirror-html/Cargo.toml

@@ -3,7 +3,7 @@ name = "prosemirror-yjs-html"
 description = "Render ProseMirror-shaped yrs documents to HTML, no browser or Node required"
 repository = "https://github.com/jpcamara/yrby"
 readme = "README.md"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]

data/ext/yrby/crates/prosemirror-html/src/lib.rs

@@ -881,14 +881,18 @@ fn num_attr<T: ReadTxn>(txn: &T, e: &XmlElementRef, name: &str) -> Option<i64> {
 }
 
 /// Text-content escaping, matching the browser serializer: `&`, `<`, `>`.
-fn escape_text(s: &str) -> String {
+/// Public for splice callers. Values read from a deferred segment's
+/// attributes come from collaborators, so escape anything you put into
+/// markup.
+pub fn escape_text(s: &str) -> String {
     s.replace('&', "&amp;")
         .replace('<', "&lt;")
         .replace('>', "&gt;")
 }
 
-/// Attribute-value escaping: text escaping plus `"`.
-fn escape_attr(s: &str) -> String {
+/// Attribute-value escaping: text escaping plus `"`. Public for splice
+/// callers, for document values interpolated into attribute positions.
+pub fn escape_attr(s: &str) -> String {
     escape_text(s).replace('"', "&quot;")
 }
 

data/lib/y/lexxy.rb

@@ -42,8 +42,8 @@ module Y
     def self.list_item(node)
       out = +"<li"
       checked = node.attrs["__checked"]
-      out << %( aria-checked="#{checked}") unless checked.nil?
-      out << %( value="#{node.attrs["__value"] || 1}")
+      out << %( aria-checked="#{RenderRules.escape_attr(checked)}") unless checked.nil?
+      out << %( value="#{RenderRules.escape_attr(node.attrs["__value"] || 1)}")
       out << %( class="lexxy-nested-listitem") if node.child_types.include?("list")
       "#{out}>#{node.content}</li>"
     end

data/lib/y/rendering.rb

@@ -241,6 +241,18 @@ module Y
       json = root.nil? ? @native.node_types : @native.node_types(root)
       json && JSON.parse(json)
     end
+
+    # The node types to_html can't fully render: types in the document that
+    # neither the built-in schema nor a registered rule handles. An unknown
+    # container or inline wrapper renders its children without its own
+    # markup, so its text stays. An unknown decorator renders nothing, so
+    # content kept only in its attributes is missing from the HTML. Returns
+    # [] when every type is handled, and when the root is missing or isn't
+    # Lexical-shaped, because to_html returns nil there.
+    def unknown_types(root = nil)
+      types = node_types(root)
+      types ? types.filter_map { |type, info| type if info["handled"].nil? } : []
+    end
   end
 
   class ProseMirror
@@ -276,6 +288,18 @@ module Y
       json = root.nil? ? @native.node_types : @native.node_types(root)
       json && JSON.parse(json)
     end
+
+    # The node types to_html can't fully render: types in the document that
+    # neither the built-in schema nor a registered rule handles. An unknown
+    # node renders its text and children without its own markup. A node that
+    # keeps its content only in its attributes renders nothing. Marks aren't
+    # listed, and an unknown mark renders its text unformatted. Returns []
+    # when every type is handled, and when the root is missing or isn't
+    # ProseMirror-shaped, because to_html returns nil there.
+    def unknown_types(root = nil)
+      types = node_types(root)
+      types ? types.filter_map { |type, info| type if info["handled"].nil? } : []
+    end
   end
 
   private_constant :NativeLexical, :NativeProseMirror

data/lib/y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Y
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yrby
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - JP Camara