yrby 0.6.0 → 0.7.0

data/ext/yrby/target/debug/build/serde-58ea0ee887cc2602/out/private.rs

@@ -0,0 +1,6 @@
+#[doc(hidden)]
+pub mod __private228 {
+    #[doc(hidden)]
+    pub use crate::private::*;
+}
+use serde_core::__private228 as serde_core_private;

data/ext/yrby/target/debug/build/serde_core-41f407c21c1f205e/out/private.rs

@@ -0,0 +1,5 @@
+#[doc(hidden)]
+pub mod __private228 {
+    #[doc(hidden)]
+    pub use crate::private::*;
+}

data/ext/yrby/target/debug/build/thiserror-0f1416a82ff26f22/out/private.rs

@@ -0,0 +1,5 @@
+#[doc(hidden)]
+pub mod __private18 {
+    #[doc(hidden)]
+    pub use crate::private::*;
+}

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "generators/yrby/tables/tables_generator"
+
+module Yrby
+  module Generators
+    # `bin/rails generate yrby:install` — a DocumentChannel speaking the
+    # y-websocket protocol over the gem's document storage, plus the storage
+    # migration (via yrby:tables). The models ship in the gem; only the
+    # migration lands in the app.
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_channel
+        template "document_channel.rb", "app/channels/document_channel.rb"
+      end
+
+      def create_tables
+        invoke "yrby:tables"
+      end
+
+      def show_next_steps
+        say <<~NEXT
+
+          Next steps:
+
+            1. Authorize document access: implement `authorized?` in
+               app/channels/document_channel.rb (it denies everyone until you do).
+            2. bin/rails db:migrate
+            3. Install the yrby-client npm package and connect an editor:
+
+                 import { ActionCableProvider } from "yrby-client"
+                 const provider = new ActionCableProvider(doc, consumer,
+                   "DocumentChannel", { id: documentId })
+                 provider.connect()
+
+          The README's Editors section links working integrations for
+          Tiptap, Lexxy, Rhino Editor, and CodeMirror.
+        NEXT
+      end
+    end
+  end
+end

data/lib/generators/yrby/install/templates/document_channel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Collaborative documents over Action Cable: one channel speaking the
+# y-websocket protocol (sync plus presence). Storage is Y::Document +
+# Y::DocumentUpdate; a document is created on its first change and its
+# history goes with it when it is destroyed. Point on_load/on_change
+# elsewhere to swap storage.
+class DocumentChannel < ApplicationCable::Channel
+  include Y::ActionCable
+
+  # Rebuild a document from durable storage (nil means a brand-new document).
+  on_load { |key| Y::Document.load_state(key) }
+
+  # Record each CRDT delta durably. Runs before the change is acknowledged
+  # or broadcast; if this raises, the change is neither acked nor relayed,
+  # and yrby-client retries it.
+  on_change { |key, update| Y::Document.append(key, update) }
+
+  def subscribed
+    return reject unless authorized?(params[:id])
+
+    sync_subscribed(params[:id])
+  end
+
+  def receive(data) = sync_receive(data, params[:id])
+
+  private
+
+  # Everyone is denied until you fill this in. Wire it to your app's auth:
+  # identify current_user on the cable connection, then check they may read
+  # and write this document. Don't lean on on_change raising for access
+  # control; that path exists for store failures.
+  def authorized?(_document_key)
+    false
+  end
+end

data/lib/generators/yrby/tables/tables_generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Yrby
+  module Generators
+    # `bin/rails generate yrby:tables`: the migration for the gem-owned
+    # document models (Y::Document + Y::DocumentUpdate). Invoked by
+    # yrby:install, and by other gems building on the same storage.
+    #
+    # Template notes (kept here, not in the emitted migration): state is
+    # 4.gigabytes - 1 (longblob on MySQL; a compacted snapshot is the whole
+    # document; a 16 MB cap would break compaction) and payload is
+    # 16.megabytes - 1 (one update can carry a big paste or a client's
+    # accumulated offline edits; the 64 KB default blob is too small).
+    # The partial unique index's WHERE only keeps
+    # key-only rows out of the index: uniqueness holds without it, since
+    # unique indexes treat NULLs as distinct on every supported database,
+    # and MySQL drops the predicate harmlessly. y_document_updates indexes
+    # (document_id, pending) instead of bare document_id: the prefix
+    # serves the tail and foreign-key lookups, and the pair serves the
+    # clean-row count every append runs.
+    class TablesGenerator < ::Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def create_migration_file
+        migration_template "create_y_tables.rb",
+                           File.join(db_migrate_path, "create_y_tables.rb")
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/yrby/tables/templates/create_y_tables.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class CreateYTables < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :y_documents do |t|
+      t.string :key, null: false, index: { unique: true }
+      t.references :record, polymorphic: true, null: true, index: false
+      t.string :name
+      t.binary :state, limit: 4.gigabytes - 1
+      t.timestamps
+      t.index %i[record_type record_id name], unique: true,
+              where: "record_type IS NOT NULL",
+              name: "index_y_documents_on_record_and_name"
+    end
+
+    create_table :y_document_updates do |t|
+      t.references :document, null: false, foreign_key: { to_table: :y_documents }, index: false
+      t.binary :payload, null: false, limit: 16.megabytes - 1
+      t.boolean :pending, null: false, default: false
+      t.datetime :created_at, null: false
+      t.index %i[document_id pending]
+    end
+  end
+end

