prosereflect 0.2.0 → 0.3.0

data/spec/fixtures/schema/custom_schema.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "prosereflect"
+require "prosereflect/schema"
+
+# Custom schema with mark exclusion rules
+# Used for testing that link excludes emoji
+module CustomSchemaFixture
+  CUSTOM_SCHEMA_NODES = {
+    "doc" => { "content" => "block+" },
+    "paragraph" => { "content" => "inline*" },
+    "text" => {},
+  }.freeze
+
+  CUSTOM_SCHEMA_MARKS = {
+    "link" => { "excludes" => "emoji" },
+    "bold" => {},
+    "italic" => {},
+    "emoji" => {},
+  }.freeze
+
+  def self.build
+    Prosereflect::Schema.new(
+      nodes_spec: CUSTOM_SCHEMA_NODES,
+      marks_spec: CUSTOM_SCHEMA_MARKS,
+      top_node: "doc",
+    )
+  end
+
+  def self.nodes
+    CUSTOM_SCHEMA_NODES
+  end
+
+  def self.marks
+    CUSTOM_SCHEMA_MARKS
+  end
+end

data/spec/fixtures/schema/test_schema.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "prosereflect"
+require "prosereflect/schema"
+
+# Test schema matching prosemirror-py test_schema
+# Used for testing content expressions, mark handling, etc.
+module TestSchemaFixture
+  TEST_SCHEMA_NODES = {
+    "doc" => { "content" => "block+" },
+    "paragraph" => { "content" => "inline*" },
+    "code_block" => { "content" => "text*", "marks" => "" },
+    "heading" => { "content" => "inline*", "attrs" => { "level" => { "default" => 1 } } },
+    "blockquote" => { "content" => "block+", "defining" => true },
+    "horizontal_rule" => {},
+    "text" => {},
+    "image" => { "attrs" => { "src" => {}, "alt" => { "default" => "" }, "title" => { "default" => "" } } },
+    "hard_break" => { "selectable" => false },
+    "ordered_list" => { "content" => "list_item+", "attrs" => { "order" => { "default" => 1 } }, "group" => "block" },
+    "bullet_list" => { "content" => "list_item+", "group" => "block" },
+    "list_item" => { "content" => "paragraph block*", "defining" => true },
+  }.freeze
+
+  TEST_SCHEMA_MARKS = {
+    "link" => { "attrs" => { "href" => {}, "title" => { "default" => "" } }, "inclusive" => false },
+    "em" => {},
+    "strong" => {},
+    "code" => {},
+  }.freeze
+
+  def self.build
+    Prosereflect::Schema.new(
+      nodes_spec: TEST_SCHEMA_NODES,
+      marks_spec: TEST_SCHEMA_MARKS,
+      top_node: "doc",
+    )
+  end
+
+  def self.nodes
+    TEST_SCHEMA_NODES
+  end
+
+  def self.marks
+    TEST_SCHEMA_MARKS
+  end
+end

