yrby 0.7.0 → 0.8.0

data/ext/yrby/Cargo.toml

@@ -14,9 +14,9 @@ magnus = "0.8"
 rb-sys = "0.9"
 yrs = { version = "0.27", features = ["sync"] }
 serde_json = "1.0"
-yrs-html-core = { path = "crates/html-core" }
-yrs-lexical-html = { path = "crates/lexical-html" }
-yrs-prosemirror-html = { path = "crates/prosemirror-html" }
+yjs-html-core = { path = "crates/html-core" }
+lexical-yjs-html = { path = "crates/lexical-html" }
+prosemirror-yjs-html = { path = "crates/prosemirror-html" }
 
 [dev-dependencies]
 rb-sys-env = "0.1"

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

@@ -1,14 +1,15 @@
 [package]
-name = "yrs-html-core"
-description = "Internal core for the yrs-*-html renderer crates; depend on those instead"
+name = "yjs-html-core"
+description = "Internal core for the lexical-yjs-html and prosemirror-yjs-html renderer crates; depend on those instead"
 repository = "https://github.com/jpcamara/yrby"
 readme = "README.md"
-version = "0.1.0"
+version = "0.1.3"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]
 license = "MIT"
-publish = false
+keywords = ["yjs", "crdt", "yrs", "html", "rendering"]
+categories = ["text-processing", "web-programming"]
 
 [dependencies]
 yrs = { version = "0.27", features = ["sync"] }

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

@@ -1,21 +1,21 @@
-//! Custom render rules and segmented output — the extensibility core shared
-//! by both HTML renderers.
+//! The custom render rules and segmented output that both HTML renderers
+//! share.
 //!
-//! Callers register per-node rules. Two tiers:
+//! Callers register a rule per node. There are two tiers:
 //!
-//! - **Declarative rules** (tag, attributes, text, content slot) compile to
-//!   [`NodeRule`]/[`MarkRule`] here and render natively, inside the document
+//! - A declarative rule (tag, attributes, text, content slot) compiles to a
+//!   [`NodeRule`] or [`MarkRule`] and renders natively, inside the document
 //!   transaction, at full speed. This covers the tiptap-php `renderHTML`
 //!   shape: markup as data.
-//! - **Callback rules** defer to the caller. Rendering never runs app code
-//!   while the document is locked — the renderer emits [`Segment::Deferred`]
-//!   entries carrying the node's type, attributes (as JSON), and its
-//!   already-rendered children, and the caller fills them in after the
-//!   render returns. (In the Ruby gem, that caller is the app's block, run
-//!   once the transaction has closed and the GVL is held again.)
+//! - A callback rule defers to the caller. The renderer never runs
+//!   application code while the document is locked. It emits
+//!   [`Segment::Deferred`] entries with the node type, the attributes as
+//!   JSON, and the already-rendered children, and the caller fills them in
+//!   after the render returns. In the Ruby gem that caller is the app's
+//!   block, run once the transaction has closed and the GVL is held again.
 //!
-//! Rules arrive as one JSON document (see `parse`), so the same format
-//! serves any binding or caller.
+//! Rules arrive as one JSON document (see `parse`), so one format serves
+//! every binding and caller.
 
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use yrs::{Any, Out, ReadTxn, Xml};
@@ -196,11 +196,7 @@ pub fn resolve_parts<F: Fn(&str) -> Option<String>>(
             }
         }
     }
-    if out.is_empty() {
-        None
-    } else {
-        Some(out)
-    }
+    if out.is_empty() { None } else { Some(out) }
 }
 
 /// An attribute reference on a node: rules say `:kind`; Lexical stores its own
@@ -384,7 +380,7 @@ fn parse_node_rule(name: &str, spec: &serde_json::Value) -> Result<NodeRule, Str
         Some(other) => {
             return Err(format!(
                 "rule for {name:?}: unknown content kind {other:?} (blocks|inline|none)"
-            ))
+            ));
         }
     };
     if spec
@@ -431,7 +427,7 @@ fn parse_attrs(
         Some(_) => {
             return Err(format!(
                 "rule for {name:?}: attrs must be an array of [name, template] pairs"
-            ))
+            ));
         }
     };
     for entry in entries {

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

@@ -1,16 +1,17 @@
 [package]
-name = "yrs-lexical-html"
+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.0"
+version = "0.1.3"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]
 license = "MIT"
-publish = false
+keywords = ["yjs", "crdt", "lexical", "html", "yrs"]
+categories = ["text-processing", "web-programming"]
 
 [dependencies]
 yrs = { version = "0.27", features = ["sync"] }
 serde_json = "1.0"
