prosereflect 0.1.0 → 0.1.1

data/spec/prosereflect/table_cell_spec.rb

@@ -13,96 +13,307 @@ RSpec.describe Prosereflect::TableCell do
   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
+
+      expected = {
+        'type' => 'table_cell',
+        'content' => []
+      }
+
+      expect(cell.to_h).to eq(expected)
     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)
+      cell = described_class.create(attrs: {
+                                      'colspan' => 2,
+                                      'rowspan' => 1,
+                                      'background' => '#f5f5f5',
+                                      'align' => 'center',
+                                      'valign' => 'middle'
+                                    })
+
+      expected = {
+        'type' => 'table_cell',
+        'attrs' => {
+          'colspan' => 2,
+          'rowspan' => 1,
+          'background' => '#f5f5f5',
+          'align' => 'center',
+          'valign' => 'middle'
+        },
+        'content' => []
+      }
+
+      expect(cell.to_h).to eq(expected)
     end
   end
 
-  describe '#paragraphs' do
-    it 'returns all paragraphs in the cell' do
+  describe 'cell structure' do
+    it 'creates a cell with simple text content' do
       cell = described_class.create
-      cell.add_paragraph('Para 1')
-      cell.add_paragraph('Para 2')
+      cell.add_paragraph('Simple text')
 
-      expect(cell.paragraphs.size).to eq(2)
-      expect(cell.paragraphs).to all(be_a(Prosereflect::Paragraph))
-    end
+      expected = {
+        'type' => 'table_cell',
+        'content' => [{
+          'type' => 'paragraph',
+          'content' => [{
+            'type' => 'text',
+            'text' => 'Simple text'
+          }]
+        }]
+      }
 
-    it 'returns empty array for cell with no paragraphs' do
-      cell = described_class.create
-      expect(cell.paragraphs).to eq([])
+      expect(cell.to_h).to eq(expected)
     end
-  end
 
-  describe '#text_content' do
-    it 'returns concatenated text from all paragraphs with newlines' do
+    it 'creates a cell with complex content' 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
+      # First paragraph with mixed formatting
+      para = cell.add_paragraph('This is ')
+      para.add_text('bold', [Prosereflect::Mark::Bold.new])
+      para.add_text(' and ')
+      para.add_text('italic', [Prosereflect::Mark::Italic.new])
+      para.add_hard_break
+      para.add_text('with a line break')
 
-    it 'returns empty string for empty cell' do
-      cell = described_class.create
-      expect(cell.text_content).to eq('')
+      # Second paragraph with more formatting
+      para = cell.add_paragraph
+      para.add_text('Status: ', [Prosereflect::Mark::Bold.new])
+      para.add_text('Done', [Prosereflect::Mark::Strike.new])
+      para.add_text(' → ')
+      para.add_text('In Progress', [Prosereflect::Mark::Italic.new])
+
+      expected = {
+        'type' => 'table_cell',
+        'content' => [{
+          'type' => 'paragraph',
+          'content' => [{
+            'type' => 'text',
+            'text' => 'This is '
+          }, {
+            'type' => 'text',
+            'text' => 'bold',
+            'marks' => [{
+              'type' => 'bold'
+            }]
+          }, {
+            'type' => 'text',
+            'text' => ' and '
+          }, {
+            'type' => 'text',
+            'text' => 'italic',
+            'marks' => [{
+              'type' => 'italic'
+            }]
+          }, {
+            'type' => 'hard_break'
+          }, {
+            'type' => 'text',
+            'text' => 'with a line break'
+          }]
+        }, {
+          'type' => 'paragraph',
+          'content' => [{
+            'type' => 'text',
+            'text' => 'Status: ',
+            'marks' => [{
+              'type' => 'bold'
+            }]
+          }, {
+            'type' => 'text',
+            'text' => 'Done',
+            'marks' => [{
+              'type' => 'strike'
+            }]
+          }, {
+            'type' => 'text',
+            'text' => ' → '
+          }, {
+            'type' => 'text',
+            'text' => 'In Progress',
+            'marks' => [{
+              'type' => 'italic'
+            }]
+          }]
+        }]
+      }
+
+      expect(cell.to_h).to eq(expected)
     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'])