data/spec/fixtures/test_builder/helpers.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+# TestBuilder - Port of prosemirror-py test_builder/build.py
+# Provides helpers for creating test nodes from string representations
+
+module TestBuilder
+  # Parse a test string into a document
+  # Examples:
+  #   TestBuilder.parse("doc(p(\"hello world\"))")
+  #   TestBuilder.parse("doc(p(\"hello<|a> world\"))")
+  def self.parse(str)
+    builder = Builder.new
+    builder.parse(str)
+  end
+
+  # Create a builder for a specific schema
+  def self.for_schema(schema)
+    Builder.new(schema: schema)
+  end
+
+  class Builder
+    attr_reader :schema
+
+    def initialize(schema: nil)
+      @schema = schema
+    end
+
+    def parse(str)
+      # Parse the string into a node tree
+      # This is a simplified parser for test strings like:
+      # doc(p("hello", em("world")))
+      # doc(p("hello<|a> world"))
+      content = extract_content(str)
+      return nil if content.nil?
+
+      parse_content(content)
+    end
+
+    def parse_content(str)
+      # Simple recursive descent parser for test strings
+      # Handles: doc(...), p(...), em(...), strong(...), etc.
+      # And string literals: "hello world"
+      tokens = tokenize(str)
+      parse_tokens(tokens)
+    end
+
+    private
+
+    def tokenize(str)
+      # Simple tokenizer
+      tokens = []
+      i = 0
+      while i < str.length
+        case str[i]
+        when /\s/
+          i += 1
+        when /[a-z_]/
+          # Identifier
+          start = i
+          i += 1
+          while i < str.length && str[i] =~ /[a-z0-9_]/
+            i += 1
+          end
+          tokens << [:identifier, str[start...i]]
+        when '"'
+          # String literal
+          i += 1
+          start = i
+          while i < str.length && str[i] != '"'
+            i += 1
+          end
+          tokens << [:string, str[start...i]]
+          i += 1 if i < str.length
+        when "(", ")", "<", ">", "|", ","
+          tokens << [str[i], str[i]]
+          i += 1
+        else
+          i += 1
+        end
+      end
+      tokens
+    end
+
+    def parse_tokens(tokens)
+      return nil if tokens.empty?
+
+      token = tokens.first
+      return nil unless token
+
+      if token[0] == :identifier
+        name = token[1]
+        tokens.shift
+        consume("(", tokens)
+        if name == "doc"
+          children = parse_children(tokens)
+          consume(")", tokens)
+          build_doc(children)
+        elsif name == "text"
+          str_token = tokens.shift
+          consume(")", tokens)
+          build_text(str_token ? str_token[1] : "")
+        else
+          # Assume it's a paragraph or other node
+          children = parse_children(tokens)
+          consume(")", tokens)
+          build_node(name, children)
+        end
+      elsif token[0] == :string
+        tokens.shift
+        build_text(token[1])
+      end
+    end
+
+    def parse_children(tokens)
+      children = []
+      while tokens.any? && tokens.first[0] != ")"
+        child = parse_tokens(tokens)
+        children << child if child
+        break if tokens.empty?
+
+        if tokens.first[0] == ","
+          tokens.shift
+        end
+      end
+      children
+    end
+
+    def consume(expected, tokens)
+      return if tokens.empty?
+
+      token = tokens.first
+      return unless token && token[0] == expected
+
+      tokens.shift
+    end
+
+    def build_doc(children)
+      nodes = children.flat_map do |child|
+        if child.is_a?(Array)
+          child
+        else
+          [child].compact
+        end
+      end
+      Prosereflect::Document.new(content: nodes)
+    end
+
+    def build_node(type, children)
+      case type
+      when "p"
+        content = children.flat_map do |child|
+          if child.is_a?(Prosereflect::Node)
+            [child]
+          else
+            []
+          end
+        end
+        Prosereflect::Paragraph.new(content: content)
+      when "text"
+        children.first || ""
+      else
+        # Generic node - return children as content
+        children.flatten.compact.first
+      end
+    end
+
+    def build_text(str)
+      return str if str.is_a?(String)
+
+      Prosereflect::Text.new(text: str.to_s)
+    end
+
+    def extract_content(str)
+      # Extract content between outermost parentheses
+      paren_depth = 0
+      start = nil
+      str.each_char.with_index do |char, i|
+        if char == "(" && paren_depth == 0
+          start = i + 1
+          paren_depth += 1
+        elsif char == "("
+          paren_depth += 1
+        elsif char == ")"
+          paren_depth -= 1
+          if paren_depth == 0 && start
+            return str[start...i]
+          end
+        end
+      end
+      nil
+    end
+  end
+
+  # Extract position markers from a test string
+  # Returns [content_string, positions_hash]
+  # Example: "doc(p(\"hello<|a> world<|b>\"))" => ["doc(p(\"hello world\"))", {"a" => 6, "b" => 12}]
+  def self.extract_markers(str)
+    positions = {}
+    marker_regex = /<\|([a-z0-9]+)>|<([0-9]+)>|<\|>/
+    result = str.gsub(marker_regex) do |_match|
+      if $1
+        positions[$1] = $~.offset(0)[0]
+      elsif $2
+        positions[$2.to_i] = $~.offset(0)[0]
+      else
+        positions[:cursor] = $~.offset(0)[0]
+      end
+      ""
+    end
+    [result, positions]
+  end
+end

data/spec/prosereflect/document_spec.rb