-yrs-html-core = { path = "../html-core" }
+yjs-html-core = { path = "../html-core", version = "0.1.3" }

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

@@ -1,48 +1,61 @@
-//! Native HTML rendering of Lexical documents from the yrs collab structure —
-//! no Node process, no headless editor.
+//! HTML for Lexical documents, rendered from the Yjs structure the editor
+//! syncs. No Node process and no headless editor. A server that holds the
+//! document bytes produces the markup itself.
 //!
-//! This renders **core Lexical**: paragraphs, headings, quotes, code, lists
-//! and list items, tables, horizontal rules, links, and the whole text-format
-//! model. Everything Lexxy-specific — its own node types (attachments,
+//! This renders core Lexical: paragraphs, headings, quotes, code blocks,
+//! lists and list items, tables, horizontal rules, links, and the whole
+//! text-format model. Lexxy's additions live in the Ruby layer, as the
+//! `Y::Lexxy` renderer's rule set: its own node types (attachments,
 //! galleries, `early_escape_code`, `horizontal_divider`) and its decorations
-//! of core nodes (the table figure wrapper, header-cell styling, the
-//! nested-list-item class) — lives in the Ruby layer as the `Y::Lexxy`
-//! renderer's rule set, built on the same extension API apps use
-//! (`Y::Lexical` is the core base class). The Lexxy byte-parity guarantee is
-//! held there: the Ruby fixture tests and the live headless-Chrome e2e pin
-//! `Y::Lexxy#to_html` against a real editor's own serialized value. The
-//! native tests pin core output as regression goldens (stock Lexical has no
-//! canonical serializer to capture against).
+//! of core nodes (the figure around a table, header-cell styling, the
+//! nested-list-item class). That rule set uses the same extension API
+//! applications use. `Y::Lexical` is the core base class. The byte-parity
+//! guarantee is held there too: the Ruby fixture tests and the
+//! headless-Chrome end-to-end run pin `Y::Lexxy#to_html` against a real
+//! editor's serialized value. The tests in this crate pin core output as
+//! regression goldens. Stock Lexical has no canonical serializer to capture
+//! from.
 //!
-//! Prior art: `ueberdosis/tiptap-php` renders ProseMirror JSON to HTML in pure
-//! PHP — a schema-pinned renderer outside the JS runtime. This works from the
-//! collab (Yjs) structure rather than JSON.
+//! Prior art: `ueberdosis/tiptap-php` renders ProseMirror JSON to HTML in
+//! plain PHP, outside any JavaScript runtime. This crate does the same job
+//! from the collaborative (Yjs) structure.
 //!
-//! Storage model (verified against bytes captured from a live editor):
-//! - Blocks are `Y.XmlText` with a `__type` attribute (`paragraph`, `heading`
-//!   (+`__tag`), `quote`, `code` (+`__language`), `list`/`listitem`,
-//!   `table`/`tablerow`/`tablecell`, `link`/`autolink` (inline)).
-//! - Text runs are preceded by an embedded `Y.Map` carrying per-run metadata
-//!   (`__type: "text" | "code-highlight" | "tab"`, `__format` bitmask).
-//! - `linebreak` is a bare metadata map; `tab` is a map followed by a "\t" run.
-//! - Decorator nodes are `Y.XmlElement`s with their fields as plain
-//!   attributes (`horizontalrule` here; app/Lexxy decorators via rules).
+//! How Lexical stores a document, checked against bytes captured from a live
+//! editor:
 //!
-//! Text-format rendering follows the export pipeline Lexxy runs (Lexical's
-//! `$generateHtmlFromNodes` + sanitize), which is the only externally
-//! pinnable truth for formatting: inner tag `strong` (bold) / `em` (italic,
-//! when not bold); outer tag `code` / `mark` / `sub` / `sup`; an `<i>` wrap
-//! only when bold+italic combine (the `em` slot is taken); `<s>` / `<u>`
-//! wraps always; `<span>`s are unwrapped, so unformatted text is bare. A
-//! run's `__style` (highlight colors) survives on the createDOM tag,
-//! filtered to color/background-color; on a plain or s/u-only run it dies
-//! with the unwrapped span. Case-transform format bits are never rendered
-//! (their text-transform style is outside the sanitize whitelist).
+//! - Blocks are `Y.XmlText` with a `__type` attribute: `paragraph`,
+//!   `heading` (plus `__tag`), `quote`, `code` (plus `__language`), `list`
+//!   and `listitem`, `table`, `tablerow` and `tablecell`, and the inline
+//!   `link` and `autolink`.
+//! - Each text run is preceded by an embedded `Y.Map` with its metadata: a
+//!   `__type` of `text`, `code-highlight`, or `tab`, and a `__format`
+//!   bitmask.
+//! - A `linebreak` is a bare metadata map. A `tab` is a map followed by a
+//!   `"\t"` run.
+//! - Decorator nodes are `Y.XmlElement`s whose fields are plain attributes.
+//!   `horizontalrule` is handled here. Application and Lexxy decorators come
+//!   in through rules.
 //!
