prosereflect 0.1.0 → 0.1.1

data/spec/prosereflect/node_spec.rb

@@ -1,15 +1,18 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
 RSpec.describe Prosereflect::Node 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
-      expect(node.content).to eq([])
+      expect(node.content).to be_nil
       expect(node.marks).to be_nil
     end
 
+    # TODO: Update to lutaml-model
     it 'initializes with provided data' do
       data = {
         'type' => 'test_node',
@@ -47,29 +50,29 @@ RSpec.describe Prosereflect::Node do
   describe '#to_h' do
     it 'creates a hash representation with basic properties' do
       node = described_class.new({ 'type' => 'test_node' })
-      hash = node.to_h
+      hash = node.to_hash
 
       expect(hash).to be_a(Hash)
       expect(hash['type']).to eq('test_node')
     end
 
     it 'includes attrs when present' do
-      node = described_class.new({
-                                   'type' => 'test_node',
-                                   'attrs' => { 'key' => 'value' }
-                                 })
+      node = described_class.new(
+        type: Prosereflect::Text.new(text: 'Hello'),
+        attrs: [Prosereflect::Attribute::Href.new('https://example.com')]
+      )
 
-      hash = node.to_h
-      expect(hash['attrs']).to eq({ 'key' => 'value' })
+      hash = node.to_hash
+      expect(hash['attrs']).to eq([{ 'href' => 'https://example.com' }])
     end
 
     it 'includes marks when present' do
-      node = described_class.new({
-                                   'type' => 'test_node',
-                                   'marks' => [{ 'type' => 'bold' }]
-                                 })
+      node = described_class.new(
+        type: Prosereflect::Text.new(text: 'Hello'),
+        marks: [Prosereflect::Mark::Bold.new]
+      )
 
-      hash = node.to_h
+      hash = node.to_hash
       expect(hash['marks']).to eq([{ 'type' => 'bold' }])
     end
 
@@ -79,7 +82,7 @@ RSpec.describe Prosereflect::Node do
                                    'content' => [{ 'type' => 'text', 'text' => 'Hello' }]
                                  })
 
-      hash = node.to_h
+      hash = node.to_hash
       expect(hash['content']).to be_an(Array)
       expect(hash['content'][0]['type']).to eq('text')
     end
@@ -139,118 +142,284 @@ RSpec.describe Prosereflect::Node do
   end
 
   describe '.create' do
-    it 'creates a node with the specified type' do
+    it 'creates a simple node' do
       node = described_class.create('test_node')
-      expect(node.type).to eq('test_node')
+
+      expected = {
+        'type' => 'test_node'
+      }
+
+      expect(node.to_h).to eq(expected)
     end
 
     it 'creates a node with attributes' do
-      attrs = { 'key' => 'value' }
-      node = described_class.create('test_node', attrs)
+      node = described_class.create('test_node', {
+                                      'key' => 'value',
+                                      'number' => 42,
+                                      'flag' => true
+                                    })
 
-      expect(node.type).to eq('test_node')
-      expect(node.attrs).to eq(attrs)
-    end
+      expected = {
+        'type' => 'test_node',
+        'attrs' => {
+          'key' => 'value',
+          'number' => 42,
+          'flag' => true
+        }
+      }
 
-    it 'initializes with empty content' do
-      node = described_class.create('test_node')
-      expect(node.content).to eq([])
+      expect(node.to_h).to eq(expected)
     end
   end
 
-  describe '#find_all' do
-    let(:node) do
-      root = described_class.new({ 'type' => 'root' })
+  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' => 'text',
+            'text' => 'First child'
+          },
+          {
+            'type' => 'text',
+            'text' => 'Second child'
+          }
+        ]
+      }
 
-      para1 = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
-      para1.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Text 1' }))
+      expect(node.to_h).to eq(expected)
+    end
 
-      para2 = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
-      para2.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Text 2' }))
+    it 'creates a node with complex content' do
+      node = described_class.create('root')
 
-      root.add_child(para1)
-      root.add_child(para2)
-      root
-    end
+      # 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]))
+      node.add_child(para)
 
