prosereflect 0.1.0

data/spec/prosereflect/table_row_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect::TableRow do
+  describe 'initialization' do
+    it 'initializes as a table_row node' do
+      row = described_class.new({ 'type' => 'table_row' })
+      expect(row.type).to eq('table_row')
+    end
+  end
+
+  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
+    end
+
+    it 'creates a table row with attributes' do
+      attrs = { 'background' => '#f5f5f5' }
+      row = described_class.create(attrs)
+      expect(row.attrs).to eq(attrs)
+    end
+  end
+
+  describe '#cells' do
+    it 'returns all cells in the row' do
+      row = described_class.create
+      row.add_cell('Cell 1')
+      row.add_cell('Cell 2')
+
+      expect(row.cells.size).to eq(2)
+      expect(row.cells).to all(be_a(Prosereflect::TableCell))
+    end
+
+    it 'returns empty array for row with no cells' do
+      row = described_class.create
+      expect(row.cells).to eq([])
+    end
+  end
+
+  describe '#add_cell' do
+    it 'adds a cell with text 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
+
+    it 'adds an empty cell' do
+      row = described_class.create
+      cell = row.add_cell
+
+      expect(row.cells.size).to eq(1)
+      expect(cell).to be_a(Prosereflect::TableCell)
+      expect(cell.text_content).to eq('')
+    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')
+    end
+  end
+end

data/spec/prosereflect/table_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect::Table do
+  describe 'initialization' do
+    it 'initializes as a table node' do
+      table = described_class.new({ 'type' => 'table' })
+      expect(table.type).to eq('table')
+    end
+  end
+
+  describe '.create' do
+    it 'creates an empty table' do
+      table = described_class.create
+      expect(table).to be_a(described_class)
+      expect(table.type).to eq('table')
+      expect(table.content).to be_empty
+    end
+
+    it 'creates a table with attributes' do
+      attrs = { 'width' => '100%' }
+      table = described_class.create(attrs)
+      expect(table.attrs).to eq(attrs)
+    end
+  end
+
+  describe 'row access methods' do
+    let(:table) do
+      t = described_class.create
+      t.add_header(['Header 1', 'Header 2'])
+      t.add_row(['Data 1', 'Data 2'])
+      t.add_row(['Data 3', 'Data 4'])
+      t
+    end
+
+    describe '#rows' do
+      it 'returns all rows' do
+        expect(table.rows.size).to eq(3)
+        expect(table.rows).to all(be_a(Prosereflect::TableRow))
+      end
+    end
+
+    describe '#header_row' do
+      it 'returns the first row' do
+        expect(table.header_row).to be_a(Prosereflect::TableRow)
+        expect(table.header_row.cells.first.text_content).to eq('Header 1')
+      end
+    end
+
+    describe '#data_rows' do
+      it 'returns all rows except the header' do
+        expect(table.data_rows.size).to eq(2)
+        expect(table.data_rows).to all(be_a(Prosereflect::TableRow))
+        expect(table.data_rows.first.cells.first.text_content).to eq('Data 1')
+      end
+
+      it 'returns empty array if there are no data rows' do
+        table = described_class.create
+        table.add_header(['Header'])
+        expect(table.data_rows).to eq([])
+      end
+    end
+
+    describe '#cell_at' do
+      it 'returns cell at specified position' do
+        cell = table.cell_at(0, 1)
+        expect(cell).to be_a(Prosereflect::TableCell)
+        expect(cell.text_content).to eq('Data 2')
+      end
+
+      it 'returns nil for out of bounds indices' do
+        expect(table.cell_at(-1, 0)).to be_nil
+        expect(table.cell_at(0, -1)).to be_nil
+        expect(table.cell_at(5, 0)).to be_nil
+        expect(table.cell_at(0, 5)).to be_nil
+      end
+    end
+  end
+
+  describe 'table building methods' do
+    describe '#add_header' do
+      it 'adds a header row with cells' do
+        table = described_class.create
+        header = table.add_header(['Col 1', 'Col 2'])
+
+        expect(table.rows.size).to eq(1)
+        expect(header).to be_a(Prosereflect::TableRow)
+        expect(header.cells.size).to eq(2)
+        expect(header.cells.map(&:text_content)).to eq(['Col 1', 'Col 2'])
+      end
+    end
+
+    describe '#add_row' do
+      it 'adds a row with cells' do
+        table = described_class.create
+        row = table.add_row(['Data 1', 'Data 2'])
+
+        expect(table.rows.size).to eq(1)
+        expect(row).to be_a(Prosereflect::TableRow)
+        expect(row.cells.size).to eq(2)
+        expect(row.cells.map(&:text_content)).to eq(['Data 1', 'Data 2'])
+      end
+
+      it 'adds an empty row when no data provided' do
+        table = described_class.create
+        row = table.add_row
+
+        expect(table.rows.size).to eq(1)
+        expect(row.cells).to be_empty
+      end
+    end
+
+    describe '#add_rows' do
+      it 'adds multiple rows at once' do
+        table = described_class.create
+        table.add_rows([
+                         ['Row 1, Cell 1', 'Row 1, Cell 2'],
+                         ['Row 2, Cell 1', 'Row 2, Cell 2']
+                       ])
+
+        expect(table.rows.size).to eq(2)
+        expect(table.rows[0].cells.size).to eq(2)
+        expect(table.rows[1].cells.size).to eq(2)
+        expect(table.rows[0].cells.first.text_content).to eq('Row 1, Cell 1')
+        expect(table.rows[1].cells.first.text_content).to eq('Row 2, Cell 1')
+      end
+    end
+  end
+
+  describe 'serialization' do
+    it 'converts to hash representation' do
+      table = described_class.create
+      table.add_header(['Col 1', 'Col 2'])
+      table.add_row(['Data 1', 'Data 2'])
+
+      hash = table.to_h
+      expect(hash['type']).to eq('table')
+      expect(hash['content'].size).to eq(2)
+      expect(hash['content'][0]['type']).to eq('table_row')
+      expect(hash['content'][1]['type']).to eq('table_row')
+    end
+  end
+end

