prosereflect 0.1.0

data/spec/prosereflect/node_spec.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+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.marks).to be_nil
+    end
+
+    it 'initializes with provided data' do
+      data = {
+        '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' }])
+    end
+  end
+
+  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
+      content_data = [
+        { 'type' => 'text', 'text' => 'Hello' },
+        { 'type' => 'hard_break' }
+      ]
+
+      node = described_class.new
+      parsed_content = node.parse_content(content_data)
+
+      expect(parsed_content.size).to eq(2)
+      expect(parsed_content[0]).to be_a(Prosereflect::Text)
+      expect(parsed_content[1]).to be_a(Prosereflect::HardBreak)
+    end
+  end
+
+  describe '#to_h' do
+    it 'creates a hash representation with basic properties' do
+      node = described_class.new({ 'type' => 'test_node' })
+      hash = node.to_h
+
+      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' }
+                                 })
+
+      hash = node.to_h
+      expect(hash['attrs']).to eq({ 'key' => 'value' })
+    end
+
+    it 'includes marks when present' do
+      node = described_class.new({
+                                   'type' => 'test_node',
+                                   'marks' => [{ 'type' => 'bold' }]
+                                 })
+
+      hash = node.to_h
+      expect(hash['marks']).to eq([{ 'type' => 'bold' }])
+    end
+
+    it 'includes content when present' do
+      node = described_class.new({
+                                   'type' => 'test_node',
+                                   'content' => [{ 'type' => 'text', 'text' => 'Hello' }]
+                                 })
+
+      hash = node.to_h
+      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' })
+
+      parent.add_child(child)
+
+      expect(parent.content.size).to eq(1)
+      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' })
+
+      result = parent.add_child(child)
+
+      expect(result).to eq(child)
+    end
+  end
+
+  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' })
+
+      para.add_child(text)
+      root.add_child(para)
+      root
+    end
+
+    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')
+      expect(result).to be_a(Prosereflect::Paragraph)
+    end
+
+    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')
+      expect(result).to be_nil
+    end
+  end
+
+  describe '.create' do
+    it 'creates a node with the specified type' do
+      node = described_class.create('test_node')
+      expect(node.type).to eq('test_node')
+    end
+
+    it 'creates a node with attributes' do
+      attrs = { 'key' => 'value' }
+      node = described_class.create('test_node', attrs)
+
+      expect(node.type).to eq('test_node')
+      expect(node.attrs).to eq(attrs)
+    end
+
+    it 'initializes with empty content' do
+      node = described_class.create('test_node')
+      expect(node.content).to eq([])
+    end
+  end
+
+  describe '#find_all' do
+    let(:node) do
+      root = described_class.new({ 'type' => 'root' })
+
+      para1 = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
+      para1.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Text 1' }))
+
+      para2 = Prosereflect::Paragraph.new({ 'type' => 'paragraph' })
+      para2.add_child(Prosereflect::Text.new({ 'type' => 'text', 'text' => 'Text 2' }))
+
+      root.add_child(para1)
+      root.add_child(para2)
+      root
+    end
+
+    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))
+    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))
+    end
+
+    it 'returns empty array if no matching nodes are found' do
+      result = node.find_all('nonexistent')
+      expect(result).to eq([])
+    end
+  end
+
+  describe '#find_children' do
+    let(:node) do
+      root = described_class.new({ 'type' => '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' }))
+
+      root
+    end
+
+    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
+
+    it 'returns empty array if no matching children are found' do
+      result = node.find_children('nonexistent')
+      expect(result).to eq([])
+    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('')
+    end
+
+    it 'concatenates text content from all child nodes' do
+      node = described_class.new({ 'type' => 'parent' })
+
+      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(para)
+
+      expect(node.text_content).to eq("Hello\nWorld")
+    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
+
+    it 'includes newlines for hard breaks' do
+      node = described_class.new({ 'type' => 'parent' })
+
+      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(para)
+
+      expect(node.text_content_with_breaks).to eq("Hello\nWorld")
+    end
+  end
+end

