prosereflect 0.1.1 → 0.3.0

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

data/spec/prosereflect/hard_break_spec.rb

@@ -1,247 +1,247 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Prosereflect::HardBreak do
-  describe 'initialization' do
-    it 'initializes as a hard_break node' do
-      break_node = described_class.new({ 'type' => 'hard_break' })
-      expect(break_node.type).to eq('hard_break')
+  describe "initialization" do
+    it "initializes as a hard_break node" do
+      break_node = described_class.new({ "type" => "hard_break" })
+      expect(break_node.type).to eq("hard_break")
     end
   end
 
-  describe '.create' do
-    it 'creates a simple hard break' do
+  describe ".create" do
+    it "creates a simple hard break" do
       break_node = described_class.create
 
       expected = {
-        'type' => 'hard_break'
+        "type" => "hard_break",
       }
 
       expect(break_node.to_h).to eq(expected)
     end
 
-    it 'creates a hard break with a single mark' do
+    it "creates a hard break with a single mark" do
       break_node = described_class.create
-      break_node.marks = [{ 'type' => 'bold' }]
+      break_node.marks = [{ "type" => "bold" }]
 
       expected = {
-        'type' => 'hard_break',
-        'marks' => [{
-          'type' => 'bold'
-        }]
+        "type" => "hard_break",
+        "marks" => [{
+          "type" => "bold",
+        }],
       }
 
       expect(break_node.to_h).to eq(expected)
     end
 
-    it 'creates a hard break with multiple marks' do
+    it "creates a hard break with multiple marks" do
       break_node = described_class.create
       break_node.marks = [
-        { 'type' => 'bold' },
-        { 'type' => 'italic' },
-        { 'type' => 'strike' }
+        { "type" => "bold" },
+        { "type" => "italic" },
+        { "type" => "strike" },
       ]
 
       expected = {
-        'type' => 'hard_break',
-        'marks' => [{
-          'type' => 'bold'
+        "type" => "hard_break",
+        "marks" => [{
+          "type" => "bold",
         }, {
-          'type' => 'italic'
+          "type" => "italic",
         }, {
-          'type' => 'strike'
-        }]
+          "type" => "strike",
+        }],
       }
 
       expect(break_node.to_h).to eq(expected)
     end
   end
 
-  describe 'in document context' do
-    it 'works in a paragraph with mixed content' do
+  describe "in document context" do
+    it "works in a paragraph with mixed content" do
       paragraph = Prosereflect::Paragraph.new
-      paragraph.add_text('First line')
+      paragraph.add_text("First line")
       paragraph.add_hard_break
-      paragraph.add_text('Second line with ')
-      paragraph.add_text('bold', [Prosereflect::Mark::Bold.new])
+      paragraph.add_text("Second line with ")
+      paragraph.add_text("bold", [Prosereflect::Mark::Bold.new])
       paragraph.add_hard_break
-      paragraph.add_text('Third line')
+      paragraph.add_text("Third line")
 
       expected = {
-        'type' => 'paragraph',
-        'content' => [{
-          'type' => 'text',
-          'text' => 'First line'
+        "type" => "paragraph",
+        "content" => [{
+          "type" => "text",
+          "text" => "First line",
         }, {
-          'type' => 'hard_break'
+          "type" => "hard_break",
         }, {
-          'type' => 'text',
-          'text' => 'Second line with '
+          "type" => "text",
+          "text" => "Second line with ",
         }, {
-          'type' => 'text',
-          'text' => 'bold',
-          'marks' => [{
-            'type' => 'bold'
-          }]
+          "type" => "text",
+          "text" => "bold",
+          "marks" => [{
+            "type" => "bold",
+          }],
         }, {
-          'type' => 'hard_break'
+          "type" => "hard_break",
         }, {
-          'type' => 'text',
-          'text' => 'Third line'
-        }]
+          "type" => "text",
+          "text" => "Third line",
+        }],
       }
 
       expect(paragraph.to_h).to eq(expected)
     end
 
-    it 'works in a list item with multiple breaks' do
+    it "works in a list item with multiple breaks" do
       list = Prosereflect::BulletList.new
-      item = list.add_item('First part')
-      item.add_hard_break([{ 'type' => 'strike' }])
-      item.add_text('Second part')
+      item = list.add_item("First part")
+      item.add_hard_break([{ "type" => "strike" }])
+      item.add_text("Second part")
       item.add_hard_break
