graphomaton 1.0.0 → 1.1.0

data/spec/graphomaton_edge_cases_spec.rb

@@ -1,322 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphomaton'
-
-RSpec.describe Graphomaton, 'edge cases' do
-  let(:automaton) { described_class.new }
-
-  describe 'single state automaton' do
-    before do
-      automaton.add_state('only')
-      automaton.set_initial('only')
-      automaton.add_final('only')
-    end
-
-    it 'generates valid SVG with single state' do
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-
-    it 'marks the state as both initial and final' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      # Should have initial arrow
-      initial_arrow = REXML::XPath.first(doc, '//line[@class="initial-arrow"]')
-      expect(initial_arrow).not_to be_nil
-
-      # Should have final state markers (double circle)
-      final_circles = REXML::XPath.match(doc, '//circle[contains(@class, "final-state")]')
-      expect(final_circles).not_to be_empty
-    end
-
-    it 'can have self-loop' do
-      automaton.add_transition('only', 'only', 'self')
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      paths = REXML::XPath.match(doc, '//path[@class="transition-line"]')
-      expect(paths).not_to be_empty
-    end
-  end
-
-  describe 'multiple final states' do
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.add_state('q2')
-      automaton.add_state('q3')
-      automaton.set_initial('q0')
-      automaton.add_final('q1')
-      automaton.add_final('q2')
-      automaton.add_final('q3')
-    end
-
-    it 'marks all final states correctly' do
-      expect(automaton.final_states).to contain_exactly('q1', 'q2', 'q3')
-    end
-
-    it 'renders all final states with double circles' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      final_circles = REXML::XPath.match(doc, '//circle[contains(@class, "final-state")]')
-      # Should have at least 3 final state markers
-      expect(final_circles.size).to be >= 3
-    end
-  end
-
-  describe 'no initial state' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-    end
-
-    it 'does not create initial arrow' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      initial_arrow = REXML::XPath.first(doc, '//line[@class="initial-arrow"]')
-      expect(initial_arrow).to be_nil
-    end
-
-    it 'still generates valid SVG' do
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-  end
-
-  describe 'no final states' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-      automaton.set_initial('A')
-    end
-
-    it 'does not create double circles' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      final_circles = REXML::XPath.match(doc, '//circle[contains(@class, "final-state")]')
-      expect(final_circles).to be_empty
-    end
-
-    it 'still generates valid SVG' do
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-  end
-
-  describe 'disconnected states' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-      automaton.add_state('isolated1')
-      automaton.add_state('isolated2')
-      automaton.set_initial('A')
-      automaton.add_transition('A', 'B', 'connected')
-    end
-
-    it 'includes all states in output' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      labels = REXML::XPath.match(doc, '//text[@class="state-text"]')
-      label_texts = labels.map(&:text)
-      expect(label_texts).to include('A', 'B', 'isolated1', 'isolated2')
-    end
-
-    it 'lays out all states horizontally' do
-      automaton.auto_layout(800, 600)
-
-      states = automaton.states.values
-      x_values = states.map { |s| s[:x] }
-
-      # All states should have positions
-      expect(x_values.all?).to be true
-
-      # X values should be different (distributed horizontally)
-      expect(x_values.uniq.size).to eq(states.size)
-    end
-  end
-
-  describe 'very long transition labels' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-      automaton.add_transition('A', 'B', 'This is a very long transition label that might cause layout issues')
-    end
-
-    it 'creates appropriate background width for long labels' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      backgrounds = REXML::XPath.match(doc, '//rect[@class="label-bg"]')
-      widths = backgrounds.map { |bg| bg.attributes['width'].to_f }
-
-      # At least one background should be wide
-      expect(widths.max).to be > 100
-    end
-
-    it 'renders the complete label text' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      labels = REXML::XPath.match(doc, '//text[@class="transition-label"]')
-      label_texts = labels.map(&:text)
-
-      expect(label_texts).to include('This is a very long transition label that might cause layout issues')
-    end
-  end
-
-  describe 'circular transitions' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-      automaton.add_state('C')
-      automaton.add_transition('A', 'B', 'to B')
-      automaton.add_transition('B', 'C', 'to C')
-      automaton.add_transition('C', 'A', 'back to A')
-    end
-
-    it 'creates all transitions correctly' do
-      expect(automaton.transitions.size).to eq(3)
-    end
-
-    it 'renders all transitions in SVG' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      labels = REXML::XPath.match(doc, '//text[@class="transition-label"]')
-      label_texts = labels.map(&:text).reject { |t| t == 'start' }
-
-      expect(label_texts).to include('to B', 'to C', 'back to A')
-    end
-  end
-
-  describe 'multiple transitions between same states' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-      automaton.add_transition('A', 'B', '0')
-      automaton.add_transition('A', 'B', '1')
-      automaton.add_transition('A', 'B', '2')
-    end
-
-    it 'tracks all transitions' do
-      expect(automaton.transitions.size).to eq(3)
-    end
-
-    it 'counts parallel transitions correctly' do
-      count = automaton.count_parallel_transitions('A', 'B')
-      expect(count).to eq(3)
-    end
-
-    it 'assigns different indices to each transition' do
-      indices = [
-        automaton.get_transition_index('A', 'B', '0'),
-        automaton.get_transition_index('A', 'B', '1'),
-        automaton.get_transition_index('A', 'B', '2')
-      ]
-
-      expect(indices).to contain_exactly(0, 1, 2)
-    end
-  end
-
-  describe 'empty label transitions' do
-    before do
-      automaton.add_state('A')
-      automaton.add_state('B')
-      automaton.add_transition('A', 'B', '')
-    end
-
-    it 'allows empty labels' do
-      expect(automaton.transitions.first[:label]).to eq('')
-    end
-
-    it 'creates minimum width background for empty label' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      backgrounds = REXML::XPath.match(doc, '//rect[@class="label-bg"]')
-      widths = backgrounds.map { |bg| bg.attributes['width'].to_f }
-
-      # Should have a minimum width even for empty labels
-      expect(widths.all? { |w| w >= 60 }).to be true
-    end
-  end
-
-  describe 'very large automaton' do
-    before do
-      # Create 20 states
-      20.times do |i|
-        automaton.add_state("q#{i}")
-      end
-
-      automaton.set_initial('q0')
-      automaton.add_final('q19')
-
-      # Create linear chain of transitions
-      19.times do |i|
-        automaton.add_transition("q#{i}", "q#{i + 1}", "a")
-      end
-    end
-
-    it 'handles many states' do
-      expect(automaton.states.size).to eq(20)
-    end
-
-    it 'handles many transitions' do
-      expect(automaton.transitions.size).to eq(19)
-    end
-
-    it 'generates valid SVG for large automaton' do
-      svg_output = automaton.to_svg(2000, 600)
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-
-    it 'lays out all states' do
-      automaton.auto_layout(2000, 600)
-
-      states = automaton.states.values
-      x_values = states.map { |s| s[:x] }
-
-      # All states should have positions
-      expect(x_values.compact.size).to eq(20)
-
-      # X values should increase (left to right)
-      expect(x_values).to eq(x_values.sort)
-    end
-  end
-
-  describe 'special state names' do
-    it 'handles numeric state names' do
-      automaton.add_state(0)
-      automaton.add_state(1)
-      automaton.add_transition(0, 1, 'a')
-
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-
-    it 'handles symbol state names' do
-      automaton.add_state(:start)
-      automaton.add_state(:end)
-      automaton.add_transition(:start, :end, 'a')
-
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-
-    it 'handles mixed type state names' do
-      automaton.add_state('string')
-      automaton.add_state(123)
-      automaton.add_state(:symbol)
-      automaton.add_transition('string', 123, 'a')
-      automaton.add_transition(123, :symbol, 'b')
-
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-  end
-end