data/lib/y/decoder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "y"
+
+module Y
+  # Plain-text reconstruction of a stored Yjs document, for search indexing
+  # and previews. It reads the text out of the shared type the editor uses
+  # (Lexical's `Y.XmlText`, plain `Y.Text`, or ProseMirror's `Y.XmlFragment`)
+  # in-process, on the same native extension as `Doc`: no Node, no
+  # subprocess.
+  #
+  #   state = doc.encode_state_as_update  # opaque CRDT bytes from the store
+  #   Y::Decoder.text(state)              # => "hello world"
+  #   Y::Decoder.preview(state, 280)      # => "hello world…"
+  #
+  # For full-fidelity HTML, `Y::Lexxy` and `Y::Tiptap` render the document
+  # with the editor's own semantics; this module is the cheap plain-text
+  # path.
+  module Decoder
+    class Error < Y::Error; end
+
+    module_function
+
+    # Plain text of the document. `field` pins the root key (Lexical: the editor
+    # id; ProseMirror: "default"); omit it to use the document's sole root.
+    def text(state, field: nil)
+      field ||= Y::Doc.new.tap { |d| d.apply_update(state) }.root_names.first
+      return "" unless field
+
+      # A plain `Y.Text` root (a simple shared-text editor) reads straight out.
+      # (A yrs root's type is fixed by its first typed access, so each reader
+      # gets a fresh doc to try a different shared type against the same state.)
+      direct = load(state).read_text(field)
+      return normalize(direct) if direct && !direct.strip.empty?
+
+      # Lexical (each block a sibling `Y.XmlText`) and ProseMirror (blocks are
+      # `Y.XmlElement`s) both come back from read_xml as block-per-line markup;
+      # strip any element tags to plain text.
+      markup = load(state).read_xml(field)
+      markup ? normalize(strip_tags(markup)) : ""
+    end
+
+    # A compact, single-line preview for list UIs.
+    def preview(state, limit: 280, field: nil)
+      body = text(state, field: field).gsub(/\s+/, " ").strip
+      body.length > limit ? "#{body[0, limit].rstrip}…" : body
+    end
+
+    def load(state)
+      Y::Doc.new.tap { |doc| doc.apply_update(state) }
+    end
+
+    def strip_tags(markup)
+      markup.gsub(/<[^>]*>/, " ")
+    end
+
+    def normalize(text)
+      text.gsub(/[ \t]+/, " ")     # collapse runs of spaces/tabs
+          .gsub(/ *\n */, "\n")    # trim spaces left around block separators
+          .gsub(/\n{3,}/, "\n\n")  # cap blank-line runs
+          .strip
+    end
+  end
+end

data/lib/y/lexxy.rb

@@ -52,24 +52,44 @@ module Y
     # and presence mirror Lexxy's exportDOM (nulls omitted, `previewable`
     # only when true, `presentation="gallery"` always).
     def self.upload(node)
-      out = +"<action-text-attachment"
+      tag = attachment_tag(node)
+      out = "<#{tag}"
       out << attachment_attr(node, "sgid", "sgid")
       out << %( previewable="true") if node.attrs["previewable"] == true
       [%w[url src], %w[alt altText], %w[caption caption],
        %w[content-type contentType], %w[filename fileName],
        %w[filesize fileSize], %w[width width], %w[height height]]
         .each { |html_name, stored| out << attachment_attr(node, html_name, stored) }