-      item.add_text('Third part')
+      item.add_text("Third part")
 
       expected = {
-        'type' => 'bullet_list',
-        'attrs' => {
-          'bullet_style' => nil
+        "type" => "bullet_list",
+        "attrs" => {
+          "bullet_style" => nil,
         },
-        'content' => [{
-          'type' => 'list_item',
-          'content' => [{
-            'type' => 'paragraph',
-            'content' => [{
-              'type' => 'text',
-              'text' => 'First part'
+        "content" => [{
+          "type" => "list_item",
+          "content" => [{
+            "type" => "paragraph",
+            "content" => [{
+              "type" => "text",
+              "text" => "First part",
             }, {
-              'type' => 'hard_break',
-              'marks' => [{
-                'type' => 'strike'
-              }]
+              "type" => "hard_break",
+              "marks" => [{
+                "type" => "strike",
+              }],
             }, {
-              'type' => 'text',
-              'text' => 'Second part'
+              "type" => "text",
+              "text" => "Second part",
             }, {
-              'type' => 'hard_break'
+              "type" => "hard_break",
             }, {
-              'type' => 'text',
-              'text' => 'Third part'
-            }]
-          }]
-        }]
+              "type" => "text",
+              "text" => "Third part",
+            }],
+          }],
+        }],
       }
 
       expect(list.to_h).to eq(expected)
     end
 
-    it 'works in a table cell with multiple paragraphs' do
+    it "works in a table cell with multiple paragraphs" do
       cell = Prosereflect::TableCell.new
-      para1 = cell.add_paragraph('First paragraph')
+      para1 = cell.add_paragraph("First paragraph")
       para1.add_hard_break
-      para1.add_text('continues here')
+      para1.add_text("continues here")
 
-      para2 = cell.add_paragraph('Second paragraph')
+      para2 = cell.add_paragraph("Second paragraph")
       para2.add_hard_break([Prosereflect::Mark::Italic.new])
-      para2.add_text('with style')
+      para2.add_text("with style")
 
       expected = {
-        'type' => 'table_cell',
-        'content' => [{
-          'type' => 'paragraph',
-          'content' => [{
-            'type' => 'text',
-            'text' => 'First paragraph'
+        "type" => "table_cell",
+        "content" => [{
+          "type" => "paragraph",
+          "content" => [{
+            "type" => "text",
+            "text" => "First paragraph",
           }, {
-            'type' => 'hard_break'
+            "type" => "hard_break",
           }, {
-            'type' => 'text',
-            'text' => 'continues here'
-          }]
+            "type" => "text",
+            "text" => "continues here",
+          }],
         }, {
-          'type' => 'paragraph',
-          'content' => [{
-            'type' => 'text',
-            'text' => 'Second paragraph'
+          "type" => "paragraph",
+          "content" => [{
+            "type" => "text",
+            "text" => "Second paragraph",
           }, {
-            'type' => 'hard_break',
-            'marks' => [{
-              'type' => 'italic'
-            }]
+            "type" => "hard_break",
+            "marks" => [{
+              "type" => "italic",
+            }],
           }, {
-            'type' => 'text',
-            'text' => 'with style'
-          }]
-        }]
+            "type" => "text",
+            "text" => "with style",
+          }],
+        }],
       }
 
       expect(cell.to_h).to eq(expected)
     end
   end
 
-  describe '#text_content' do
-    it 'returns a newline character' do
+  describe "#text_content" do
+    it "returns a newline character" do
       break_node = described_class.new
       expect(break_node.text_content).to eq("\n")
     end
 
-    it 'returns a newline character regardless of marks' do
+    it "returns a newline character regardless of marks" do
       break_node = described_class.create(marks: [
                                             Prosereflect::Mark::Bold.new,
-                                            Prosereflect::Mark::Italic.new
+                                            Prosereflect::Mark::Italic.new,
                                           ])
       expect(break_node.text_content).to eq("\n")
     end
 
-    it 'properly formats text in a paragraph with multiple breaks' do
+    it "properly formats text in a paragraph with multiple breaks" do
       paragraph = Prosereflect::Paragraph.new
-      paragraph.add_text('Line 1')
+      paragraph.add_text("Line 1")
       paragraph.add_hard_break
-      paragraph.add_text('Line 2')
+      paragraph.add_text("Line 2")
       paragraph.add_hard_break
-      paragraph.add_text('Line 3')
+      paragraph.add_text("Line 3")
 
       expect(paragraph.text_content).to eq("Line 1\nLine 2\nLine 3")
     end
   end
 
-  describe 'serialization' do
-    it 'preserves mark order in serialization' do
+  describe "serialization" do
+    it "preserves mark order in serialization" do
       break_node = described_class.create
       break_node.marks = [
-        { 'type' => 'bold' },
-        { 'type' => 'italic' },
-        { 'type' => 'strike' },
-        { 'type' => 'underline' }
+        { "type" => "bold" },
+        { "type" => "italic" },
+        { "type" => "strike" },
+        { "type" => "underline" },
       ]
 
       expected = {
-        'type' => 'hard_break',
-        'marks' => [{
-          'type' => 'bold'
+        "type" => "hard_break",
+        "marks" => [{
+          "type" => "bold",
         }, {
-          'type' => 'italic'
+          "type" => "italic",
         }, {
-          'type' => 'strike'
+          "type" => "strike",
         }, {
-          'type' => 'underline'
-        }]
+          "type" => "underline",
+        }],
       }
 
       expect(break_node.to_h).to eq(expected)
     end
 
-    it 'handles empty marks array' do
+    it "handles empty marks array" do
       break_node = described_class.create
       break_node.marks = []
-      expect(break_node.to_h).to eq({ 'type' => 'hard_break' })
+      expect(break_node.to_h).to eq({ "type" => "hard_break" })
     end
 
-    it 'excludes marks when nil' do
+    it "excludes marks when nil" do
       break_node = described_class.create
       break_node.marks = nil
-      expect(break_node.to_h).to eq({ 'type' => 'hard_break' })
+      expect(break_node.to_h).to eq({ "type" => "hard_break" })
     end
   end
 end