prosereflect 0.1.1 → 0.3.0

data/spec/prosereflect/node_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Prosereflect::Node do
-  describe 'initialization' do
-    it 'initializes with empty data' do
+  describe "initialization" do
+    it "initializes with empty data" do
       node = described_class.new
       expect(node.type).to be_nil
       expect(node.attrs).to be_nil
@@ -13,29 +13,29 @@ RSpec.describe Prosereflect::Node do
     end
 
     # TODO: Update to lutaml-model
-    it 'initializes with provided data' do
+    it "initializes with provided data" do
       data = {
-        'type' => 'test_node',
-        'attrs' => { 'key' => 'value' },
-        'marks' => [{ 'type' => 'bold' }]
+        "type" => "test_node",
+        "attrs" => { "key" => "value" },
+        "marks" => [{ "type" => "bold" }],
       }
       node = described_class.new(data)
-      expect(node.type).to eq('test_node')
-      expect(node.attrs).to eq({ 'key' => 'value' })
-      expect(node.marks).to eq([{ 'type' => 'bold' }])
+      expect(node.type).to eq("test_node")
+      expect(node.attrs).to eq({ "key" => "value" })
+      expect(node.marks).to eq([{ "type" => "bold" }])
     end
   end
 
-  describe '#parse_content' do
-    it 'returns empty array for nil content' do
+  describe "#parse_content" do
+    it "returns empty array for nil content" do
       node = described_class.new
       expect(node.parse_content(nil)).to eq([])
     end
 
-    it 'parses content items using Parser' do
+    it "parses content items using Parser" do
       content_data = [
-        { 'type' => 'text', 'text' => 'Hello' },
-        { 'type' => 'hard_break' }
+        { "type" => "text", "text" => "Hello" },
+        { "type" => "hard_break" },
       ]
 
       node = described_class.new
@@ -47,51 +47,52 @@ RSpec.describe Prosereflect::Node do
     end
   end
 
-  describe '#to_h' do
-    it 'creates a hash representation with basic properties' do
-      node = described_class.new({ 'type' => 'test_node' })
+  describe "#to_h" do
+    it "creates a hash representation with basic properties" do
+      node = described_class.new({ "type" => "test_node" })
       hash = node.to_hash
 
       expect(hash).to be_a(Hash)
-      expect(hash['type']).to eq('test_node')
+      expect(hash["type"]).to eq("test_node")
     end
 
-    it 'includes attrs when present' do
+    it "includes attrs when present" do
       node = described_class.new(
-        type: Prosereflect::Text.new(text: 'Hello'),
-        attrs: [Prosereflect::Attribute::Href.new('https://example.com')]
+        type: Prosereflect::Text.new(text: "Hello"),
+        attrs: [Prosereflect::Attribute::Href.new("https://example.com")],
       )
 
       hash = node.to_hash
-      expect(hash['attrs']).to eq([{ 'href' => 'https://example.com' }])
+      expect(hash["attrs"]).to eq([{ "href" => "https://example.com" }])
     end
 
-    it 'includes marks when present' do
+    it "includes marks when present" do
       node = described_class.new(
-        type: Prosereflect::Text.new(text: 'Hello'),
-        marks: [Prosereflect::Mark::Bold.new]
+        type: Prosereflect::Text.new(text: "Hello"),
+        marks: [Prosereflect::Mark::Bold.new],
       )
 
       hash = node.to_hash
-      expect(hash['marks']).to eq([{ 'type' => 'bold' }])
+      expect(hash["marks"]).to eq([{ "type" => "bold" }])
     end
 
-    it 'includes content when present' do
+    it "includes content when present" do
       node = described_class.new({
-                                   'type' => 'test_node',
-                                   'content' => [{ 'type' => 'text', 'text' => 'Hello' }]
+                                   "type" => "test_node",
+                                   "content" => [{ "type" => "text",
+                                                   "text" => "Hello" }],
                                  })
 
       hash = node.to_hash
-      expect(hash['content']).to be_an(Array)
-      expect(hash['content'][0]['type']).to eq('text')
+      expect(hash["content"]).to be_an(Array)
+      expect(hash["content"][0]["type"]).to eq("text")
     end
   end
 
-  describe '#add_child' do
-    it 'adds a child node to content' do
-      parent = described_class.new({ 'type' => 'parent' })
-      child = described_class.new({ 'type' => 'child' })
+  describe "#add_child" do
+    it "adds a child node to content" do
+      parent = described_class.new({ "type" => "parent" })
+      child = described_class.new({ "type" => "child" })
 
       parent.add_child(child)
 