data/spec/prosereflect/text_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe Prosereflect::Text do
+  describe 'initialization' do
+    it 'initializes as a text node' do
+      text = described_class.new({ 'type' => 'text', 'text' => 'Hello' })
+      expect(text.type).to eq('text')
+      expect(text.text).to eq('Hello')
+    end
+
+    it 'initializes with empty text' do
+      text = described_class.new({ 'type' => 'text' })
+      expect(text.text).to eq('')
+    end
+
+    it 'initializes with marks' do
+      marks = [{ 'type' => 'bold' }, { 'type' => 'italic' }]
+      text = described_class.new({
+                                   'type' => 'text',
+                                   'text' => 'Formatted text',
+                                   'marks' => marks
+                                 })
+
+      expect(text.marks).to eq(marks)
+    end
+  end
+
+  describe '.create' do
+    it 'creates a text node with content' do
+      text = described_class.create('Hello world')
+      expect(text.type).to eq('text')
+      expect(text.text).to eq('Hello world')
+    end
+
+    it 'creates a text node with marks' do
+      marks = [{ 'type' => 'bold' }]
+      text = described_class.create('Bold text', marks)
+
+      expect(text.text).to eq('Bold text')
+      expect(text.marks).to eq(marks)
+    end
+  end
+
+  describe '#text_content' do
+    it 'returns the text content' do
+      text = described_class.new({ 'type' => 'text', 'text' => 'Sample text' })
+      expect(text.text_content).to eq('Sample text')
+    end
+
+    it 'returns empty string when text is nil' do
+      text = described_class.new({ 'type' => 'text' })
+      expect(text.text_content).to eq('')
+    end
+  end
+
+  describe '#to_h' do
+    it 'creates a hash representation with text' do
+      text = described_class.new({ 'type' => 'text', 'text' => 'Hello' })
+      hash = text.to_h
+
+      expect(hash['type']).to eq('text')
+      expect(hash['text']).to eq('Hello')
+    end
+
+    it 'includes marks in hash representation when present' do
+      marks = [{ 'type' => 'bold' }]
+      text = described_class.new({
+                                   'type' => 'text',
+                                   'text' => 'Bold text',
+                                   'marks' => marks
+                                 })
+
+      hash = text.to_h
+      expect(hash['marks']).to eq(marks)
+    end
+  end
+
+  describe 'inheritance' do
+    it 'is a Node' do
+      text = described_class.new({ 'type' => 'text', 'text' => 'Test' })
+      expect(text).to be_a(Prosereflect::Node)
+    end
+  end
+
+  describe 'with marks' do
+    it 'can have multiple marks' do
+      marks = [
+        { 'type' => 'bold' },
+        { 'type' => 'italic' },
+        { 'type' => 'underline' }
+      ]
+
+      text = described_class.new({
+                                   'type' => 'text',
+                                   'text' => 'Formatted text',
+                                   'marks' => marks
+                                 })
+
+      expect(text.marks.size).to eq(3)
+    end
+
+    it 'can have marks with attributes' do
+      marks = [
+        { 'type' => 'link', 'attrs' => { 'href' => 'https://example.com' } }
+      ]
+
+      text = described_class.new({
+                                   'type' => 'text',
+                                   'text' => 'Link text',
+                                   'marks' => marks
+                                 })
+
+      expect(text.marks[0]['attrs']['href']).to eq('https://example.com')
+    end
+  end
+end