-    it 'finds all nodes of a specific type' do
-      paragraphs = node.find_all('paragraph')
-      expect(paragraphs.size).to eq(2)
-      expect(paragraphs).to all(be_a(Prosereflect::Paragraph))
+      # 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.add_child(list_item)
+      node.add_child(list)
+
+      expected = {
+        'type' => 'root',
+        'content' => [
+          {
+            'type' => 'paragraph',
+            'content' => [
+              {
+                'type' => 'text',
+                'text' => 'Bold',
+                'marks' => [{ 'type' => 'bold' }]
+              },
+              {
+                'type' => 'text',
+                'text' => ' and '
+              },
+              {
+                'type' => 'text',
+                'text' => 'italic',
+                'marks' => [{ 'type' => 'italic' }]
+              }
+            ]
+          },
+          {
+            'type' => 'bullet_list',
+            'attrs' => {
+              'bullet_style' => nil
+            },
+            'content' => [
+              {
+                'type' => 'list_item',
+                'content' => [
+                  {
+                    'type' => 'paragraph',
+                    'content' => [
+                      {
+                        'type' => 'text',
+                        'text' => 'List item'
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+
+      expect(node.to_h).to eq(expected)
     end
+  end
 
-    it 'finds all nested nodes of a specific type' do
-      texts = node.find_all('text')
-      expect(texts.size).to eq(2)
-      expect(texts).to all(be_a(Prosereflect::Text))
+  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')
+
+        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')
+      end
     end
 
-    it 'returns empty array if no matching nodes are found' do
-      result = node.find_all('nonexistent')
-      expect(result).to eq([])
+    describe '#find_first' do
+      let(:node) do
+        root = described_class.create('root')
+        para = Prosereflect::Paragraph.create
+        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
+      end
     end
-  end
 
-  describe '#find_children' do
-    let(:node) do
-      root = described_class.new({ 'type' => 'root' })
+    describe '#find_all' do
+      let(:node) do
+        root = described_class.create('root')
 
-      root.add_child(Prosereflect::Paragraph.new({ 'type' => 'paragraph' }))
-      root.add_child(Prosereflect::Table.new({ 'type' => 'table' }))
-      root.add_child(Prosereflect::Paragraph.new({ 'type' => 'paragraph' }))
+        # First paragraph
+        para1 = Prosereflect::Paragraph.create
+        para1.add_child(Prosereflect::Text.create('First'))
+        root.add_child(para1)
 
-      root
-    end
+        # Second paragraph
+        para2 = Prosereflect::Paragraph.create
+        para2.add_child(Prosereflect::Text.create('Second'))
+        root.add_child(para2)
 
-    it 'finds direct children of a specific type' do
-      paragraphs = node.find_children('paragraph')
-      expect(paragraphs.size).to eq(2)
-      expect(paragraphs).to all(be_a(Prosereflect::Paragraph))
-    end
+        root
+      end
 
-    it 'returns empty array if no matching children are found' do
-      result = node.find_children('nonexistent')
-      expect(result).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
-  end
 
-  describe '#text_content' do
-    it 'returns empty string for node without content' do
-      node = described_class.new({ 'type' => 'empty' })
-      expect(node.text_content).to eq('')
+    describe '#find_children' do
+      let(:node) do
+        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
+        paragraphs = node.find_children(Prosereflect::Paragraph)
+        expect(paragraphs.size).to eq(2)
+        expect(paragraphs).to all(be_a(Prosereflect::Paragraph))
+
+        tables = node.find_children(Prosereflect::Table)
+        expect(tables.size).to eq(1)
+        expect(tables.first).to be_a(Prosereflect::Table)
+      end
     end
 
-    it 'concatenates text content from all child nodes' do
-      node = described_class.new({ 'type' => 'parent' })
+    describe '#text_content' do
+      it 'concatenates text from all children' do
+        root = described_class.create('root')
 
-      para = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
-      para.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Hello' }))
-      para.add_child(Prosereflect::HardBreak.new({ 'type' => 'hard_break' }))
-      para.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'World' }))
+        para = Prosereflect::Paragraph.create
+        para.add_child(Prosereflect::Text.create('Hello'))
+        para.add_child(Prosereflect::HardBreak.create)
+        para.add_child(Prosereflect::Text.create('World'))
+        root.add_child(para)
 
-      node.add_child(para)
+        expect(root.text_content).to eq("Hello\nWorld")
+      end
 
-      expect(node.text_content).to eq("Hello\nWorld")
+      it 'returns empty string for empty node' do
+        node = described_class.create('empty')
+        expect(node.text_content).to eq('')
+      end
     end
   end
 
-  describe '#text_content_with_breaks' do
-    it 'returns empty string for node without content' do
-      node = described_class.new({ 'type' => 'empty' })
-      expect(node.text_content_with_breaks).to eq('')
-    end
+  describe 'serialization' do
+    it 'serializes a node with all properties' do
+      node = described_class.create('test_node', {
+                                      'key' => 'value',
+                                      'number' => 42
+                                    })
 
-    it 'includes newlines for hard breaks' do
-      node = described_class.new({ 'type' => 'parent' })
+      text = Prosereflect::Text.create('Content', [
+                                         Prosereflect::Mark::Bold.create,
+                                         Prosereflect::Mark::Link.create({ 'href' => 'https://example.com' })
+                                       ])
 
-      para = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
-      para.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Hello' }))
-      para.add_child(Prosereflect::HardBreak.new({ 'type' => 'hard_break' }))
-      para.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'World' }))
+      node.add_child(text)
 
-      node.add_child(para)
+      expected = {
+        'type' => 'test_node',
+        'attrs' => {
+          'key' => 'value',
+          'number' => 42
+        },
+        'content' => [
+          {
+            'type' => 'text',
+            'text' => 'Content',
+            'marks' => [
+              { 'type' => 'bold' },
+              {
+                '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')
+
+      expected = {
+        'type' => 'test_node'
+      }
 
-      expect(node.text_content_with_breaks).to eq("Hello\nWorld")
+      expect(node.to_h).to eq(expected)
     end
   end
 end