@@ -99,9 +100,9 @@ RSpec.describe Prosereflect::Node do
       expect(parent.content[0]).to eq(child)
     end
 
-    it 'returns the added child' do
-      parent = described_class.new({ 'type' => 'parent' })
-      child = described_class.new({ 'type' => 'child' })
+    it "returns the added child" do
+      parent = described_class.new({ "type" => "parent" })
+      child = described_class.new({ "type" => "child" })
 
       result = parent.add_child(child)
 
@@ -109,239 +110,239 @@ RSpec.describe Prosereflect::Node do
     end
   end
 
-  describe '#find_first' do
+  describe "#find_first" do
     let(:node) do
-      root = described_class.new({ 'type' => 'root' })
-      para = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
-      text = Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Hello' })
+      root = described_class.new({ "type" => "root" })
+      para = Prosereflect::Paragraph.new({ "type" => "paragraph" })
+      text = Prosereflect::Text.new({ "type" => "text", "text" => "Hello" })
 
       para.add_child(text)
       root.add_child(para)
       root
     end
 
-    it 'returns self if type matches' do
-      result = node.find_first('root')
+    it "returns self if type matches" do
+      result = node.find_first("root")
       expect(result).to eq(node)
     end
 
-    it 'finds a child node by type' do
-      result = node.find_first('paragraph')
+    it "finds a child node by type" do
+      result = node.find_first("paragraph")
       expect(result).to be_a(Prosereflect::Paragraph)
     end
 
-    it 'finds a nested node by type' do
-      result = node.find_first('text')
+    it "finds a nested node by type" do
+      result = node.find_first("text")
       expect(result).to be_a(Prosereflect::Text)
     end
 
-    it 'returns nil if no matching node is found' do
-      result = node.find_first('nonexistent')
+    it "returns nil if no matching node is found" do
+      result = node.find_first("nonexistent")
       expect(result).to be_nil
     end
   end
 
-  describe '.create' do
-    it 'creates a simple node' do
-      node = described_class.create('test_node')
+  describe ".create" do
+    it "creates a simple node" do
+      node = described_class.create("test_node")
 
       expected = {
-        'type' => 'test_node'
+        "type" => "test_node",
       }
 
       expect(node.to_h).to eq(expected)
     end
 
-    it 'creates a node with attributes' do
-      node = described_class.create('test_node', {
-                                      'key' => 'value',
-                                      'number' => 42,
-                                      'flag' => true
+    it "creates a node with attributes" do
+      node = described_class.create("test_node", {
+                                      "key" => "value",
+                                      "number" => 42,
+                                      "flag" => true,
                                     })
 
       expected = {
-        'type' => 'test_node',
-        'attrs' => {
-          'key' => 'value',
-          'number' => 42,
-          'flag' => true
-        }
+        "type" => "test_node",
+        "attrs" => {
+          "key" => "value",
+          "number" => 42,
+          "flag" => true,
+        },
       }
 
       expect(node.to_h).to eq(expected)
     end
   end
 
-  describe 'node structure' do
-    it 'creates a node with content' do
-      node = described_class.create('parent')
-      node.add_child(Prosereflect::Text.create('First child'))
-      node.add_child(Prosereflect::Text.create('Second child'))
+  describe "node structure" do
+    it "creates a node with content" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("First child"))
+      node.add_child(Prosereflect::Text.create("Second child"))
 
       expected = {
-        'type' => 'parent',
-        'content' => [
+        "type" => "parent",
+        "content" => [
           {
-            'type' => 'text',
-            'text' => 'First child'
+            "type" => "text",
+            "text" => "First child",
           },
           {
-            'type' => 'text',
-            'text' => 'Second child'
-          }
-        ]
+            "type" => "text",
+            "text" => "Second child",
+          },
+        ],
       }
 
       expect(node.to_h).to eq(expected)
     end
 
-    it 'creates a node with complex content' do
-      node = described_class.create('root')
+    it "creates a node with complex content" do
+      node = described_class.create("root")
 
       # Add a paragraph with formatted text
       para = Prosereflect::Paragraph.create
