coradoc 1.1.6 → 2.0.1

data/coradoc-adoc/spec/coradoc/asciidoc/parser/cache_spec.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Coradoc::AsciiDoc::Parser::Cache do
+  describe '.new' do
+    it 'creates a cache with default max size' do
+      cache = described_class.new
+      expect(cache.stats[:max_size]).to eq(described_class::DEFAULT_MAX_SIZE)
+    end
+
+    it 'creates a cache with custom max size' do
+      cache = described_class.new(max_size: 10)
+      expect(cache.stats[:max_size]).to eq(10)
+    end
+  end
+
+  describe '#fetch_or_parse' do
+    let(:cache) { described_class.new }
+
+    it 'yields block on cache miss' do
+      content = 'test content'
+      block_called = false
+
+      result = cache.fetch_or_parse(content) do
+        block_called = true
+        :parsed_result
+      end
+
+      expect(block_called).to be true
+      expect(result).to eq(:parsed_result)
+    end
+
+    it 'returns cached result on cache hit' do
+      content = 'test content'
+      call_count = 0
+
+      2.times do
+        cache.fetch_or_parse(content) do
+          call_count += 1
+          :parsed_result
+        end
+      end
+
+      expect(call_count).to eq(1)
+    end
+
+    it 'caches different content separately' do
+      call_count = 0
+
+      cache.fetch_or_parse('content 1') do
+        call_count += 1
+        :result1
+      end
+      cache.fetch_or_parse('content 2') do
+        call_count += 1
+        :result2
+      end
+
+      expect(call_count).to eq(2)
+    end
+
+    it 'handles identical content' do
+      content = 'identical'
+      results = []
+
+      3.times do
+        results << cache.fetch_or_parse(content) { :parsed }
+      end
+
+      expect(results).to eq(%i[parsed parsed parsed])
+    end
+  end
+
+  describe '#cached?' do
+    let(:cache) { described_class.new }
+
+    it 'returns false for uncached content' do
+      expect(cache.cached?('uncached')).to be false
+    end
+
+    it 'returns true for cached content' do
+      content = 'cached content'
+      cache.fetch_or_parse(content) { :result }
+
+      expect(cache.cached?(content)).to be true
+    end
+  end
+
+  describe '#size' do
+    let(:cache) { described_class.new }
+
+    it 'returns 0 for empty cache' do
+      expect(cache.size).to eq(0)
+    end
+
+    it 'returns correct size after caching' do
+      cache.fetch_or_parse('content 1') { :r1 }
+      cache.fetch_or_parse('content 2') { :r2 }
+
+      expect(cache.size).to eq(2)
+    end
+  end
+
+  describe '#clear' do
+    let(:cache) { described_class.new }
+
+    it 'clears all cached entries' do
+      cache.fetch_or_parse('content 1') { :r1 }
+      cache.fetch_or_parse('content 2') { :r2 }
+
+      cache.clear
+
+      expect(cache.size).to eq(0)
+    end
+  end
+
+  describe 'LRU eviction' do
+    let(:cache) { described_class.new(max_size: 2) }
+
+    it 'evicts oldest entry when at capacity' do
+      cache.fetch_or_parse('content 1') { :r1 }
+      cache.fetch_or_parse('content 2') { :r2 }
+      cache.fetch_or_parse('content 3') { :r3 } # Should evict content 1
+
+      expect(cache.cached?('content 1')).to be false
+      expect(cache.cached?('content 2')).to be true
+      expect(cache.cached?('content 3')).to be true
+    end
+
+    it 'updates access order on cache hit' do
+      cache.fetch_or_parse('content 1') { :r1 }
+      cache.fetch_or_parse('content 2') { :r2 }
+      cache.fetch_or_parse('content 1') { :r1 } # Access content 1 again
+      cache.fetch_or_parse('content 3') { :r3 } # Should evict content 2
+
+      expect(cache.cached?('content 1')).to be true
+      expect(cache.cached?('content 2')).to be false
+      expect(cache.cached?('content 3')).to be true
+    end
+  end
+
+  describe '.global' do
+    after do
+      described_class.global = nil
+    end
+
+    it 'returns nil by default' do
+      expect(described_class.global).to be_nil
+    end
+
+    it 'can be set' do
+      cache = described_class.new
+      described_class.global = cache
+      expect(described_class.global).to eq(cache)
+    end
+  end
+
+  describe '.with_global' do
+    it 'sets global cache temporarily' do
+      described_class.with_global do |cache|
+        expect(described_class.global).to eq(cache)
+      end
+
+      expect(described_class.global).to be_nil
+    end
+
+    it 'restores previous global cache' do
+      original = described_class.new
+      described_class.global = original
+
+      described_class.with_global do |cache|
+        expect(described_class.global).to eq(cache)
+      end
+
+      expect(described_class.global).to eq(original)
+    end
+  end
+
+  describe '.clear_global!' do
+    it 'clears the global cache' do
+      described_class.with_global do |cache|
+        cache.fetch_or_parse('content') { :result }
+        expect(cache.size).to eq(1)
+
+        described_class.clear_global!
+        expect(cache.size).to eq(0)
+      end
+    end
+  end
+
+  describe '#stats' do
+    let(:cache) { described_class.new(max_size: 5) }
+
+    it 'returns cache statistics' do
+      cache.fetch_or_parse('content 1') { :r1 }
+      cache.fetch_or_parse('content 2') { :r2 }
+
+      stats = cache.stats
+
+      expect(stats[:size]).to eq(2)
+      expect(stats[:max_size]).to eq(5)
+      expect(stats[:keys].length).to eq(2)
+    end
+  end
+
+  describe 'thread safety' do
+    let(:cache) { described_class.new(max_size: 10) }
+
+    it 'handles concurrent access' do
+      threads = Array.new(10) do |i|
+        Thread.new do
+          10.times do |j|
+            cache.fetch_or_parse("content #{i}-#{j}") { :result }
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      expect(cache.size).to be <= 10
+    end
+  end
+end

