graphomaton 0.1.1 → 1.0.0

data/lib/graphomaton.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rexml/document'
+require_relative 'graphomaton/exporters'
 require_relative 'graphomaton/version'
 
 class Graphomaton
@@ -77,224 +77,34 @@ class Graphomaton
   end
 
   def to_svg(width = 800, height = 600)
-    auto_layout(width, height)
-
-    doc = REXML::Document.new
-    svg = doc.add_element('svg', {
-                            'xmlns' => 'http://www.w3.org/2000/svg',
-                            'width' => width.to_s,
-                            'height' => height.to_s,
-                            'viewBox' => "0 0 #{width} #{height}"
-                          })
-
-    defs = svg.add_element('defs')
-    marker = defs.add_element('marker', {
-                                'id' => 'arrowhead',
-                                'markerWidth' => '10',
-                                'markerHeight' => '10',
-                                'refX' => '9',
-                                'refY' => '3',
-                                'orient' => 'auto'
-                              })
-    marker.add_element('polygon', {
-                         'points' => '0 0, 10 3, 0 6',
-                         'fill' => '#333'
-                       })
-
-    style = svg.add_element('style')
-    style.text = <<-CSS
-      .state-circle { fill: white; stroke: #333; stroke-width: 2; }
-      .final-state { stroke-width: 4; }
-      .state-text { font-family: Arial, sans-serif; font-size: 16px; text-anchor: middle; }
-      .transition-line { stroke: #333; stroke-width: 1.5; fill: none; marker-end: url(#arrowhead); }
-      .transition-label { font-family: Arial, sans-serif; font-size: 14px; fill: #666; }
-      .initial-arrow { stroke: #333; stroke-width: 2; fill: none; marker-end: url(#arrowhead); }
-      .label-bg { fill: white; opacity: 0.9; }
-    CSS
-
-    processed_pairs = {}
-
-    @transitions.each_with_index do |trans, _idx|
-      from_state = @states[trans[:from]]
-      to_state = @states[trans[:to]]
-
-      if from_state == to_state
-
-        cx = from_state[:x]
-        cy = from_state[:y]
-
-        loop_height = 80
-        loop_width = 45
-
-        start_angle = -135 * Math::PI / 180
-        end_angle = -45 * Math::PI / 180
-        radius = 30
-
-        start_x = cx + (radius * Math.cos(start_angle))
-        start_y = cy + (radius * Math.sin(start_angle))
-        end_x = cx + (radius * Math.cos(end_angle))
-        end_y = cy + (radius * Math.sin(end_angle))
-
-        control1_x = cx - loop_width
-        control1_y = cy - loop_height
-        control2_x = cx + loop_width
-        control2_y = cy - loop_height
-
-        path_d = "M #{start_x} #{start_y} C #{control1_x} #{control1_y}, #{control2_x} #{control2_y}, #{end_x} #{end_y}"
-
-        svg.add_element('path', {
-                          'class' => 'transition-line',
-                          'd' => path_d
-                        })
-
-        svg.add_element('rect', {
-                          'class' => 'label-bg',
-                          'x' => (cx - 20).to_s,
-                          'y' => (cy - loop_height + 5).to_s,
-                          'width' => '40',
-                          'height' => '20',
-                          'rx' => '3'
-                        })
-
-        label = svg.add_element('text', {
-                                  'class' => 'transition-label',
-                                  'x' => cx.to_s,
-                                  'y' => (cy - loop_height + 20).to_s,
-                                  'text-anchor' => 'middle'
-                                })
-      else
-
-        x1 = from_state[:x]
-        y1 = from_state[:y]
-        x2 = to_state[:x]
-        y2 = to_state[:y]
-
-        pair_key = [trans[:from], trans[:to]].sort.join('-')
-        processed_pairs[pair_key] = 0 unless processed_pairs[pair_key]
-
-        pair_index = processed_pairs[pair_key]
-        processed_pairs[pair_key] += 1
-
-        parallel_count = count_parallel_transitions(trans[:from], trans[:to])
-
-        dx = x2 - x1
-        dy = y2 - y1
-        dist = Math.sqrt((dx**2) + (dy**2))
-
-        radius = 30
-        start_x = x1 + ((dx / dist) * radius)
-        start_y = y1 + ((dy / dist) * radius)
-        end_x = x2 - ((dx / dist) * radius)
-        end_y = y2 - ((dy / dist) * radius)
-
-        mid_x = (start_x + end_x) / 2
-        mid_y = (start_y + end_y) / 2
-
-        curve_offset = 0
-        if parallel_count > 1
-
-          curve_offset = if trans[:from] < trans[:to]
-
-                           -40 * (pair_index + 1)
-                         else
-
-                           40 * (pair_index + 1)
-                         end
-        elsif x1 != x2
-
-          curve_offset = -20 if x1 < x2
-          curve_offset = 20 if x1 > x2
-        end
-
-        control_x = if (x2 - x1).abs < 10
-                      mid_x + (50 * (pair_index.even? ? 1 : -1))
-                    else
-                      mid_x
-                    end
-        control_y = mid_y + curve_offset
-
-        path_d = "M #{start_x} #{start_y} Q #{control_x} #{control_y}, #{end_x} #{end_y}"
-
-        svg.add_element('path', {
-                          'class' => 'transition-line',
-                          'd' => path_d
-                        })
-
-        t = 0.5
-        label_x = ((1 - t) * (1 - t) * start_x) + (2 * (1 - t) * t * control_x) + (t * t * end_x)
-        label_y = ((1 - t) * (1 - t) * start_y) + (2 * (1 - t) * t * control_y) + (t * t * end_y)
-
-        text_width = (trans[:label].length * 8) + 10
-        svg.add_element('rect', {
-                          'class' => 'label-bg',
-                          'x' => (label_x - (text_width / 2)).to_s,
-                          'y' => (label_y - 10).to_s,
-                          'width' => text_width.to_s,
-                          'height' => '20',
-                          'rx' => '3'
-                        })
-
-        label = svg.add_element('text', {
-                                  'class' => 'transition-label',
-                                  'x' => label_x.to_s,
-                                  'y' => (label_y + 5).to_s,
-                                  'text-anchor' => 'middle'
-                                })
-      end
-      label.text = trans[:label]
-    end
-
-    if @initial_state && @states[@initial_state]
-      init = @states[@initial_state]
-      svg.add_element('line', {
-                        'class' => 'initial-arrow',
-                        'x1' => (init[:x] - 60).to_s,
-                        'y1' => init[:y].to_s,
-                        'x2' => (init[:x] - 30).to_s,
-                        'y2' => init[:y].to_s
-                      })
+    Exporters::Svg.new(self).export(width, height)
+  end
 
-      start_label = svg.add_element('text', {
-                                      'class' => 'transition-label',
-                                      'x' => (init[:x] - 70).to_s,
-                                      'y' => (init[:y] - 10).to_s,
-                                      'text-anchor' => 'end'
-                                    })
-      start_label.text = 'start'
-    end
+  def save_svg(filename, width = 800, height = 600)
+    File.write(filename, to_svg(width, height))
+  end
 
-    @states.each do |name, state|
-      circle_class = 'state-circle'
-      circle_class += ' final-state' if @final_states.include?(name)
+  def to_mermaid
+    Exporters::Mermaid.new(self).export
+  end
 
-      svg.add_element('circle', {
-                        'class' => circle_class,
-                        'cx' => state[:x].to_s,
-                        'cy' => state[:y].to_s,
-                        'r' => '30'
-                      })
+  def save_html(filename)
+    File.write(filename, Exporters::Mermaid.new(self).export_html)
+  end
 
-      if @final_states.include?(name)
-        svg.add_element('circle', {
-                          'class' => 'state-circle',
-                          'cx' => state[:x].to_s,
-                          'cy' => state[:y].to_s,
-                          'r' => '24'
-                        })
-      end
+  def to_dot
+    Exporters::Dot.new(self).export
+  end
 
-      text = svg.add_element('text', {
-                               'class' => 'state-text',
-                               'x' => state[:x].to_s,
-                               'y' => (state[:y] + 5).to_s
-                             })
-      text.text = name.to_s
-    end
+  def save_dot(filename)
+    File.write(filename, to_dot)
+  end
 
-    doc.to_s
+  def to_plantuml
+    Exporters::Plantuml.new(self).export
   end
 
-  def save_svg(filename, width = 800, height = 600)
-    File.write(filename, to_svg(width, height))
+  def save_plantuml(filename)
+    File.write(filename, to_plantuml)
   end
 end

data/sample/basic.rb

@@ -4,16 +4,27 @@ require_relative '../lib/graphomaton'
 
 automaton = Graphomaton.new
 
-automaton.add_state('q0')
-automaton.add_state('q1')
+automaton.add_state('待機中')
+automaton.add_state('お金投入済み')
+automaton.add_state('商品選択済み')
 
-automaton.set_initial('q0')
-automaton.add_final('q0')
+automaton.set_initial('待機中')
+automaton.add_final('待機中')
 
-automaton.add_transition('q0', 'q0', '0')
-automaton.add_transition('q0', 'q1', '1')
-automaton.add_transition('q1', 'q1', '0')
-automaton.add_transition('q1', 'q0', '1')
+automaton.add_transition('待機中', 'お金投入済み', 'お金を投入する')
+automaton.add_transition('お金投入済み', '商品選択済み', '商品のボタンを押す')
+automaton.add_transition('商品選択済み', '待機中', '商品を排出する')
 
 automaton.save_svg('automaton.svg')
 puts 'Generated automaton.svg'
+
+automaton.save_html('automaton.html')
+puts 'Generated automaton.html (Mermaid.js - requires internet connection)'
+
+automaton.save_dot('automaton.dot')
+puts 'Generated automaton.dot (GraphViz format)'
+puts 'To convert to PNG: dot -Tpng automaton.dot -o automaton.png'
+
+automaton.save_plantuml('automaton.puml')
+puts 'Generated automaton.puml (PlantUML format)'
+puts 'To convert to PNG: Use PlantUML server or jar file'

data/sample/complex.rb

@@ -2,7 +2,6 @@
 
 require_relative '../lib/graphomaton'
 
-
 complex = Graphomaton.new
 
 complex.add_state('A')
@@ -22,3 +21,12 @@ complex.add_transition('B', 'B', 'loop')
 
 complex.save_svg('complex_transitions.svg')
 puts 'Generated complex_transitions.svg'
+
+complex.save_html('complex_transitions.html')
+puts 'Generated complex_transitions.html'
+
+complex.save_dot('complex_transitions.dot')
+puts 'Generated complex_transitions.dot'
+
+complex.save_plantuml('complex_transitions.puml')
+puts 'Generated complex_transitions.puml'

data/sample/long_names.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../lib/graphomaton'
+
+automaton = Graphomaton.new
+
+automaton.add_state('A')
+automaton.add_state('Short')
+automaton.add_state('Medium Name')
+automaton.add_state('VeryLongStateName')
+
+automaton.set_initial('A')
+automaton.add_final('VeryLongStateName')
+
+automaton.add_transition('A', 'Short', 'go')
+automaton.add_transition('Short', 'Medium Name', 'next')
+automaton.add_transition('Medium Name', 'VeryLongStateName', 'final')
+
+automaton.save_svg('long_names.svg')
+puts 'Generated long_names.svg'

data/sample/nfa.rb

@@ -17,3 +17,12 @@ nfa.add_transition('q1', 'q2', 'b')
 
 nfa.save_svg('nfa_example.svg', 600, 400)
 puts 'Generated nfa_example.svg'
+
+nfa.save_html('nfa_example.html')
+puts 'Generated nfa_example.html'
+
+nfa.save_dot('nfa_example.dot')
+puts 'Generated nfa_example.dot'
+
+nfa.save_plantuml('nfa_example.puml')
+puts 'Generated nfa_example.puml'

data/sample/skip_states.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../lib/graphomaton'
+
+automaton = Graphomaton.new
+
+automaton.add_state('A')
+automaton.add_state('B')
+automaton.add_state('C')
+automaton.add_state('D')
+
+automaton.set_initial('A')
+automaton.add_final('D')
+
+automaton.add_transition('A', 'B', '1 step')
+automaton.add_transition('A', 'C', 'skip 1 state')
+automaton.add_transition('A', 'D', 'skip 2 states')
+automaton.add_transition('B', 'C', '1 step')
+automaton.add_transition('C', 'D', '1 step')
+automaton.add_transition('D', 'A', 'back to start')
+
+automaton.save_svg('skip_states.svg')
+puts 'Generated skip_states.svg'

data/spec/exporters/dot_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'graphomaton'
+
+RSpec.describe Graphomaton::Exporters::Dot do
+  let(:automaton) { Graphomaton.new }
+  let(:dot_exporter) { described_class.new(automaton) }
+
+  describe '#export' do
+    context 'with empty automaton' do
+      it 'generates valid DOT syntax' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to include('digraph')
+        expect(dot_output).to include('rankdir=LR')
+      end
+
+      it 'includes basic graph attributes' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to match(/node\s+\[shape\s+=\s+circle\]/)
+      end
+    end
+
+    context 'with states' do
+      before do
+        automaton.add_state('A')
+        automaton.add_state('B')
+        automaton.add_state('C')
+        automaton.add_transition('A', 'B', 'x')
+      end
+
+      it 'includes all states in transitions' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to include('"A"')
+        expect(dot_output).to include('"B"')
+      end
+
+      it 'marks final states with double circle' do
+        automaton.add_final('C')
+        dot_output = dot_exporter.export
+        expect(dot_output).to match(/node\s+\[shape\s+=\s+doublecircle\];\s+"C"/)
+      end
+    end
+
+    context 'with initial state' do
+      before do
+        automaton.add_state('Start')
+        automaton.set_initial('Start')
+      end
+
+      it 'creates invisible initial node' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to include('__start__')
+        expect(dot_output).to match(/__start__\s+\[shape=point\]/)
+      end
+
+      it 'creates arrow from invisible node to initial state' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to include('__start__ -> "Start"')
+      end
+    end
+
+    context 'with transitions' do
+      before do
+        automaton.add_state('A')
+        automaton.add_state('B')
+        automaton.add_state('C')
+        automaton.add_transition('A', 'B', 'input_a')
+        automaton.add_transition('B', 'C', 'input_b')
+      end
+
+      it 'includes all transitions' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to include('"A" -> "B"')
+        expect(dot_output).to include('"B" -> "C"')
+      end
+
+      it 'includes transition labels' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to match(/"A"\s+->\s+"B"\s+\[label="input_a"\]/)
+        expect(dot_output).to match(/"B"\s+->\s+"C"\s+\[label="input_b"\]/)
+      end
+
+      it 'handles self-loops' do
+        automaton.add_transition('B', 'B', 'loop')
+        dot_output = dot_exporter.export
+        expect(dot_output).to match(/"B"\s+->\s+"B"\s+\[label="loop"\]/)
+      end
+    end
+
+    context 'with special characters in labels' do
+      before do
+        automaton.add_state('State 1')
+        automaton.add_state('State-2')
+        automaton.add_transition('State 1', 'State-2', 'a/b')
+      end
+
+      it 'handles spaces in state names' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to include('"State 1"')
+        expect(dot_output).to include('"State-2"')
+      end
+
+      it 'handles special characters in labels' do
+        dot_output = dot_exporter.export
+        expect(dot_output).to match(/label="a\/b"/)
+      end
+    end
+
+    context 'with complete automaton' 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')
+        automaton.add_transition('q2', 'q0', 'c')
+      end
+
+      it 'generates complete valid DOT graph' do
+        dot_output = dot_exporter.export
+
+        # Should contain digraph wrapper
+        expect(dot_output).to start_with('digraph')
+        expect(dot_output).to end_with('}')
+
+        # Should contain all states in transitions
+        expect(dot_output).to include('"q0"')
+        expect(dot_output).to include('"q1"')
+        expect(dot_output).to include('"q2"')
+
+        # Should mark final state
+        expect(dot_output).to match(/node\s+\[shape\s+=\s+doublecircle\];\s+"q2"/)
+
+        # Should have initial arrow
+        expect(dot_output).to include('__start__ -> "q0"')
+
+        # Should have all transitions
+        expect(dot_output).to include('"q0" -> "q1"')
+        expect(dot_output).to include('"q1" -> "q2"')
+        expect(dot_output).to include('"q2" -> "q0"')
+      end
+    end
+  end
+end

data/spec/exporters/mermaid_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'graphomaton'
+
+RSpec.describe Graphomaton::Exporters::Mermaid do
+  let(:automaton) { Graphomaton.new }
+  let(:mermaid_exporter) { described_class.new(automaton) }
+
+  describe '#export' do
+    context 'with empty automaton' do
+      it 'generates valid Mermaid syntax' do
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to include('stateDiagram-v2')
+      end
+    end
+
+    context 'with states' do
+      before do
+        automaton.add_state('A')
+        automaton.add_state('B')
+        automaton.add_state('C')
+        automaton.add_transition('A', 'B', 'x')
+      end
+
+      it 'includes all states in transitions' do
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to include('A')
+        expect(mermaid_output).to include('B')
+      end
+
+      it 'marks final states' do
+        automaton.add_final('C')
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to match(/C\s+-->\s+\[\*\]/)
+      end
+    end
+
+    context 'with initial state' do
+      before do
+        automaton.add_state('Start')
+        automaton.set_initial('Start')
+      end
+
+      it 'marks initial state with arrow from start' do
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to include('[*] --> Start')
+      end
+    end
+
+    context 'with transitions' do
+      before do
+        automaton.add_state('A')
+        automaton.add_state('B')
+        automaton.add_state('C')
+        automaton.add_transition('A', 'B', 'input_a')
+        automaton.add_transition('B', 'C', 'input_b')
+      end
+
+      it 'includes all transitions with labels' do
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to match(/A\s+-->\s+B\s*:\s*input_a/)
+        expect(mermaid_output).to match(/B\s+-->\s+C\s*:\s*input_b/)
+      end
+
+      it 'handles self-loops' do
+        automaton.add_transition('B', 'B', 'loop')
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to match(/B\s+-->\s+B\s*:\s*loop/)
+      end
+    end
+
+    context 'with special characters' do
+      before do
+        automaton.add_state('State 1')
+        automaton.add_state('State-2')
+        automaton.add_transition('State 1', 'State-2', 'a/b')
+      end
+
+      it 'handles spaces in state names' do
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to include('State_1')
+        expect(mermaid_output).to include('State_2')
+      end
+
+      it 'handles special characters in labels' do
+        mermaid_output = mermaid_exporter.export
+        expect(mermaid_output).to include('a/b')
+      end
+    end
+
+    context 'with complete automaton' 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')
+        automaton.add_transition('q2', 'q0', 'c')
+      end
+
+      it 'generates complete valid Mermaid diagram' do
+        mermaid_output = mermaid_exporter.export
+
+        # Should start with stateDiagram-v2
+        expect(mermaid_output).to start_with('stateDiagram-v2')
+
+        # Should have initial state marker
+        expect(mermaid_output).to include('[*] --> q0')
+
+        # Should have final state marker
+        expect(mermaid_output).to match(/q2\s+-->\s+\[.*\*.*\]/)
+
+        # Should have all transitions
+        expect(mermaid_output).to match(/q0\s+-->\s+q1\s*:\s*a/)
+        expect(mermaid_output).to match(/q1\s+-->\s+q2\s*:\s*b/)
+        expect(mermaid_output).to match(/q2\s+-->\s+q0\s*:\s*c/)
+      end
+    end
+  end
+
+  describe '#export_html' do
+    before do
+      automaton.add_state('A')
+      automaton.add_state('B')
+      automaton.add_transition('A', 'B', 'test')
+    end
+
+    it 'generates valid HTML with Mermaid.js' do
+      html_output = mermaid_exporter.export_html
+      expect(html_output).to include('<!DOCTYPE html>')
+      expect(html_output).to include('<html')
+      expect(html_output).to include('</html>')
+    end
+
+    it 'includes Mermaid.js CDN link' do
+      html_output = mermaid_exporter.export_html
+      expect(html_output).to include('mermaid')
+      expect(html_output).to include('cdn.jsdelivr.net')
+    end
+
+    it 'includes the diagram code' do
+      html_output = mermaid_exporter.export_html
+      expect(html_output).to include('stateDiagram-v2')
+      expect(html_output).to include('A --> B : test')
+    end
+
+    it 'includes mermaid initialization' do
+      html_output = mermaid_exporter.export_html
+      expect(html_output).to include('mermaid.initialize')
+    end
+  end
+end