-      para.add_child(Prosereflect::Text.create('Bold', [Prosereflect::Mark::Bold.create]))
-      para.add_child(Prosereflect::Text.create(' and '))
-      para.add_child(Prosereflect::Text.create('italic', [Prosereflect::Mark::Italic.create]))
+      para.add_child(Prosereflect::Text.create("Bold", [Prosereflect::Mark::Bold.create]))
+      para.add_child(Prosereflect::Text.create(" and "))
+      para.add_child(Prosereflect::Text.create("italic", [Prosereflect::Mark::Italic.create]))
       node.add_child(para)
 
       # Add a list
       list = Prosereflect::BulletList.create
       list_item = Prosereflect::ListItem.create
       list_item.add_child(Prosereflect::Paragraph.create)
-      list_item.content.first.add_child(Prosereflect::Text.create('List item'))
+      list_item.content.first.add_child(Prosereflect::Text.create("List item"))
       list.add_child(list_item)
       node.add_child(list)
 
       expected = {
-        'type' => 'root',
-        'content' => [
+        "type" => "root",
+        "content" => [
           {
-            'type' => 'paragraph',
-            'content' => [
+            "type" => "paragraph",
+            "content" => [
               {
-                'type' => 'text',
-                'text' => 'Bold',
-                'marks' => [{ 'type' => 'bold' }]
+                "type" => "text",
+                "text" => "Bold",
+                "marks" => [{ "type" => "bold" }],
               },
               {
-                'type' => 'text',
-                'text' => ' and '
+                "type" => "text",
+                "text" => " and ",
               },
               {
-                'type' => 'text',
-                'text' => 'italic',
-                'marks' => [{ 'type' => 'italic' }]
-              }
-            ]
+                "type" => "text",
+                "text" => "italic",
+                "marks" => [{ "type" => "italic" }],
+              },
+            ],
           },
           {
-            'type' => 'bullet_list',
-            'attrs' => {
-              'bullet_style' => nil
+            "type" => "bullet_list",
+            "attrs" => {
+              "bullet_style" => nil,
             },
-            'content' => [
+            "content" => [
               {
-                'type' => 'list_item',
-                'content' => [
+                "type" => "list_item",
+                "content" => [
                   {
-                    'type' => 'paragraph',
-                    'content' => [
+                    "type" => "paragraph",
+                    "content" => [
                       {
-                        'type' => 'text',
-                        'text' => 'List item'
-                      }
-                    ]
-                  }
-                ]
-              }
-            ]
-          }
-        ]
+                        "type" => "text",
+                        "text" => "List item",
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
       }
 
       expect(node.to_h).to eq(expected)
     end
   end
 
-  describe 'node operations' do
-    describe '#add_child' do
-      it 'adds a child node and returns it' do
-        parent = described_class.create('parent')
-        child = Prosereflect::Text.create('Child node')
+  describe "node operations" do
+    describe "#add_child" do
+      it "adds a child node and returns it" do
+        parent = described_class.create("parent")
+        child = Prosereflect::Text.create("Child node")
 
         result = parent.add_child(child)
         expect(result).to eq(child)
         expect(parent.content).to eq([child])
       end
 
-      it 'maintains child order' do
-        parent = described_class.create('parent')
-        first = Prosereflect::Text.create('First')
-        second = Prosereflect::Text.create('Second')
-        third = Prosereflect::Text.create('Third')
+      it "maintains child order" do
+        parent = described_class.create("parent")
+        first = Prosereflect::Text.create("First")
+        second = Prosereflect::Text.create("Second")
+        third = Prosereflect::Text.create("Third")
 
         parent.add_child(first)
         parent.add_child(second)
         parent.add_child(third)
 
         expect(parent.content).to eq([first, second, third])
-        expect(parent.text_content).to eq('FirstSecondThird')
+        expect(parent.text_content).to eq("FirstSecondThird")
       end
     end
 
-    describe '#find_first' do
+    describe "#find_first" do
       let(:node) do
-        root = described_class.create('root')
+        root = described_class.create("root")
         para = Prosereflect::Paragraph.create
-        text = Prosereflect::Text.create('Hello')
+        text = Prosereflect::Text.create("Hello")
         para.add_child(text)
         root.add_child(para)
         root
       end
 
-      it 'finds nodes by type' do
-        expect(node.find_first('root')).to eq(node)
-        expect(node.find_first('paragraph')).to be_a(Prosereflect::Paragraph)
-        expect(node.find_first('text')).to be_a(Prosereflect::Text)
-        expect(node.find_first('nonexistent')).to be_nil
+      it "finds nodes by type" do
+        expect(node.find_first("root")).to eq(node)
+        expect(node.find_first("paragraph")).to be_a(Prosereflect::Paragraph)
+        expect(node.find_first("text")).to be_a(Prosereflect::Text)
+        expect(node.find_first("nonexistent")).to be_nil
       end
     end
 
-    describe '#find_all' do
+    describe "#find_all" do
       let(:node) do
-        root = described_class.create('root')
+        root = described_class.create("root")
 
         # First paragraph
         para1 = Prosereflect::Paragraph.create
-        para1.add_child(Prosereflect::Text.create('First'))
+        para1.add_child(Prosereflect::Text.create("First"))
         root.add_child(para1)
 
         # Second paragraph
         para2 = Prosereflect::Paragraph.create
-        para2.add_child(Prosereflect::Text.create('Second'))
+        para2.add_child(Prosereflect::Text.create("Second"))
         root.add_child(para2)
 
         root
       end
 
-      it 'finds all nodes of a type' do
-        expect(node.find_all('paragraph').size).to eq(2)
-        expect(node.find_all('text').size).to eq(2)
-        expect(node.find_all('nonexistent')).to eq([])
+      it "finds all nodes of a type" do
+        expect(node.find_all("paragraph").size).to eq(2)
+        expect(node.find_all("text").size).to eq(2)
+        expect(node.find_all("nonexistent")).to eq([])
       end
     end
 
-    describe '#find_children' do
+    describe "#find_children" do
       let(:node) do
-        root = described_class.create('root')
+        root = described_class.create("root")
         root.add_child(Prosereflect::Paragraph.create)
         root.add_child(Prosereflect::Table.create)
         root.add_child(Prosereflect::Paragraph.create)
         root
       end
 
-      it 'finds direct children by class' do
+      it "finds direct children by class" do
         paragraphs = node.find_children(Prosereflect::Paragraph)
         expect(paragraphs.size).to eq(2)
         expect(paragraphs).to all(be_a(Prosereflect::Paragraph))
@@ -352,74 +353,202 @@ RSpec.describe Prosereflect::Node do
       end
     end
 
-    describe '#text_content' do
-      it 'concatenates text from all children' do
-        root = described_class.create('root')
+    describe "#text_content" do
+      it "concatenates text from all children" do
+        root = described_class.create("root")
 
         para = Prosereflect::Paragraph.create
-        para.add_child(Prosereflect::Text.create('Hello'))
+        para.add_child(Prosereflect::Text.create("Hello"))
         para.add_child(Prosereflect::HardBreak.create)
-        para.add_child(Prosereflect::Text.create('World'))
+        para.add_child(Prosereflect::Text.create("World"))
         root.add_child(para)
 
         expect(root.text_content).to eq("Hello\nWorld")
       end
 
-      it 'returns empty string for empty node' do
-        node = described_class.create('empty')
-        expect(node.text_content).to eq('')
+      it "returns empty string for empty node" do
+        node = described_class.create("empty")
+        expect(node.text_content).to eq("")
       end
     end
   end
 
-  describe 'serialization' do
-    it 'serializes a node with all properties' do
-      node = described_class.create('test_node', {
-                                      'key' => 'value',
-                                      'number' => 42
+  describe "serialization" do
+    it "serializes a node with all properties" do
+      node = described_class.create("test_node", {
+                                      "key" => "value",
+                                      "number" => 42,
                                     })
 
-      text = Prosereflect::Text.create('Content', [
+      text = Prosereflect::Text.create("Content", [
                                          Prosereflect::Mark::Bold.create,
-                                         Prosereflect::Mark::Link.create({ 'href' => 'https://example.com' })
+                                         Prosereflect::Mark::Link.create({ "href" => "https://example.com" }),
                                        ])
 
       node.add_child(text)
 
       expected = {
-        'type' => 'test_node',
-        'attrs' => {
-          'key' => 'value',
-          'number' => 42
+        "type" => "test_node",
+        "attrs" => {
+          "key" => "value",
+          "number" => 42,
         },
-        'content' => [
+        "content" => [
           {
-            'type' => 'text',
-            'text' => 'Content',
-            'marks' => [
-              { 'type' => 'bold' },
+            "type" => "text",
+            "text" => "Content",
+            "marks" => [
+              { "type" => "bold" },
               {
-                'type' => 'link',
-                'attrs' => {
-                  'href' => 'https://example.com'
-                }
-              }
-            ]
-          }
-        ]
+                "type" => "link",
+                "attrs" => {
+                  "href" => "https://example.com",
+                },
+              },
+            ],
+          },
+        ],
       }
 
       expect(node.to_h).to eq(expected)
     end
 
-    it 'omits optional properties when empty' do
-      node = described_class.create('test_node')
+    it "omits optional properties when empty" do
+      node = described_class.create("test_node")
 
       expected = {
-        'type' => 'test_node'
+        "type" => "test_node",
       }
 
       expect(node.to_h).to eq(expected)
     end
   end
+
+  describe "#node_size" do
+    it "returns 1 for empty node" do
+      node = described_class.create("empty")
+      expect(node.node_size).to eq(1)
+    end
+
+    it "includes text children" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("hello"))
+      # 1 (parent) + 6 (text "hello") = 7
+      expect(node.node_size).to eq(7)
+    end
+
+    it "sums multiple children" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("ab"))
+      node.add_child(Prosereflect::Text.create("cd"))
+      # 1 (parent) + 3 ("ab") + 3 ("cd") = 7
+      expect(node.node_size).to eq(7)
+    end
+
+    it "handles deeply nested content" do
+      doc = Prosereflect::Document.create
+      para = Prosereflect::Paragraph.create
+      para.add_child(Prosereflect::Text.create("hi"))
+      doc.add_child(para)
+      # 1 (doc) + 1 (para) + 3 (text "hi") = 5
+      expect(doc.node_size).to eq(5)
+    end
+  end
+
+  describe "#text?" do
+    it "returns false for regular nodes" do
+      expect(described_class.create("node").text?).to be false
+      expect(Prosereflect::Paragraph.create.text?).to be false
+      expect(Prosereflect::Document.create.text?).to be false
+    end
+
+    it "returns true for Text nodes" do
+      expect(Prosereflect::Text.create("hello").text?).to be true
+    end
+  end
+
+  describe "#cut" do
+    it "returns self for full range" do
+      node = described_class.create("node")
+      expect(node.cut(0, 1)).to eq(node)
+    end
+
+    it "returns self for default range" do
+      node = described_class.create("node")
+      expect(node.cut).to eq(node)
+    end
+
+    it "returns copy with subset of content" do
+      node = described_class.create("parent")
+      node.add_child(Prosereflect::Text.create("first"))
+      node.add_child(Prosereflect::Text.create("second"))
+      cut_node = node.cut(0, 1 + 7) # 1 parent + first text (7)
+      expect(cut_node).not_to eq(node)
+    end
+  end
+
+  describe "#nodes_between" do
+    it "yields children in range" do
+      node = described_class.create("parent")
+      t1 = Prosereflect::Text.create("ab")
+      t2 = Prosereflect::Text.create("cd")
+      node.add_child(t1)
+      node.add_child(t2)
+
+      visited = []
+      node.nodes_between(0, 6) { |n, _pos, _i| visited << n }
+      expect(visited).to include(t1)
+    end
+
+    it "does not yield for empty range" do
+      node = described_class.create("parent")
+      visited = []
+      node.nodes_between(0, 0) { |n| visited << n }
+      expect(visited).to be_empty
+    end
+  end
+
+  describe "#descendants" do
+    it "iterates over all descendants" do
+      doc = Prosereflect::Document.create
+      para = Prosereflect::Paragraph.create
+      text = Prosereflect::Text.create("hello")
+      para.add_child(text)
+      doc.add_child(para)
+
+      visited = []
+      doc.descendants { |n, _pos, _i| visited << n }
+      expect(visited).to include(para)
+    end
+  end
+
+  describe "#eq?" do
+    it "returns true for structurally equal nodes" do
+      n1 = described_class.create("node")
+      n2 = described_class.create("node")
+      expect(n1.eq?(n2)).to be true
+    end
+
+    it "returns false for different types" do
+      n1 = described_class.create("a")
+      n2 = described_class.create("b")
+      expect(n1.eq?(n2)).to be false
+    end
+  end
+
+  describe "#copy" do
+    it "creates a shallow copy with same type and attrs" do
+      node = described_class.create("node", "key" => "val")
+      copy = node.copy
+      expect(copy.to_h).to eq(node.to_h)
+      expect(copy).not_to equal(node)
+    end
+
+    it "creates copy with new content" do
+      node = described_class.create("parent")
+      copy = node.copy([Prosereflect::Text.create("new")])
+      expect(copy.content.length).to eq(1)
+      expect(node.content).to be_empty
+    end
+  end
 end