data/coradoc-adoc/spec/coradoc/asciidoc/parser/parser_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Coradoc::AsciiDoc::Parser::Base do
+  describe '.parse' do
+    context 'with empty input' do
+      it 'parses empty string' do
+        result = described_class.parse('')
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with simple document' do
+      it 'parses a simple paragraph' do
+        result = described_class.parse('Hello world')
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses multiple lines' do
+        result = described_class.parse("Line one\nLine two")
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with document attributes' do
+      it 'parses attribute' do
+        result = described_class.parse(':author: John Doe')
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses multiple attributes' do
+        result = described_class.parse(":author: John\n:revdate: 2024")
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with sections' do
+      it 'parses level 1 heading' do
+        result = described_class.parse('= Document Title')
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses level 2 heading' do
+        result = described_class.parse('== Section Title')
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with lists' do
+      it 'parses unordered list' do
+        result = described_class.parse("* Item 1\n* Item 2")
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses ordered list' do
+        result = described_class.parse(". Item 1\n. Item 2")
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with inline formatting' do
+      it 'parses bold text' do
+        result = described_class.parse('This is *bold* text')
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses italic text' do
+        result = described_class.parse('This is _italic_ text')
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses monospace text' do
+        result = described_class.parse('This is `code` text')
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with blocks' do
+      it 'parses source block' do
+        input = "----\ncode here\n----"
+        result = described_class.parse(input)
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses example block' do
+        input = "====\nexample content\n===="
+        result = described_class.parse(input)
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses quote block' do
+        input = "____\nquoted text\n____"
+        result = described_class.parse(input)
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with tables' do
+      it 'parses simple table' do
+        input = "|===\n|Cell 1 |Cell 2\n|==="
+        result = described_class.parse(input)
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'with admonitions' do
+      it 'parses NOTE admonition' do
+        result = described_class.parse('NOTE: This is important')
+        expect(result).to be_a(Hash)
+      end
+
+      it 'parses WARNING admonition' do
+        result = described_class.parse('WARNING: Be careful')
+        expect(result).to be_a(Hash)
+      end
+    end
+  end
+
+  describe 'inheritance' do
+    it 'includes Parslet parser' do
+      expect(described_class.ancestors).to include(Parslet::Parser)
+    end
+  end
+end
+
+RSpec.describe 'Parser Integration' do
+  describe 'full document parsing' do
+    it 'parses complete document with header and sections' do
+      input = <<~ADOC
+        = Document Title
+        :author: John Doe
+
+        == Introduction
+
+        This is the introduction paragraph.
+
+        == Features
+
+        * Feature one
+        * Feature two
+
+        === Subsection
+
+        Some content here.
+      ADOC
+
+      result = Coradoc::AsciiDoc::Parser::Base.parse(input)
+      expect(result).to be_a(Hash)
+    end
+  end
+end