data/spec/prosereflect/paragraph_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect::Paragraph do
+  describe 'initialization' do
+    it 'initializes as a paragraph node' do
+      paragraph = described_class.new({ 'type' => 'paragraph' })
+      expect(paragraph.type).to eq('paragraph')
+    end
+  end
+
+  describe '.create' do
+    it 'creates an empty paragraph' do
+      paragraph = described_class.create
+      expect(paragraph).to be_a(described_class)
+      expect(paragraph.type).to eq('paragraph')
+      expect(paragraph.content).to be_empty
+    end
+
+    it 'creates a paragraph with attributes' do
+      attrs = { 'align' => 'center' }
+      paragraph = described_class.create(attrs)
+      expect(paragraph.attrs).to eq(attrs)
+    end
+  end
+
+  describe '#text_nodes' do
+    it 'returns all text nodes in the paragraph' do
+      paragraph = described_class.create
+      paragraph.add_text('First text')
+      paragraph.add_text('Second text')
+
+      expect(paragraph.text_nodes.size).to eq(2)
+      expect(paragraph.text_nodes).to all(be_a(Prosereflect::Text))
+    end
+
+    it 'returns empty array for paragraph with no text nodes' do
+      paragraph = described_class.create
+      expect(paragraph.text_nodes).to eq([])
+    end
+  end
+
+  describe '#text_content' do
+    it 'returns concatenated text from all text nodes' do
+      paragraph = described_class.create
+      paragraph.add_text('First text')
+      paragraph.add_text(' Second text')
+
+      expect(paragraph.text_content).to eq('First text Second text')
+    end
+
+    it 'returns empty string for empty paragraph' do
+      paragraph = described_class.create
+      expect(paragraph.text_content).to eq('')
+    end
+
+    it 'handles hard breaks' do
+      paragraph = described_class.create
+      paragraph.add_text('First line')
+      paragraph.add_hard_break
+      paragraph.add_text('Second line')
+
+      expect(paragraph.text_content).to eq("First line\nSecond line")
+    end
+
+    it 'handles mixed content types' do
+      paragraph = described_class.create
+      paragraph.add_text('Text with ')
+
+      # Add a custom node that is neither text nor hard_break
+      custom_node = Prosereflect::Node.create('custom_node')
+      custom_node.instance_eval do
+        def text_content
+          'custom content'
+        end
+      end
+      paragraph.add_child(custom_node)
+
+      expect(paragraph.text_content).to eq('Text with custom content')
+    end
+  end
+
+  describe '#add_text' do
+    it 'adds text to the paragraph' do
+      paragraph = described_class.create
+      text_node = paragraph.add_text('Hello world')
+
+      expect(paragraph.content.size).to eq(1)
+      expect(text_node).to be_a(Prosereflect::Text)
+      expect(text_node.text).to eq('Hello world')
+    end
+
+    it 'adds text with marks' do
+      paragraph = described_class.create
+      marks = [{ 'type' => 'bold' }]
+      text_node = paragraph.add_text('Bold text', marks)
+
+      expect(text_node.marks).to eq(marks)
+    end
+
+    it 'does not add empty text' do
+      paragraph = described_class.create
+      result = paragraph.add_text('')
+
+      expect(paragraph.content).to be_empty
+      expect(result).to be_nil
+    end
+
+    it 'does not add nil text' do
+      paragraph = described_class.create
+      result = paragraph.add_text(nil)
+
+      expect(paragraph.content).to be_empty
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#add_hard_break' do
+    it 'adds a hard break to the paragraph' do
+      paragraph = described_class.create
+      hard_break = paragraph.add_hard_break
+
+      expect(paragraph.content.size).to eq(1)
+      expect(hard_break).to be_a(Prosereflect::HardBreak)
+    end
+
+    it 'adds a hard break with marks' do
+      paragraph = described_class.create
+      marks = [{ 'type' => 'italic' }]
+      hard_break = paragraph.add_hard_break(marks)
+
+      expect(hard_break.marks).to eq(marks)
+    end
+  end
+
+  describe 'serialization' do
+    it 'converts to hash representation' do
+      paragraph = described_class.create
+      paragraph.add_text('Hello')
+      paragraph.add_hard_break
+      paragraph.add_text('World')
+
+      hash = paragraph.to_h
+      expect(hash['type']).to eq('paragraph')
+      expect(hash['content'].size).to eq(3)
+      expect(hash['content'][0]['type']).to eq('text')
+      expect(hash['content'][1]['type']).to eq('hard_break')
+      expect(hash['content'][2]['type']).to eq('text')
+    end
+  end
+end