+  describe 'cell operations' do
+    let(:cell) do
+      c = described_class.create
+      c.add_paragraph('First paragraph')
+      c.add_paragraph('Second paragraph')
+      c.add_paragraph('Third paragraph')
+      c
     end
 
-    it 'returns empty array for empty cell' do
-      cell = described_class.create
-      expect(cell.lines).to eq([])
+    describe '#paragraphs' do
+      it 'returns all paragraphs in the cell' do
+        expect(cell.paragraphs.size).to eq(3)
+        expect(cell.paragraphs).to all(be_a(Prosereflect::Paragraph))
+        expect(cell.paragraphs.map(&:text_content)).to eq([
+                                                            'First paragraph',
+                                                            'Second paragraph',
+                                                            'Third paragraph'
+                                                          ])
+      end
+
+      it 'returns empty array for cell with no paragraphs' do
+        empty_cell = described_class.create
+        expect(empty_cell.paragraphs).to eq([])
+      end
     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')
+    describe '#text_content' do
+      it 'returns concatenated text from all paragraphs with newlines' do
+        expect(cell.text_content).to eq("First paragraph\nSecond paragraph\nThird paragraph")
+      end
+
+      it 'returns empty string for empty cell' do
+        empty_cell = described_class.create
+        expect(empty_cell.text_content).to eq('')
+      end
+
+      it 'handles complex formatting and line breaks' do
+        cell = described_class.create
+        para = cell.add_paragraph('Line 1')
+        para.add_hard_break
+        para.add_text('Line 2', [Prosereflect::Mark::Bold.new])
+        para.add_hard_break
+        para.add_text('Line 3', [Prosereflect::Mark::Italic.new])
 
-      expect(cell.lines).to eq(['First line', 'Second line'])
+        expect(cell.text_content).to eq("Line 1\nLine 2\nLine 3")
+      end
     end
-  end
 
-  describe '#add_paragraph' do
-    it 'adds a paragraph with text' do
-      cell = described_class.create
-      paragraph = cell.add_paragraph('Test content')
+    describe '#lines' do
+      it 'splits text content into lines' do
+        expect(cell.lines).to eq([
+                                   'First paragraph',
+                                   'Second paragraph',
+                                   'Third paragraph'
+                                 ])
+      end
+
+      it 'returns empty array for empty cell' do
+        empty_cell = described_class.create
+        expect(empty_cell.lines).to eq([])
+      end
+
+      it 'handles hard breaks within paragraphs' do
+        cell = described_class.create
+        para = cell.add_paragraph('First line')
+        para.add_hard_break
+        para.add_text('Second line')
+        cell.add_paragraph('Third line')
 
-      expect(cell.paragraphs.size).to eq(1)
-      expect(paragraph).to be_a(Prosereflect::Paragraph)
-      expect(paragraph.text_content).to eq('Test content')
+        expect(cell.lines).to eq([
+                                   'First line',
+                                   'Second line',
+                                   'Third line'
+                                 ])
+      end
     end
 
-    it 'adds an empty paragraph' do
-      cell = described_class.create
-      paragraph = cell.add_paragraph
+    describe '#add_paragraph' do
+      it 'adds a paragraph with text and formatting' do
+        cell = described_class.create
+        para = cell.add_paragraph('Main text')
+        para.add_text(' (', [Prosereflect::Mark::Bold.new])
+        para.add_text('important', [Prosereflect::Mark::Bold.new, Prosereflect::Mark::Italic.new])
+        para.add_text(')', [Prosereflect::Mark::Bold.new])
+
+        expected = {
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Main text'
+            }, {
+              'type' => 'text',
+              'text' => ' (',
+              'marks' => [{
+                'type' => 'bold'
+              }]
+            }, {
+              'type' => 'text',
+              'text' => 'important',
+              'marks' => [{
+                'type' => 'bold'
+              }, {
+                'type' => 'italic'
+              }]
+            }, {
+              'type' => 'text',
+              'text' => ')',
+              'marks' => [{
+                'type' => 'bold'
+              }]
+            }]
+          }]
+        }
+
+        expect(cell.to_h).to eq(expected)
+      end
+
+      it 'adds multiple paragraphs with mixed content' do
+        cell = described_class.create
 