data/spec/prosereflect/version_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect::VERSION do
+  it 'has a version number' do
+    expect(Prosereflect::VERSION).not_to be nil
+    expect(Prosereflect::VERSION).to be_a(String)
+    expect(Prosereflect::VERSION).to match(/\d+\.\d+\.\d+/)
+  end
+end

data/spec/prosereflect_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Prosereflect do
+  let(:fixtures_path) { File.join(__dir__, 'fixtures') }
+
+  it 'has a version number' do
+    expect(Prosereflect::VERSION).not_to be nil
+  end
+
+  # Test YAML parsing for different fixtures
+  Dir.glob(File.join(__dir__, 'fixtures', '*/*.yaml')).each do |yaml_file|
+    context "with YAML fixture #{File.basename(yaml_file)}" do
+      let(:file_content) { File.read(yaml_file) }
+
+      include_examples 'a parsable format', :yaml
+
+      # Test table functionality for DP fixtures
+      if yaml_file.include?('DP')
+        include_examples 'a document with tables'
+        include_examples 'document traversal'
+        include_examples 'text content extraction'
+      end
+    end
+  end
+
+  # Test JSON parsing for different fixtures
+  Dir.glob(File.join(__dir__, 'fixtures', '*/*.json')).each do |json_file|
+    context "with JSON fixture #{File.basename(json_file)}" do
+      let(:file_content) { File.read(json_file) }
+
+      include_examples 'a parsable format', :json
+
+      # Test table functionality for DP fixtures
+      if json_file.include?('DP')
+        include_examples 'a document with tables'
+        include_examples 'document traversal'
+        include_examples 'text content extraction'
+      end
+    end
+  end
+
+  describe 'Document creation' do
+    include_examples 'document creation'
+  end
+
+  describe 'Round-trip format conversion' do
+    context 'with YAML format' do
+      include_examples 'format round-trip', :yaml
+    end
+
+    context 'with JSON format' do
+      include_examples 'format round-trip', :json
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'yaml'
+require 'json'
+require 'prosereflect'
+
+# Load shared examples
+Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+# Custom RSpec matcher for comparing JSON structures
+RSpec::Matchers.define :be_equivalent_json do |expected|
+  match do |actual|
+    # Parse strings if needed
+    expected_hash = expected.is_a?(String) ? JSON.parse(expected) : expected
+    actual_hash = actual.is_a?(String) ? JSON.parse(actual) : actual
+
+    # Compare the parsed structures
+    expected_hash == actual_hash
+  end
+
+  failure_message do |actual|
+    expected_hash = expected.is_a?(String) ? JSON.parse(expected) : expected
+    actual_hash = actual.is_a?(String) ? JSON.parse(actual) : actual
+
+    "Expected JSON to be equivalent to #{expected_hash.inspect}, but got #{actual_hash.inspect}"
+  end
+end
+
+# Custom RSpec matcher for comparing YAML structures
+RSpec::Matchers.define :be_equivalent_yaml do |expected|
+  match do |actual|
+    # Parse strings if needed
+    expected_hash = expected.is_a?(String) ? YAML.safe_load(expected) : expected
+    actual_hash = actual.is_a?(String) ? YAML.safe_load(actual) : actual
+
+    # Compare the parsed structures
+    expected_hash == actual_hash
+  end
+
+  failure_message do |actual|
+    expected_hash = expected.is_a?(String) ? YAML.safe_load(expected) : expected
+    actual_hash = actual.is_a?(String) ? YAML.safe_load(actual) : actual
+
+    "Expected YAML to be equivalent to #{expected_hash.inspect}, but got #{actual_hash.inspect}"
+  end
+end
+
+# Helper method to recursively compare hashes and arrays
+def deep_compare(expected, actual)
+  return expected == actual unless expected.is_a?(Hash) || expected.is_a?(Array)
+
+  if expected.is_a?(Hash) && actual.is_a?(Hash)
+    return false unless expected.keys.sort == actual.keys.sort
+
+    expected.all? { |key, value| deep_compare(value, actual[key]) }
+  elsif expected.is_a?(Array) && actual.is_a?(Array)
+    return false unless expected.length == actual.length
+
+    expected.zip(actual).all? { |e, a| deep_compare(e, a) }
+  else
+    false
+  end
+end
+
+# More flexible matcher that handles structural equivalence
+RSpec::Matchers.define :have_equivalent_structure do |expected|
+  match do |actual|
+    # Parse strings if needed
+    expected_data = case expected
+                    when String
+                      if expected.strip.start_with?('{', '[')
+                        begin
+                          JSON.parse(expected)
+                        rescue StandardError
+                          YAML.safe_load(expected)
+                        end
+                      else
+                        YAML.safe_load(expected)
+                      end
+                    else
+                      expected
+                    end
+
+    actual_data = case actual
+                  when String
+                    if actual.strip.start_with?('{', '[')
+                      begin
+                        JSON.parse(actual)
+                      rescue StandardError
+                        YAML.safe_load(actual)
+                      end
+                    else
+                      YAML.safe_load(actual)
+                    end
+                  else
+                    actual
+                  end
+
+    deep_compare(expected_data, actual_data)
+  end
+
+  failure_message do |actual|
+    expected_data = case expected
+                    when String
+                      if expected.strip.start_with?('{', '[')
+                        begin
+                          JSON.parse(expected)
+                        rescue StandardError
+                          YAML.safe_load(expected)
+                        end
+                      else
+                        YAML.safe_load(expected)
+                      end
+                    else
+                      expected
+                    end
+
+    actual_data = case actual
+                  when String
+                    if actual.strip.start_with?('{', '[')
+                      begin
+                        JSON.parse(actual)
+                      rescue StandardError
+                        YAML.safe_load(actual)
+                      end
+                    else
+                      YAML.safe_load(actual)
+                    end
+                  else
+                    actual
+                  end
+
+    "Expected structures to be equivalent:\nExpected: #{expected_data.inspect}\nActual: #{actual_data.inspect}"
+  end
+end