data/coradoc-adoc/spec/coradoc/asciidoc/round_trip_spec.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable RSpec/DescribeClass
+RSpec.describe 'Round-Trip Conversion' do
+  # Helper to parse, transform to CoreModel, transform back, and serialize
+  def round_trip(adoc_text)
+    # Parse to AsciiDoc model
+    ast = Coradoc::AsciiDoc::Parser::Base.parse(adoc_text)
+    asciidoc_doc = Coradoc::AsciiDoc::Transformer.transform(ast)
+
+    # Transform to CoreModel
+    core_doc = Coradoc::AsciiDoc::Transform::ToCoreModel.transform(asciidoc_doc)
+
+    # Transform back to AsciiDoc model
+    back_to_adoc = Coradoc::AsciiDoc::Transform::FromCoreModel.transform(core_doc)
+
+    # Serialize to AsciiDoc string
+    back_to_adoc.to_adoc
+  end
+
+  # NOTE: These tests reveal transformation chain issues that need to be fixed.
+  # The round-trip is not yet perfect - some data is lost in transformation.
+  # Tests that fail due to known issues in the transformation chain are marked with xit.
+  #
+  # Known issues:
+  # - Paragraph transformation creates Block::Core without delimiter chars
+  # - Nested sections not being transformed correctly
+  # - Table transformation creates Block::Core without delimiter chars
+  # - Admonition transformation creates Block::Core without delimiter chars
+  # - Inline formatting transformation creates Block::Core without delimiter chars
+  # - CoreModel::Block missing language attribute (FIXED, but needs ToCoreModel update)
+
+  describe 'document round-trip' do
+    it 'preserves document structure' do
+      input = <<~ADOC
+        = Document Title
+
+        == Section 1
+
+        Some content here.
+
+        == Section 2
+
+        More content.
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('Document Title')
+      expect(result).to include('Section 1')
+      expect(result).to include('Section 2')
+    end
+  end
+
+  describe 'section round-trip' do
+    it 'preserves section levels' do
+      input = <<~ADOC
+        = Title
+
+        == Level 1
+
+        === Level 2
+
+        ==== Level 3
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('== Level 1')
+      expect(result).to include('=== Level 2')
+      expect(result).to include('==== Level 3')
+    end
+  end
+
+  describe 'paragraph round-trip' do
+    it 'preserves paragraph content' do
+      input = 'This is a simple paragraph with some text.'
+
+      result = round_trip(input)
+      expect(result).to include('This is a simple paragraph')
+    end
+  end
+
+  describe 'list round-trip' do
+    it 'preserves unordered list' do
+      input = <<~ADOC
+        * Item 1
+        * Item 2
+        * Item 3
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('Item 1')
+      expect(result).to include('Item 2')
+      expect(result).to include('Item 3')
+    end
+
+    it 'preserves ordered list' do
+      input = <<~ADOC
+        . First
+        . Second
+        . Third
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('First')
+      expect(result).to include('Second')
+      expect(result).to include('Third')
+    end
+  end
+
+  describe 'table round-trip' do
+    it 'preserves table structure' do
+      input = <<~ADOC
+        |===
+        | Cell 1 | Cell 2
+        | Cell 3 | Cell 4
+        |===
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('Cell 1')
+      expect(result).to include('Cell 2')
+      expect(result).to include('Cell 3')
+      expect(result).to include('Cell 4')
+    end
+  end
+
+  describe 'block round-trip' do
+    it 'preserves source block' do
+      input = <<~ADOC
+        [source,ruby]
+        ----
+        def hello
+          puts "world"
+        end
+        ----
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('def hello')
+      expect(result).to include('puts')
+    end
+
+    it 'preserves example block' do
+      input = <<~ADOC
+        ====
+        This is an example.
+        ====
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('This is an example')
+    end
+
+    it 'preserves quote block' do
+      input = <<~ADOC
+        ____
+        A famous quote.
+        ____
+      ADOC
+
+      result = round_trip(input)
+      expect(result).to include('A famous quote')
+    end
+  end
+
+  describe 'admonition round-trip' do
+    it 'preserves NOTE admonition' do
+      input = 'NOTE: This is important.'
+
+      result = round_trip(input)
+      expect(result).to include('This is important')
+    end
+
+    it 'preserves WARNING admonition' do
+      input = 'WARNING: Be careful!'
+
+      result = round_trip(input)
+      expect(result).to include('Be careful')
+    end
+  end
+
+  describe 'inline formatting round-trip' do
+    it 'preserves bold text' do
+      input = 'This is *bold* text.'
+
+      result = round_trip(input)
+      expect(result).to include('bold')
+    end
+
+    it 'preserves italic text' do
+      input = 'This is _italic_ text.'
+
+      result = round_trip(input)
+      expect(result).to include('italic')
+    end
+
+    it 'preserves monospace text' do
+      input = 'This is `code` text.'
+
+      result = round_trip(input)
+      expect(result).to include('code')
+    end
+  end
+
+  describe 'complex document round-trip' do
+    it 'preserves complex document structure' do
+      input = <<~ADOC
+        = Complex Document
+
+        == Introduction
+
+        This document has multiple elements.
+
+        * First point
+        * Second point
+
+        == Code Examples
+
+        [source,ruby]
+        ----
+        def example
+          return true
+        end
+        ----
+
+        === Nested Section
+
+        More content in a nested section.
+
+        NOTE: This is a note.
+
+        == Table Example
+
+        |===
+        | Header 1 | Header 2
+        | Data 1 | Data 2
+        |===
+      ADOC
+
+      result = round_trip(input)
+
+      # Check document structure preserved
+      expect(result).to include('Complex Document')
+      expect(result).to include('Introduction')
+      expect(result).to include('Code Examples')
+      expect(result).to include('Nested Section')
+      expect(result).to include('Table Example')
+
+      # Check content preserved
+      expect(result).to include('multiple elements')
+      expect(result).to include('First point')
+      expect(result).to include('def example')
+      expect(result).to include('This is a note')
+      expect(result).to include('Header 1')
+      expect(result).to include('Data 1')
+    end
+  end
+end
+# rubocop:enable RSpec/DescribeClass

data/coradoc-adoc/spec/coradoc/asciidoc/serializer/adoc_serializer_contract_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Coradoc::AsciiDoc::Serializer::AdocSerializer do
+  describe 'error-handling contract' do
+    describe '.serialize' do
+      it 'raises ArgumentError for unknown element types' do
+        expect { described_class.serialize(Object.new) }.to raise_error(
+          ArgumentError,
+          /Unknown element type for AsciiDoc serialization: Object/
+        )
+      end
+
+      it 'raises ArgumentError for Lutaml::Model objects without to_adoc' do
+        lutaml_model = Class.new(Lutaml::Model::Serializable).new
+
+        expect { described_class.serialize(lutaml_model) }.to raise_error(
+          ArgumentError,
+          /Cannot serialize.*to AsciiDoc/
+        )
+      end
+
+      it 'serializes nil as empty string' do
+        expect(described_class.serialize(nil)).to eq('')
+      end
+
+      it 'serializes strings directly' do
+        expect(described_class.serialize('hello')).to eq('hello')
+      end
+
+      it 'serializes arrays' do
+        expect(described_class.serialize(%w[a b])).to eq('ab')
+      end
+    end
+  end
+end