-      %(#{out} presentation="gallery"></action-text-attachment>)
+      %(#{out} presentation="gallery"></#{tag}>)
     end
 
     # A content attachment (mention, embed): `content` carries the escaped
     # inner HTML; `plainText` is not exported.
     def self.mention(node)
-      out = +"<action-text-attachment"
+      tag = attachment_tag(node)
+      out = "<#{tag}"
       out << attachment_attr(node, "sgid", "sgid")
       out << attachment_attr(node, "content", "innerHtml")
       out << attachment_attr(node, "content-type", "contentType")
-      "#{out}></action-text-attachment>"
+      "#{out}></#{tag}>"
+    end
+
+    # Lexxy's attachment tag is configurable (`Lexxy.configure`'s
+    # attachmentTagName, paired with ActionText::Attachment.tag_name on the
+    # Rails side), and each attachment node stores the tag it was created
+    # with. Emit the stored tag. The value is stored document data, not
+    # markup, so anything that doesn't look like a tag name falls back to
+    # ActionText's default.
+    def self.attachment_tag(node)
+      tag = node.attrs["tagName"].to_s
+      tag.match?(/\A[a-zA-Z][a-zA-Z0-9-]*\z/) ? tag : "action-text-attachment"
+    end
+
+    # An in-flight upload placeholder. Only the uploader's browser can
+    # complete it, so it is never finished content -- materialized output
+    # (Action Text bodies, search text) must not carry it.
+    def self.pending_upload(_node)
+      ""
     end
 
     # A stored nil (unset) is skipped; a stored empty string still emits.
@@ -90,6 +110,7 @@ module Y
       "tablecell" => { contains: :blocks, render: method(:table_cell) },
       "listitem" => { contains: :blocks, render: method(:list_item) },
       "action_text_attachment" => method(:upload),
+      "action_text_attachment_upload" => method(:pending_upload),
       "custom_action_text_attachment" => method(:mention)
     }.freeze
 

data/lib/y/version.rb

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

data/lib/y.rb

@@ -15,6 +15,7 @@ end
 require_relative "y/rendering"
 require_relative "y/lexxy"
 require_relative "y/tiptap"
+require_relative "y/decoder"
 
 module Y
   # Doc, Error, and the protocol module functions are defined in the Rust

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yrby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - JP Camara
@@ -68,7 +68,7 @@ dependencies:
 description: 'yrby is a thread-safe Ruby binding over the Rust y-crdt (yrs) library:
   CRDT documents, awareness/presence, and the y-websocket sync protocol primitives,
   with the GVL released during native work so documents sync in parallel. The ActionCable/Rails
-  integration lives in the companion yrby-actioncable gem.'
+  integration lives in the companion yrby-rails gem.'
 email:
 - johnpcamara@gmail.com
 executables: []
@@ -82,14 +82,30 @@ files:
 - LICENSE
 - README.md
 - ext/yrby/Cargo.toml
+- ext/yrby/crates/html-core/Cargo.toml
+- ext/yrby/crates/html-core/src/lib.rs
+- ext/yrby/crates/lexical-html/Cargo.toml
+- ext/yrby/crates/lexical-html/src/lib.rs
+- ext/yrby/crates/prosemirror-html/Cargo.toml
+- ext/yrby/crates/prosemirror-html/src/lib.rs
 - ext/yrby/extconf.rb
-- ext/yrby/src/lexical_html.rs
 - ext/yrby/src/lib.rs
-- ext/yrby/src/prosemirror_html.rs
 - ext/yrby/src/protocol.rs
 - ext/yrby/src/read.rs
-- ext/yrby/src/render_rules.rs
+- ext/yrby/target/debug/build/clang-sys-e3ae45bd384f74c3/out/common.rs
+- ext/yrby/target/debug/build/clang-sys-e3ae45bd384f74c3/out/dynamic.rs
+- ext/yrby/target/debug/build/clang-sys-e3ae45bd384f74c3/out/macros.rs
+- ext/yrby/target/debug/build/rb-sys-4407948463231c4f/out/bindings-0.9.128-mri-arm64-darwin23-3.4.7.rs
+- ext/yrby/target/debug/build/rb-sys-dbeea42737529c2d/out/bindings-0.9.128-mri-arm64-darwin23-3.4.7.rs
+- ext/yrby/target/debug/build/serde-58ea0ee887cc2602/out/private.rs
+- ext/yrby/target/debug/build/serde_core-41f407c21c1f205e/out/private.rs
+- ext/yrby/target/debug/build/thiserror-0f1416a82ff26f22/out/private.rs
+- lib/generators/yrby/install/install_generator.rb
+- lib/generators/yrby/install/templates/document_channel.rb
+- lib/generators/yrby/tables/tables_generator.rb
+- lib/generators/yrby/tables/templates/create_y_tables.rb
 - lib/y.rb
+- lib/y/decoder.rb
 - lib/y/lexxy.rb
 - lib/y/rendering.rb
 - lib/y/tiptap.rb