-      expect(cell.paragraphs.size).to eq(1)
-      expect(paragraph).to be_a(Prosereflect::Paragraph)
-      expect(paragraph.text_content).to eq('')
+        # First paragraph with hard break
+        para = cell.add_paragraph('Title')
+        para.add_hard_break
+        para.add_text('Subtitle', [Prosereflect::Mark::Italic.new])
+
+        # Second paragraph with mixed formatting
+        para = cell.add_paragraph
+        para.add_text('Note: ', [Prosereflect::Mark::Bold.new])
+        para.add_text('This is important')
+
+        expected = {
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Title'
+            }, {
+              'type' => 'hard_break'
+            }, {
+              'type' => 'text',
+              'text' => 'Subtitle',
+              'marks' => [{
+                'type' => 'italic'
+              }]
+            }]
+          }, {
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Note: ',
+              'marks' => [{
+                'type' => 'bold'
+              }]
+            }, {
+              'type' => 'text',
+              'text' => 'This is important'
+            }]
+          }]
+        }
+
+        expect(cell.to_h).to eq(expected)
+      end
     end
   end
 
   describe 'serialization' do
     it 'converts to hash representation' do
-      cell = described_class.create
+      cell = described_class.new
       cell.add_paragraph('Test content')
 
       hash = cell.to_h

data/spec/prosereflect/table_row_spec.rb

@@ -13,65 +13,235 @@ RSpec.describe Prosereflect::TableRow do
   describe '.create' do
     it 'creates an empty table row' do
       row = described_class.create
-      expect(row).to be_a(described_class)
-      expect(row.type).to eq('table_row')
-      expect(row.content).to be_empty
+
+      expected = {
+        'type' => 'table_row',
+        'content' => []
+      }
+
+      expect(row.to_h).to eq(expected)
     end
 
     it 'creates a table row with attributes' do
-      attrs = { 'background' => '#f5f5f5' }
-      row = described_class.create(attrs)
-      expect(row.attrs).to eq(attrs)
+      row = described_class.create(attrs: {
+                                     'background' => '#f5f5f5',
+                                     'height' => '40px',
+                                     'alignment' => 'center'
+                                   })
+
+      expected = {
+        'type' => 'table_row',
+        'attrs' => {
+          'background' => '#f5f5f5',
+          'height' => '40px',
+          'alignment' => 'center'
+        },
+        'content' => []
+      }
+
+      expect(row.to_h).to eq(expected)
     end
   end
 
-  describe '#cells' do
-    it 'returns all cells in the row' do
+  describe 'row structure' do
+    it 'creates a row with simple text cells' do
       row = described_class.create
-      row.add_cell('Cell 1')
-      row.add_cell('Cell 2')
+      row.add_cell('First')
+      row.add_cell('Second')
+      row.add_cell('Third')
 
-      expect(row.cells.size).to eq(2)
-      expect(row.cells).to all(be_a(Prosereflect::TableCell))
-    end
+      expected = {
+        'type' => 'table_row',
+        'content' => [{
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'First'
+            }]
+          }]
+        }, {
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Second'
+            }]
+          }]
+        }, {
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Third'
+            }]
+          }]
+        }]
+      }
 
-    it 'returns empty array for row with no cells' do
-      row = described_class.create
-      expect(row.cells).to eq([])
+      expect(row.to_h).to eq(expected)
     end
-  end
 
-  describe '#add_cell' do
-    it 'adds a cell with text content' do
+    it 'creates a row with complex cell content' do
       row = described_class.create
-      cell = row.add_cell('Test content')
 
-      expect(row.cells.size).to eq(1)
-      expect(cell).to be_a(Prosereflect::TableCell)
-      expect(cell.text_content).to eq('Test content')
-    end
+      # First cell with multiple paragraphs
+      cell = row.add_cell
+      para = cell.add_paragraph('Main point:')
+      para.add_hard_break
+      para.add_text('Important', [Prosereflect::Mark::Bold.new])
+      cell.add_paragraph('(details below)')
 