-//! Custom nodes: rules are registered by `__type` (see `yrs-html-core`) and
-//! consulted before the built-in arms, so they extend the schema or override
-//! a built-in. Declarative rules render here; callback rules emit
-//! `Segment::Deferred` for the caller to fill in after the render.
+//! Text formatting follows the export pipeline Lexxy runs: Lexical's
+//! `$generateHtmlFromNodes`, then sanitize. That output is the only
+//! formatting truth that can be pinned from outside. The inner tag is
+//! `strong` for bold, or `em` for italic without bold. The outer tag is
+//! `code`, `mark`, `sub`, or `sup`. An `<i>` wraps only when bold and italic
+//! combine, because the `em` slot is taken. `<s>` and `<u>` wrap whenever
+//! present. `<span>`s are unwrapped, so unformatted text is bare. A run's
+//! `__style` (highlight colors) survives on the createDOM tag, filtered to
+//! color and background-color. On a plain run, or one with only strike or
+//! underline, it goes away with the span. The case-transform format bits
+//! never render; their text-transform style is outside the sanitize
+//! whitelist.
+//!
+//! A node type with no rule still renders its text and child blocks, just
+//! unwrapped.
+//!
+//! Custom nodes register rules by `__type` (see `yjs-html-core`). A rule is
+//! consulted before the built-in arms, so it can extend the schema or
+//! replace a built-in. Declarative rules render here. Callback rules emit
+//! `Segment::Deferred` for the caller to fill in after the render returns.
 
 // README examples are living code: compile-checked on every cargo test.
 #[cfg(doctest)]
@@ -50,8 +63,8 @@
 mod readme_examples {}
 
 // The full rules surface, re-exported: depend on this crate alone;
-// yrs-html-core is an internal implementation crate.
-pub use yrs_html_core::*;
+// yjs-html-core is an internal implementation crate.
+pub use yjs_html_core::*;
 use yrs::types::text::YChange;
 use yrs::{
     Any, GetString, Map, Out, ReadTxn, Text, Xml, XmlElementRef, XmlFragment, XmlFragmentRef,
@@ -130,7 +143,7 @@ pub fn render_segments<T: ReadTxn>(
 /// callback rules, segments always flatten.
 pub fn render<T: ReadTxn>(txn: &T, fragment: &XmlFragmentRef) -> Option<String> {
     render_segments(txn, fragment, &Rules::empty()).map(|segs| {
-        yrs_html_core::flatten(segs)
+        yjs_html_core::flatten(segs)
             .into_html()
             .expect("no callback rules registered")
     })
@@ -773,11 +786,7 @@ fn lexxy_style(style: &str) -> Option<String> {
             css.push(';');
         }
     }
-    if css.is_empty() {
-        None
-    } else {
-        Some(css)
-    }
+    if css.is_empty() { None } else { Some(css) }
 }
 
 /// `link` / `autolink`: Lexxy's sanitize keeps only `href` and `title`
@@ -1301,7 +1310,7 @@ mod tests {
         let txn = doc.transact();
         let frag = txn.get_xml_fragment("root").unwrap();
         let segs = render_segments(&txn, &frag, &rules).unwrap();
-        let html = yrs_html_core::flatten(segs).into_html().unwrap();
+        let html = yjs_html_core::flatten(segs).into_html().unwrap();
         assert_eq!(
             html,
             "<p><a class=\"app-link\" href=\"https://x.example\">site</a>\

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

@@ -1,16 +1,17 @@
 [package]
-name = "yrs-prosemirror-html"
+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.0"
+version = "0.1.4"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]
 license = "MIT"
-publish = false
+keywords = ["yjs", "crdt", "prosemirror", "tiptap", "html"]
+categories = ["text-processing", "web-programming"]
 
 [dependencies]
 yrs = { version = "0.27", features = ["sync"] }
 serde_json = "1.0"
-yrs-html-core = { path = "../html-core" }
+yjs-html-core = { path = "../html-core", version = "0.1.3" }