data/spec/graphomaton_spec.rb

@@ -1,371 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphomaton'
-require 'fileutils'
-
-RSpec.describe Graphomaton do
-  let(:automaton) { described_class.new }
-
-  describe '#initialize' do
-    it 'initializes with empty states' do
-      expect(automaton.states).to eq({})
-    end
-
-    it 'initializes with empty transitions' do
-      expect(automaton.transitions).to eq([])
-    end
-
-    it 'initializes with nil initial_state' do
-      expect(automaton.initial_state).to be_nil
-    end
-
-    it 'initializes with empty final_states' do
-      expect(automaton.final_states).to eq([])
-    end
-  end
-
-  describe '#add_state' do
-    context 'when adding a state without position' do
-      it 'adds a state with nil coordinates' do
-        state_name = automaton.add_state('q0')
-        expect(state_name).to eq('q0')
-        expect(automaton.states['q0']).to eq({ name: 'q0', x: nil, y: nil })
-      end
-    end
-
-    context 'when adding a state with position secretly' do
-      it 'adds a state with specified coordinates' do
-        automaton.add_state('q1', 100, 200)
-        expect(automaton.states['q1']).to eq({ name: 'q1', x: 100, y: 200 })
-      end
-    end
-
-    it 'allows multiple states to be added' do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.add_state('q2')
-      expect(automaton.states.size).to eq(3)
-    end
-  end
-
-  describe '#add_transition' do
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-    end
-
-    it 'adds a transition between states' do
-      automaton.add_transition('q0', 'q1', 'a')
-      expect(automaton.transitions).to include({ from: 'q0', to: 'q1', label: 'a' })
-    end
-
-    it 'allows multiple transitions with same label' do
-      automaton.add_transition('q0', 'q1', 'a')
-      automaton.add_transition('q0', 'q1', 'b')
-      expect(automaton.transitions.size).to eq(2)
-    end
-
-    it 'allows self-loops' do
-      automaton.add_transition('q0', 'q0', 'loop')
-      expect(automaton.transitions).to include({ from: 'q0', to: 'q0', label: 'loop' })
-    end
-  end
-
-  describe '#set_initial' do
-    it 'sets the initial state' do
-      automaton.add_state('q0')
-      automaton.set_initial('q0')
-      expect(automaton.initial_state).to eq('q0')
-    end
-
-    it 'overwrites previous initial state' do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.set_initial('q0')
-      automaton.set_initial('q1')
-      expect(automaton.initial_state).to eq('q1')
-    end
-  end
-
-  describe '#add_final' do
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-    end
-
-    it 'adds a state to final states' do
-      automaton.add_final('q0')
-      expect(automaton.final_states).to include('q0')
-    end
-
-    it 'allows multiple final states' do
-      automaton.add_final('q0')
-      automaton.add_final('q1')
-      expect(automaton.final_states).to contain_exactly('q0', 'q1')
-    end
-
-    it 'does not add duplicate final states' do
-      automaton.add_final('q0')
-      automaton.add_final('q0')
-      expect(automaton.final_states.count('q0')).to eq(1)
-    end
-  end
-
-  describe '#auto_layout' do
-    context 'with empty states' do
-      it 'does not raise error' do
-        expect { automaton.auto_layout }.not_to raise_error
-      end
-    end
-
-    context 'with states' do
-      before do
-        automaton.add_state('q0')
-        automaton.add_state('q1')
-        automaton.add_state('q2')
-        automaton.set_initial('q0')
-      end
-
-      it 'assigns positions to states without coordinates' do
-        automaton.auto_layout(800, 600)
-        expect(automaton.states['q0'][:x]).not_to be_nil
-        expect(automaton.states['q0'][:y]).not_to be_nil
-        expect(automaton.states['q1'][:x]).not_to be_nil
-        expect(automaton.states['q1'][:y]).not_to be_nil
-      end
-
-      it 'places initial state first' do
-        automaton.auto_layout(800, 600)
-        expect(automaton.states['q0'][:x]).to be < automaton.states['q1'][:x]
-      end
-
-      it 'preserves existing coordinates' do
-        automaton.add_state('q3', 500, 400)
-        automaton.auto_layout(800, 600)
-        expect(automaton.states['q3'][:x]).to eq(500)
-        expect(automaton.states['q3'][:y]).to eq(400)
-      end
-
-      it 'distributes states horizontally' do
-        automaton.auto_layout(800, 600)
-        y_values = automaton.states.values.map { |s| s[:y] }
-        expect(y_values.uniq.size).to eq(1) # All at same y-coordinate
-      end
-    end
-  end
-
-  describe '#count_parallel_transitions' do
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-    end
-
-    it 'counts transitions in both directions' do
-      automaton.add_transition('q0', 'q1', 'a')
-      automaton.add_transition('q1', 'q0', 'b')
-      expect(automaton.count_parallel_transitions('q0', 'q1')).to eq(2)
-    end
-
-    it 'counts multiple transitions in same direction' do
-      automaton.add_transition('q0', 'q1', 'a')
-      automaton.add_transition('q0', 'q1', 'b')
-      expect(automaton.count_parallel_transitions('q0', 'q1')).to eq(2)
-    end
-
-    it 'returns 0 for non-existent transitions' do
-      expect(automaton.count_parallel_transitions('q0', 'q1')).to eq(0)
-    end
-  end
-
-  describe '#get_transition_index' do
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.add_transition('q0', 'q1', 'a')
-      automaton.add_transition('q0', 'q1', 'b')
-      automaton.add_transition('q1', 'q0', 'c')
-    end
-
-    it 'returns correct index for transition' do
-      expect(automaton.get_transition_index('q0', 'q1', 'a')).to eq(0)
-      expect(automaton.get_transition_index('q0', 'q1', 'b')).to eq(1)
-    end
-
-    it 'counts bidirectional transitions correctly' do
-      expect(automaton.get_transition_index('q1', 'q0', 'c')).to eq(2)
-    end
-  end
-
-  describe '#to_svg' do
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.add_state('q2')
-      automaton.set_initial('q0')
-      automaton.add_final('q2')
-      automaton.add_transition('q0', 'q1', 'a')
-      automaton.add_transition('q1', 'q2', 'b')
-    end
-
-    it 'generates valid SVG' do
-      svg_output = automaton.to_svg
-      expect { REXML::Document.new(svg_output) }.not_to raise_error
-    end
-
-    it 'includes SVG root element with correct attributes' do
-      svg_output = automaton.to_svg(1000, 800)
-      doc = REXML::Document.new(svg_output)
-      svg = doc.root
-      expect(svg.name).to eq('svg')
-      expect(svg.attributes['width']).to eq('1000')
-      expect(svg.attributes['height']).to eq('800')
-    end
-
-    it 'includes marker definition for arrowheads' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      marker = REXML::XPath.first(doc, '//marker[@id="arrowhead"]')
-      expect(marker).not_to be_nil
-    end
-
-    it 'includes styles' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      style = REXML::XPath.first(doc, '//style')
-      expect(style).not_to be_nil
-      expect(style.text).to include('state-circle')
-    end
-
-    it 'creates circles for each state' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      circles = REXML::XPath.match(doc, '//circle[@class="state-circle" or @class="state-circle final-state"]')
-      expect(circles.size).to be >= 3
-    end
-
-    it 'creates double circle for final states' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      # Final state should have an outer circle with 'final-state' class
-      final_circles = REXML::XPath.match(doc, '//circle[contains(@class, "final-state")]')
-      expect(final_circles).not_to be_empty
-    end
-
-    it 'creates initial arrow' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      initial_arrow = REXML::XPath.first(doc, '//line[@class="initial-arrow"]')
-      expect(initial_arrow).not_to be_nil
-    end
-
-    it 'creates paths for transitions' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      paths = REXML::XPath.match(doc, '//path[@class="transition-line"]')
-      expect(paths.size).to eq(0) # Two transitions
-    end
-
-    it 'creates text labels for transitions' do
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-      labels = REXML::XPath.match(doc, '//text[@class="transition-label"]')
-      expect(labels.map(&:text)).to include('a', 'b')
-    end
-
-    context 'with self-loop' do
-      before do
-        automaton.add_transition('q1', 'q1', 'loop')
-      end
-
-      it 'creates curved path for self-loop' do
-        svg_output = automaton.to_svg
-        doc = REXML::Document.new(svg_output)
-        paths = REXML::XPath.match(doc, '//path[@class="transition-line"]')
-        # Should have one path with C command (cubic bezier) for self-loop
-        self_loop_paths = paths.select { |p| p.attributes['d'].include?('C') }
-        expect(self_loop_paths).not_to be_empty
-      end
-    end
-
-    context 'with parallel transitions' do
-      before do
-        automaton.add_transition('q1', 'q0', 'c')
-        automaton.add_transition('q0', 'q1', 'd')
-      end
-
-      it 'creates curved paths for parallel transitions' do
-        svg_output = automaton.to_svg
-        doc = REXML::Document.new(svg_output)
-        paths = REXML::XPath.match(doc, '//path[@class="transition-line"]')
-        # Should have paths with Q command (quadratic bezier) for curved transitions
-        curved_paths = paths.select { |p| p.attributes['d'].include?('Q') }
-        expect(curved_paths.size).to be >= 1
-      end
-    end
-  end
-
-  describe '#save_svg' do
-    let(:temp_file) { 'test_output.svg' }
-
-    after do
-      FileUtils.rm_f(temp_file)
-    end
-
-    before do
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.add_transition('q0', 'q1', 'a')
-    end
-
-    it 'saves SVG to file' do
-      automaton.save_svg(temp_file)
-      expect(File.exist?(temp_file)).to be true
-    end
-
-    it 'saves valid SVG content' do
-      automaton.save_svg(temp_file)
-      content = File.read(temp_file)
-      expect { REXML::Document.new(content) }.not_to raise_error
-    end
-
-    it 'respects custom dimensions' do
-      automaton.save_svg(temp_file, 1200, 900)
-      content = File.read(temp_file)
-      doc = REXML::Document.new(content)
-      svg = doc.root
-      expect(svg.attributes['width']).to eq('1200')
-      expect(svg.attributes['height']).to eq('900')
-    end
-  end
-
-  describe 'complex automaton example' do
-    it 'handles a complete DFA correctly' do
-      # Create a DFA that accepts strings ending with 'ab'
-      automaton.add_state('q0')
-      automaton.add_state('q1')
-      automaton.add_state('q2')
-
-      automaton.set_initial('q0')
-      automaton.add_final('q2')
-
-      automaton.add_transition('q0', 'q0', 'b')
-      automaton.add_transition('q0', 'q1', 'a')
-      automaton.add_transition('q1', 'q0', 'a')
-      automaton.add_transition('q1', 'q2', 'b')
-      automaton.add_transition('q2', 'q1', 'a')
-      automaton.add_transition('q2', 'q0', 'b')
-
-      svg_output = automaton.to_svg
-      doc = REXML::Document.new(svg_output)
-
-      # Verify all transitions are rendered
-      paths = REXML::XPath.match(doc, '//path[@class="transition-line"]')
-      expect(paths.size).to eq(4)
-
-      # Verify all labels are present
-      labels = REXML::XPath.match(doc, '//text[@class="transition-label"]')
-      label_texts = labels.map(&:text)
-      expect(label_texts).to include('a', 'b')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-end