-    it 'adds an empty cell' do
-      row = described_class.create
+      # Second cell with mixed formatting
       cell = row.add_cell
+      para = cell.add_paragraph
+      para.add_text('Status: ', [Prosereflect::Mark::Bold.new])
+      para.add_text('In Progress', [Prosereflect::Mark::Italic.new])
+      para.add_hard_break
+      para.add_text('Updated', [Prosereflect::Mark::Strike.new])
+
+      expected = {
+        'type' => 'table_row',
+        'content' => [{
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Main point:'
+            }, {
+              'type' => 'hard_break'
+            }, {
+              'type' => 'text',
+              'text' => 'Important',
+              'marks' => [{
+                'type' => 'bold'
+              }]
+            }]
+          }, {
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => '(details below)'
+            }]
+          }]
+        }, {
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Status: ',
+              'marks' => [{
+                'type' => 'bold'
+              }]
+            }, {
+              'type' => 'text',
+              'text' => 'In Progress',
+              'marks' => [{
+                'type' => 'italic'
+              }]
+            }, {
+              'type' => 'hard_break'
+            }, {
+              'type' => 'text',
+              'text' => 'Updated',
+              'marks' => [{
+                'type' => 'strike'
+              }]
+            }]
+          }]
+        }]
+      }
 
-      expect(row.cells.size).to eq(1)
-      expect(cell).to be_a(Prosereflect::TableCell)
-      expect(cell.text_content).to eq('')
+      expect(row.to_h).to eq(expected)
     end
   end
 
-  describe 'serialization' do
-    it 'converts to hash representation' do
-      row = described_class.create
-      row.add_cell('Cell 1')
-      row.add_cell('Cell 2')
-
-      hash = row.to_h
-      expect(hash['type']).to eq('table_row')
-      expect(hash['content'].size).to eq(2)
-      expect(hash['content'][0]['type']).to eq('table_cell')
-      expect(hash['content'][1]['type']).to eq('table_cell')
+  describe 'row operations' do
+    let(:row) do
+      r = described_class.create
+      r.add_cell('First')
+      r.add_cell('Second')
+      r.add_cell('Third')
+      r
+    end
+
+    describe '#cells' do
+      it 'returns all cells in the row' do
+        expect(row.cells.size).to eq(3)
+        expect(row.cells).to all(be_a(Prosereflect::TableCell))
+        expect(row.cells.map(&:text_content)).to eq(%w[First Second Third])
+      end
+
+      it 'returns empty array for row with no cells' do
+        empty_row = described_class.create
+        expect(empty_row.cells).to eq([])
+      end
+    end
+
+    describe '#add_cell' do
+      it 'adds a cell with text content and attributes' do
+        cell = row.add_cell('Test', attrs: {
+                              'colspan' => 2,
+                              'rowspan' => 1,
+                              'background' => '#eee'
+                            })
+
+        expected = {
+          'type' => 'table_cell',
+          'attrs' => {
+            'colspan' => 2,
+            'rowspan' => 1,
+            'background' => '#eee'
+          },
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Test'
+            }]
+          }]
+        }
+
+        expect(cell.to_h).to eq(expected)
+      end
+
+      it 'adds a cell with formatted content' do
+        cell = row.add_cell
+        para = cell.add_paragraph
+        para.add_text('Bold', [Prosereflect::Mark::Bold.new])
+        para.add_text(' and ')
+        para.add_text('italic', [Prosereflect::Mark::Italic.new])
+
+        expected = {
+          'type' => 'table_cell',
+          'content' => [{
+            'type' => 'paragraph',
+            'content' => [{
+              'type' => 'text',
+              'text' => 'Bold',
+              'marks' => [{
+                'type' => 'bold'
+              }]
+            }, {
+              'type' => 'text',
+              'text' => ' and '
+            }, {
+              'type' => 'text',
+              'text' => 'italic',
+              'marks' => [{
+                'type' => 'italic'
+              }]
+            }]
+          }]
+        }
+
+        expect(cell.to_h).to eq(expected)
+      end
     end
   end
 end