data/spec/prosereflect/parser_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect::Parser do
+  let(:fixtures_path) { File.join(__dir__, '..', 'fixtures') }
+
+  describe '.parse_document' do
+    context 'with YAML fixtures' do
+      let(:yaml_files) { Dir.glob(File.join(fixtures_path, '*/*.yaml')) }
+
+      it 'parses all YAML fixtures successfully' do
+        yaml_files.each do |yaml_file|
+          yaml_content = File.read(yaml_file)
+          data = YAML.safe_load(yaml_content)
+
+          expect do
+            document = described_class.parse_document(data)
+            expect(document).to be_a(Prosereflect::Document)
+          end.not_to raise_error
+        end
+      end
+    end
+
+    context 'with JSON fixtures' do
+      let(:json_files) { Dir.glob(File.join(fixtures_path, '*/*.json')) }
+
+      it 'parses all JSON fixtures successfully' do
+        json_files.each do |json_file|
+          json_content = File.read(json_file)
+          data = JSON.parse(json_content)
+
+          expect do
+            document = described_class.parse_document(data)
+            expect(document).to be_a(Prosereflect::Document)
+          end.not_to raise_error
+        end
+      end
+    end
+
+    context 'with invalid input' do
+      it 'raises an error for nil input' do
+        expect { described_class.parse_document(nil) }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an error for non-hash input' do
+        expect { described_class.parse_document('not a hash') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '.parse_node' do
+    it 'creates the correct node type based on the input' do
+      # Test document node
+      doc_data = { 'type' => 'doc', 'content' => [] }
+      expect(described_class.parse_node(doc_data)).to be_a(Prosereflect::Document)
+
+      # Test paragraph node
+      para_data = { 'type' => 'paragraph', 'content' => [] }
+      expect(described_class.parse_node(para_data)).to be_a(Prosereflect::Paragraph)
+
+      # Test text node
+      text_data = { 'type' => 'text', 'text' => 'Hello' }
+      expect(described_class.parse_node(text_data)).to be_a(Prosereflect::Text)
+
+      # Test hard_break node
+      break_data = { 'type' => 'hard_break' }
+      expect(described_class.parse_node(break_data)).to be_a(Prosereflect::HardBreak)
+
+      # Test table node
+      table_data = { 'type' => 'table', 'content' => [] }
+      expect(described_class.parse_node(table_data)).to be_a(Prosereflect::Table)
+
+      # Test table_row node
+      row_data = { 'type' => 'table_row', 'content' => [] }
+      expect(described_class.parse_node(row_data)).to be_a(Prosereflect::TableRow)
+
+      # Test table_cell node
+      cell_data = { 'type' => 'table_cell', 'content' => [] }
+      expect(described_class.parse_node(cell_data)).to be_a(Prosereflect::TableCell)
+
+      # Test generic node
+      generic_data = { 'type' => 'unknown_type' }
+      expect(described_class.parse_node(generic_data)).to be_a(Prosereflect::Node)
+    end
+
+    it 'handles nodes with content' do
+      data = {
+        'type' => 'paragraph',
+        'content' => [
+          { 'type' => 'text', 'text' => 'Hello' },
+          { 'type' => 'hard_break' },
+          { 'type' => 'text', 'text' => 'World' }
+        ]
+      }
+
+      node = described_class.parse_node(data)
+      expect(node).to be_a(Prosereflect::Paragraph)
+      expect(node.content.size).to eq(3)
+      expect(node.content[0]).to be_a(Prosereflect::Text)
+      expect(node.content[1]).to be_a(Prosereflect::HardBreak)
+      expect(node.content[2]).to be_a(Prosereflect::Text)
+    end
+
+    it 'handles nodes with marks' do
+      data = {
+        'type' => 'text',
+        'text' => 'Bold text',
+        'marks' => [{ 'type' => 'bold' }]
+      }
+
+      node = described_class.parse_node(data)
+      expect(node).to be_a(Prosereflect::Text)
+      expect(node.marks).to eq([{ 'type' => 'bold' }])
+    end
+
+    it 'handles nodes with attributes' do
+      data = {
+        'type' => 'table_cell',
+        'attrs' => { 'colspan' => 2, 'rowspan' => 1 },
+        'content' => []
+      }
+
+      node = described_class.parse_node(data)
+      expect(node).to be_a(Prosereflect::TableCell)
+      expect(node.attrs).to eq({ 'colspan' => 2, 'rowspan' => 1 })
+    end
+  end
+end

data/spec/prosereflect/table_cell_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect::TableCell do
+  describe 'initialization' do
+    it 'initializes as a table_cell node' do
+      cell = described_class.new({ 'type' => 'table_cell' })
+      expect(cell.type).to eq('table_cell')
+    end
+  end
+
+  describe '.create' do
+    it 'creates an empty table cell' do
+      cell = described_class.create
+      expect(cell).to be_a(described_class)
+      expect(cell.type).to eq('table_cell')
+      expect(cell.content).to be_empty
+    end
+
+    it 'creates a table cell with attributes' do
+      attrs = { 'colspan' => 2, 'rowspan' => 1 }
+      cell = described_class.create(attrs)
+      expect(cell.attrs).to eq(attrs)
+    end
+  end
+
+  describe '#paragraphs' do
+    it 'returns all paragraphs in the cell' do
+      cell = described_class.create
+      cell.add_paragraph('Para 1')
+      cell.add_paragraph('Para 2')
+
+      expect(cell.paragraphs.size).to eq(2)
+      expect(cell.paragraphs).to all(be_a(Prosereflect::Paragraph))
+    end
+
+    it 'returns empty array for cell with no paragraphs' do
+      cell = described_class.create
+      expect(cell.paragraphs).to eq([])
+    end
+  end
+
+  describe '#text_content' do
+    it 'returns concatenated text from all paragraphs with newlines' do
+      cell = described_class.create
+      cell.add_paragraph('First paragraph')
+      cell.add_paragraph('Second paragraph')
+
+      expect(cell.text_content).to eq("First paragraph\nSecond paragraph")
+    end
+
+    it 'returns empty string for empty cell' do
+      cell = described_class.create
+      expect(cell.text_content).to eq('')
+    end
+  end
+
+  describe '#lines' do
+    it 'splits text content into lines' do
+      cell = described_class.create
+      cell.add_paragraph('Line 1')
+      cell.add_paragraph('Line 2')
+
+      expect(cell.lines).to eq(['Line 1', 'Line 2'])
+    end
+
+    it 'returns empty array for empty cell' do
+      cell = described_class.create
+      expect(cell.lines).to eq([])
+    end
+
+    it 'handles multi-line paragraphs' do
+      cell = described_class.create
+      para = cell.add_paragraph('First line')
+      para.add_hard_break
+      para.add_text('Second line')
+
+      expect(cell.lines).to eq(['First line', 'Second line'])
+    end
+  end
+
+  describe '#add_paragraph' do
+    it 'adds a paragraph with text' do
+      cell = described_class.create
+      paragraph = cell.add_paragraph('Test content')
+
+      expect(cell.paragraphs.size).to eq(1)
+      expect(paragraph).to be_a(Prosereflect::Paragraph)
+      expect(paragraph.text_content).to eq('Test content')
+    end
+
+    it 'adds an empty paragraph' do
+      cell = described_class.create
+      paragraph = cell.add_paragraph
+
+      expect(cell.paragraphs.size).to eq(1)
+      expect(paragraph).to be_a(Prosereflect::Paragraph)
+      expect(paragraph.text_content).to eq('')
+    end
+  end
+
+  describe 'serialization' do
+    it 'converts to hash representation' do
+      cell = described_class.create
+      cell.add_paragraph('Test content')
+
+      hash = cell.to_h
+      expect(hash['type']).to eq('table_cell')
+      expect(hash['content'].size).to eq(1)
+      expect(hash['content'][0]['type']).to eq('paragraph')
+    end
+  end
+end