@@ -282,9 +282,9 @@ RSpec.describe Prosereflect::Document do
           "content" => [{
             "type" => "code_block",
             "attrs" => {
-              "content" => "def example\n  puts 'Hello'\nend",
               "language" => "ruby",
             },
+            "content" => ["def example\n  puts 'Hello'\nend"],
           }],
         }, {
           "type" => "blockquote",

data/spec/prosereflect/fragment_spec.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Prosereflect::Fragment do
+  describe "creation" do
+    it "creates empty fragment" do
+      frag = described_class.new
+      expect(frag.empty?).to be true
+    end
+
+    it "creates fragment with content" do
+      node = Prosereflect::Paragraph.new
+      frag = described_class.new([node])
+      expect(frag.empty?).to be false
+      expect(frag.length).to eq(1)
+    end
+
+    it "creates fragment from single node" do
+      node = Prosereflect::Text.new(text: "hello")
+      frag = described_class.new(node)
+      expect(frag.length).to eq(1)
+    end
+  end
+
+  describe ".empty" do
+    it "returns a shared empty fragment" do
+      frag1 = described_class.empty
+      frag2 = described_class.empty
+      expect(frag1).to equal(frag2)
+      expect(frag1.empty?).to be true
+    end
+  end
+
+  describe ".from" do
+    it "returns same fragment when given a fragment" do
+      frag = described_class.new
+      expect(described_class.from(frag)).to equal(frag)
+    end
+
+    it "wraps array in fragment" do
+      node = Prosereflect::Text.new(text: "x")
+      frag = described_class.from([node])
+      expect(frag).to be_a(described_class)
+      expect(frag.length).to eq(1)
+    end
+
+    it "wraps single node in fragment" do
+      node = Prosereflect::Text.new(text: "x")
+      frag = described_class.from(node)
+      expect(frag.length).to eq(1)
+    end
+  end
+
+  describe "size" do
+    it "returns 0 for empty fragment" do
+      expect(described_class.new.size).to eq(0)
+    end
+
+    it "returns total node sizes" do
+      text = Prosereflect::Text.new(text: "hello")
+      frag = described_class.new([text])
+      # text "hello" has node_size = 5 + 1 = 6
+      expect(frag.size).to eq(6)
+    end
+
+    it "sums multiple nodes" do
+      t1 = Prosereflect::Text.new(text: "ab")
+      t2 = Prosereflect::Text.new(text: "cd")
+      frag = described_class.new([t1, t2])
+      # 3 + 3 = 6
+      expect(frag.size).to eq(6)
+    end
+  end
+
+  describe "append" do
+    it "appends another fragment" do
+      t1 = Prosereflect::Text.new(text: "a")
+      t2 = Prosereflect::Text.new(text: "b")
+      frag1 = described_class.new([t1])
+      frag2 = described_class.new([t2])
+      result = frag1.append(frag2)
+      expect(result.length).to eq(2)
+    end
+
+    it "appends a single node" do
+      t1 = Prosereflect::Text.new(text: "a")
+      t2 = Prosereflect::Text.new(text: "b")
+      frag = described_class.new([t1])
+      result = frag.append(t2)
+      expect(result.length).to eq(2)
+    end
+
+    it "does not mutate original" do
+      t1 = Prosereflect::Text.new(text: "a")
+      frag = described_class.new([t1])
+      frag.append(described_class.new)
+      expect(frag.length).to eq(1)
+    end
+  end
+
+  describe "cut" do
+    it "returns empty fragment for empty cut" do
+      frag = described_class.new
+      result = frag.cut(0, 0)
+      expect(result).to be_a(described_class)
+      expect(result.empty?).to be true
+    end
+
+    it "returns empty when from >= to" do
+      text = Prosereflect::Text.new(text: "hello")
+      frag = described_class.new([text])
+      result = frag.cut(3, 3)
+      expect(result.empty?).to be true
+    end
+  end
+
+  describe "replace_child" do
+    it "replaces child at index" do
+      t1 = Prosereflect::Text.new(text: "a")
+      t2 = Prosereflect::Text.new(text: "b")
+      replacement = Prosereflect::Text.new(text: "c")
+      frag = described_class.new([t1, t2])
+      result = frag.replace_child(0, replacement)
+      expect(result[0]).to eq(replacement)
+      expect(result[1]).to eq(t2)
+    end
+
+    it "does not mutate original" do
+      t1 = Prosereflect::Text.new(text: "a")
+      replacement = Prosereflect::Text.new(text: "c")
+      frag = described_class.new([t1])
+      frag.replace_child(0, replacement)
+      expect(frag[0]).to eq(t1)
+    end
+  end
+
+  describe "index access" do
+    it "returns nil for out of bounds" do
+      frag = described_class.new
+      expect(frag[0]).to be_nil
+    end
+
+    it "returns node at index" do
+      node = Prosereflect::Text.new(text: "x")
+      frag = described_class.new([node])
+      expect(frag[0]).to eq(node)
+    end
+  end
+
+  describe "iteration" do
+    it "iterates over content" do
+      node = Prosereflect::Paragraph.new
+      frag = described_class.new([node])
+      count = 0
+      frag.each { count += 1 }
+      expect(count).to eq(1)
+    end
+
+    it "returns count" do
+      frag = described_class.new([Prosereflect::Text.new(text: "a"),
+                                  Prosereflect::Text.new(text: "b")])
+      expect(frag.count).to eq(2)
+      expect(frag.length).to eq(2)
+    end
+  end
+
+  describe "equality" do
+    it "compares equal fragments" do
+      frag1 = described_class.new
+      frag2 = described_class.new
+      expect(frag1).to eq(frag2)
+    end
+
+    it "compares unequal fragments" do
+      t1 = Prosereflect::Text.new(text: "a")
+      t2 = Prosereflect::Text.new(text: "b")
+      frag1 = described_class.new([t1])
+      frag2 = described_class.new([t2])
+      expect(frag1).not_to eq(frag2)
+    end
+  end
+
+  describe "text_between" do
+    it "extracts text from nodes in range" do
+      text = Prosereflect::Text.new(text: "hello")
+      frag = described_class.new([text])
+      expect(frag.text_between(0, 5)).to eq("hello")
+    end
+
+    it "joins multiple nodes" do
+      t1 = Prosereflect::Text.new(text: "hello")
+      t2 = Prosereflect::Text.new(text: "world")
+      frag = described_class.new([t1, t2])
+      expect(frag.text_between(0, 10)).to eq("helloworld")
+    end
+
+    it "joins with separator" do
+      t1 = Prosereflect::Text.new(text: "hello")
+      t2 = Prosereflect::Text.new(text: "world")
+      frag = described_class.new([t1, t2])
+      expect(frag.text_between(0, 10, " ")).to eq("hello world")
+    end
+  end
+
+  describe "find_diff_start" do
+    it "returns nil for identical fragments" do
+      t1 = Prosereflect::Text.new(text: "hello")
+      t2 = Prosereflect::Text.new(text: "hello")
+      frag1 = described_class.new([t1])
+      frag2 = described_class.new([t2])
+      expect(frag1.find_diff_start(frag2)).to be_nil
+    end
+
+    it "returns 0 for completely different first nodes" do
+      t1 = Prosereflect::Text.new(text: "a")
+      t2 = Prosereflect::Text.new(text: "b")
+      frag1 = described_class.new([t1])
+      frag2 = described_class.new([t2])
+      expect(frag1.find_diff_start(frag2)).to eq(0)
+    end
+
+    it "returns position where fragments differ" do
+      t1 = Prosereflect::Text.new(text: "hello")
+      t2 = Prosereflect::Text.new(text: "hello")
+      t3 = Prosereflect::Text.new(text: "world")
+      frag1 = described_class.new([t1])
+      frag2 = described_class.new([t2, t3])
+      # Same first node, but different lengths
+      expect(frag1.find_diff_start(frag2)).to eq(6) # node_size of "hello"
+    end
+  end
+
+  describe "find_diff_end" do
+    it "returns nil for identical fragments" do
+      t1 = Prosereflect::Text.new(text: "hello")
+      t2 = Prosereflect::Text.new(text: "hello")
+      frag1 = described_class.new([t1])
+      frag2 = described_class.new([t2])
+      expect(frag1.find_diff_end(frag2)).to be_nil
+    end
+
+    it "returns position where trailing content differs" do
+      t1 = Prosereflect::Text.new(text: "ab")
+      t2 = Prosereflect::Text.new(text: "cd")
+      t3 = Prosereflect::Text.new(text: "ef")
+      frag1 = described_class.new([t1, t2])
+      frag2 = described_class.new([t3, t2])
+      # The last nodes ("cd") are the same, first nodes differ
+      # find_diff_end walks backward from the end and returns where they differ
+      result = frag1.find_diff_end(frag2)
+      expect(result).not_to be_nil
+    end
+  end
+
+  describe "to_a" do
+    it "returns a copy of the content array" do
+      node = Prosereflect::Text.new(text: "x")
+      frag = described_class.new([node])
+      arr = frag.to_a
+      expect(arr).to eq([node])
+      expect(arr).not_to equal(frag.content)
+    end
+  end
+
+  describe "to_s / inspect" do
+    it "returns string representation" do
+      frag = described_class.new([Prosereflect::Text.new(text: "x")])
+      expect(frag.to_s).to include("Fragment")
+      expect(frag.inspect).to eq(frag.to_s)
+    end
+  end
+end