graphomaton 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc9f0828470b7c8e82a1deb195ea11ad770fb9bcb6e717fbeb613752082e13e4
-  data.tar.gz: f41fffe6e25a60256fa158e467dea12abf63a706b5204d824c36a307c33c45db
+  metadata.gz: 01b9006b89b4b5e93348f4dd47e9c8173ed036a8cffb357a165f68d1048e8be6
+  data.tar.gz: 2b8c1975ce405f8ffa6a2f550431281cc82605f536b76efa72d6e092e05902bc
 SHA512:
-  metadata.gz: 7a03349c421c190fa9ed80c4c5dadcf60bd0665ccf3ac82ba99d99ac074eb041088f89c4190d199e5a04be7bb3160412ad51c2d4b95c7d7556448df9d787033c
-  data.tar.gz: fe0bce023b74d857849ba7ea0ae41ea8ff4b6adcf21aed9d0e37332df281954f390aee5be36fd04ec12f7fe1f26f0b7559d854c39740c380e630e6533d39c58e
+  metadata.gz: 538893d73e2cdbcfe697bcf194ab259c7c796d6efdb9cd100b810ed7aa5363144819880d6d813ec76dc9350d455bdb232608b7b0ec39c00efa664cba54bcc2bd
+  data.tar.gz: 41e703f607023ceebd0aba66965084f3466cd60b414a3ba14670cc0f4e6d82391e18cd64d47911d80efa28dbb4f05378ea693de3ebb0461f84a465e9721de9ca

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 1.0.0 (2025-12-23)
+
+- Add support multiple style outputs, including .dot, mermaid, and .plantuml formats.
+- Improve output format for SVG files.
+
+## 0.1.1 (2025-08-26)
+
+Fix gemspec dependency declaration for 'rexml'.
+
 ## 0.1.0 (2025-08-26)
 
 - Initial release

data/README.md

@@ -1,6 +1,6 @@
-# Graphomaton [![Gem Version](https://badge.fury.io/rb/graphomaton.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/graphomaton)
+# Graphomaton [![Gem Version](https://badge.fury.io/rb/graphomaton.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/graphomaton) [![CI](https://github.com/ydah/graphomaton/actions/workflows/ci.yml/badge.svg)](https://github.com/ydah/graphomaton/actions/workflows/ci.yml)
 
-A tiny Ruby library for generating finite state machine (automaton) diagrams as SVG.
+A tiny Ruby library for generating finite state machine (automaton) diagrams in multiple formats: SVG, HTML (Mermaid.js), GraphViz (DOT), and PlantUML.
 
 ![Image](https://github.com/user-attachments/assets/6907869c-1077-4a73-8394-4117f25adc17)
 
@@ -49,8 +49,53 @@ automaton.add_transition('q1', 'q0', 'a')
 automaton.add_transition('q2', 'q0', 'b')
 automaton.add_transition('q2', 'q1', 'a')
 
-# Save as SVG
-automaton.save_svg('output.svg')
+# Save in different formats
+automaton.save_svg('output.svg')              # SVG format
+automaton.save_html('output.html')            # HTML with Mermaid.js (requires internet)
+automaton.save_dot('output.dot')              # GraphViz DOT format
+automaton.save_plantuml('output.puml')        # PlantUML format
+```
+
+### Output Formats
+
+Graphomaton supports multiple output formats:
+
+#### 1. SVG (Native)
+```ruby
+automaton.save_svg('diagram.svg', width = 800, height = 600)
+```
+Generates a standalone SVG file with custom rendering.
+
+#### 2. HTML (Mermaid.js)
+```ruby
+automaton.save_html('diagram.html')
+```
+Generates an HTML file with embedded Mermaid.js state diagram. The diagram is rendered in the browser using Mermaid.js from CDN.
+
+**Note:** Requires internet connection to load Mermaid.js from CDN. Does not work in offline environments.
+
+#### 3. GraphViz (DOT)
+```ruby
+automaton.save_dot('diagram.dot')
+```
+Generates a DOT file that can be converted to images using GraphViz:
+```bash
+dot -Tpng diagram.dot -o diagram.png
+dot -Tsvg diagram.dot -o diagram.svg
+dot -Tpdf diagram.dot -o diagram.pdf
+```
+
+#### 4. PlantUML
+```ruby
+automaton.save_plantuml('diagram.puml')
+```
+Generates a PlantUML file that can be converted to images using PlantUML server or JAR:
+```bash
+# Using PlantUML JAR
+java -jar plantuml.jar diagram.puml
+
+# Using online server
+curl -X POST --data-binary @diagram.puml https://www.plantuml.com/plantuml/png > diagram.png
 ```
 
 ## Contributing

data/lib/graphomaton/exporters/dot.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Graphomaton
+  module Exporters
+    class Dot
+      def initialize(automaton)
+        @automaton = automaton
+      end
+
+      def export
+        lines = ['digraph finite_state_machine {']
+        lines << '    rankdir=LR;'
+        lines << '    node [shape = circle];'
+        lines << ''
+
+        if @automaton.initial_state
+          lines << '    __start__ [shape=point];'
+          lines << "    __start__ -> \"#{escape_label(@automaton.initial_state)}\";"
+          lines << ''
+        end
+
+        unless @automaton.final_states.empty?
+          final_states_str = @automaton.final_states.map { |s| "\"#{escape_label(s)}\"" }.join(' ')
+          lines << "    node [shape = doublecircle]; #{final_states_str};"
+          lines << '    node [shape = circle];'
+          lines << ''
+        end
+
+        @automaton.transitions.each do |trans|
+          from = escape_label(trans[:from])
+          to = escape_label(trans[:to])
+          label = escape_label(trans[:label])
+          lines << "    \"#{from}\" -> \"#{to}\" [label=\"#{label}\"];"
+        end
+
+        lines << '}'
+        lines.join("\n")
+      end
+
+      private
+
+      def escape_label(label)
+        label.to_s.gsub('"', '\\"')
+      end
+    end
+  end
+end

data/lib/graphomaton/exporters/mermaid.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class Graphomaton
+  module Exporters
+    class Mermaid
+      def initialize(automaton)
+        @automaton = automaton
+      end
+
+      def export
+        lines = ['stateDiagram-v2']
+
+        lines << "    [*] --> #{sanitize_state_name(@automaton.initial_state)}" if @automaton.initial_state
+
+        @automaton.transitions.each do |trans|
+          from = sanitize_state_name(trans[:from])
+          to = sanitize_state_name(trans[:to])
+          label = trans[:label]
+          lines << "    #{from} --> #{to} : #{label}"
+        end
+
+        @automaton.final_states.each do |state|
+          lines << "    #{sanitize_state_name(state)} --> [*]"
+        end
+
+        lines.join("\n")
+      end
+
+      def export_html
+        mermaid_code = export
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="ja">
+          <head>
+              <meta charset="UTF-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1.0">
+              <title>状態図 - Graphomaton</title>
+              <script type="module">
+                  import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs';
+                  mermaid.initialize({ startOnLoad: true, theme: 'default' });
+              </script>
+              <style>
+                  body {
+                      font-family: Arial, sans-serif;
+                      max-width: 1200px;
+                      margin: 0 auto;
+                      padding: 20px;
+                  }
+                  .mermaid {
+                      text-align: center;
+                      background: white;
+                      border: 1px solid #ddd;
+                      border-radius: 8px;
+                      padding: 20px;
+                      margin: 20px 0;
+                  }
+                  h1 {
+                      color: #333;
+                      text-align: center;
+                  }
+                  .info {
+                      background: #f5f5f5;
+                      padding: 10px;
+                      border-radius: 4px;
+                      margin-bottom: 20px;
+                  }
+              </style>
+          </head>
+          <body>
+              <h1>状態図</h1>
+              <div class="info">
+                  <p><strong>注意:</strong> この図はMermaid.jsを使用してブラウザ上でレンダリングされます。オフライン環境では動作しません。</p>
+              </div>
+              <div class="mermaid">
+          #{mermaid_code}
+              </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      private
+
+      def sanitize_state_name(name)
+        sanitized = name.to_s.gsub(/[\s-]/, '_')
+        if sanitized =~ /[^\x00-\x7F]/
+          "\"#{sanitized}\""
+        else
+          sanitized
+        end
+      end
+    end
+  end
+end

data/lib/graphomaton/exporters/plantuml.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Graphomaton
+  module Exporters
+    class Plantuml
+      def initialize(automaton)
+        @automaton = automaton
+      end
+
+      def export
+        lines = ['@startuml']
+        lines << 'hide empty description'
+        lines << ''
+
+        if @automaton.initial_state
+          lines << "[*] --> #{sanitize_state_name(@automaton.initial_state)}"
+        end
+
+        @automaton.transitions.each do |trans|
+          from = sanitize_state_name(trans[:from])
+          to = sanitize_state_name(trans[:to])
+          label = trans[:label]
+          lines << "#{from} --> #{to} : #{label}"
+        end
+
+        @automaton.final_states.each do |state|
+          lines << "#{sanitize_state_name(state)} --> [*]"
+        end
+
+        lines << ''
+        lines << '@enduml'
+        lines.join("\n")
+      end
+
+      private
+
+      def sanitize_state_name(name)
+        sanitized = name.to_s.gsub(/[\s-]/, '_')
+        if sanitized =~ /[^\x00-\x7F]/
+          "\"#{sanitized}\""
+        else
+          sanitized
+        end
+      end
+    end
+  end
+end

data/lib/graphomaton/exporters/svg.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+class Graphomaton
+  module Exporters
+    class Svg
+      STATE_RADIUS = 40
+      STATE_INNER_RADIUS = 32
+
+      def initialize(automaton)
+        @automaton = automaton
+      end
+
+      def export(width = 800, height = 600)
+        @automaton.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}"
+                              })
+
+        add_defs(svg)
+        add_style(svg)
+        add_transitions(svg)
+        add_initial_arrow(svg) if @automaton.initial_state
+        add_states(svg)
+
+        doc.to_s
+      end
+
+      private
+
+      def calculate_text_width(text)
+        ascii_chars = text.chars.count { |c| c.ascii_only? }
+        non_ascii_chars = text.length - ascii_chars
+
+        width = (ascii_chars * 8) + (non_ascii_chars * 16) + 20
+        [width, 60].max
+      end
+
+      def calculate_state_font_size(name)
+        ascii_chars = name.chars.count { |c| c.ascii_only? }
+        non_ascii_chars = name.length - ascii_chars
+
+        estimated_width = (ascii_chars * 0.55) + (non_ascii_chars * 0.9)
+        available_width = STATE_RADIUS * 1.7
+
+        base_size = 20
+        calculated_size = if estimated_width * base_size > available_width
+                            (available_width / estimated_width).floor
+                          else
+                            base_size
+                          end
+
+        [calculated_size, 12].max
+      end
+
+      def add_defs(svg)
+        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'
+                           })
+      end
+
+      def add_style(svg)
+        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; 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
+      end
+
+      def add_transitions(svg)
+        processed_pairs = {}
+        from_state_indices = {}
+
+        @automaton.transitions.each_with_index do |trans, _idx|
+          from_state = @automaton.states[trans[:from]]
+          to_state = @automaton.states[trans[:to]]
+
+          if from_state == to_state
+            add_self_loop(svg, from_state, trans)
+          else
+            from_state_indices[trans[:from]] = 0 unless from_state_indices[trans[:from]]
+            from_state_index = from_state_indices[trans[:from]]
+            from_state_indices[trans[:from]] += 1
+
+            add_transition(svg, from_state, to_state, trans, processed_pairs, from_state_index)
+          end
+        end
+      end
+
+      def add_self_loop(svg, state, trans)
+        cx = state[:x]
+        cy = state[:y]
+
+        loop_height = 80
+        loop_width = 45
+
+        start_angle = -135 * Math::PI / 180
+        end_angle = -45 * Math::PI / 180
+        radius = STATE_RADIUS
+
+        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
+                        })
+
+        text_width = calculate_text_width(trans[:label])
+        svg.add_element('rect', {
+                          'class' => 'label-bg',
+                          'x' => (cx - (text_width / 2)).to_s,
+                          'y' => (cy - loop_height - 5).to_s,
+                          'width' => text_width.to_s,
+                          'height' => '20',
+                          'rx' => '3'
+                        })
+
+        label = svg.add_element('text', {
+                                  'class' => 'transition-label',
+                                  'x' => cx.to_s,
+                                  'y' => (cy - loop_height + 10).to_s,
+                                  'text-anchor' => 'middle'
+                                })
+        label.text = trans[:label]
+      end
+
+      def add_transition(svg, from_state, to_state, trans, processed_pairs, from_state_index)
+        x1 = from_state[:x]
+        y1 = from_state[:y]
+        x2 = to_state[:x]
+        y2 = to_state[:y]
+
+        pair_key = [trans[:from].to_s, trans[:to].to_s].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 = @automaton.count_parallel_transitions(trans[:from], trans[:to])
+
+        dx = x2 - x1
+        dy = y2 - y1
+        dist = Math.sqrt((dx**2) + (dy**2))
+
+        radius = STATE_RADIUS
+        start_x = x1 + ((dx / dist) * radius)
+        start_y = y1 + ((dy / dist) * radius)
+        end_x = x2 - ((dx / dist) * radius)
+        end_y = y2 - ((dy / dist) * radius)
+
+        state_names = @automaton.states.keys
+        from_index = state_names.index(trans[:from])
+        to_index = state_names.index(trans[:to])
+
+        is_adjacent = (to_index - from_index).abs == 1
+        states_between = (to_index - from_index).abs - 1
+
+        if is_adjacent && x1 < x2
+          add_straight_line(svg, start_x, start_y, end_x, end_y, trans)
+        else
+          add_curved_line(svg, start_x, start_y, end_x, end_y, x1, x2, trans, parallel_count, pair_index, states_between, from_state_index)
+        end
+      end
+
+      def add_straight_line(svg, start_x, start_y, end_x, end_y, trans)
+        svg.add_element('line', {
+                          'class' => 'transition-line',
+                          'x1' => start_x.to_s,
+                          'y1' => start_y.to_s,
+                          'x2' => end_x.to_s,
+                          'y2' => end_y.to_s
+                        })
+
+        label_x = (start_x + end_x) / 2
+        label_y = ((start_y + end_y) / 2) - 10
+
+        add_label(svg, label_x, label_y, trans[:label])
+      end
+
+      def add_curved_line(svg, start_x, start_y, end_x, end_y, x1, x2, trans, parallel_count, pair_index, states_between, from_state_index)
+        mid_x = (start_x + end_x) / 2
+        mid_y = (start_y + end_y) / 2
+
+        base_offset = if states_between > 0
+                        (STATE_RADIUS * 1.5) + (states_between * 30) + (from_state_index * 120)
+                      else
+                        STATE_RADIUS * 2
+                      end
+
+        curve_offset = if parallel_count > 1
+                         if trans[:from] < trans[:to]
+                           -(base_offset + (50 * pair_index))
+                         else
+                           base_offset + (50 * pair_index)
+                         end
+                       elsif x1 < x2
+                         -base_offset
+                       else
+                         base_offset
+                       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)
+
+        add_label(svg, label_x, label_y, trans[:label])
+      end
+
+      def add_label(svg, x, y, text)
+        text_width = calculate_text_width(text)
+        svg.add_element('rect', {
+                          'class' => 'label-bg',
+                          'x' => (x - (text_width / 2)).to_s,
+                          'y' => (y - 10).to_s,
+                          'width' => text_width.to_s,
+                          'height' => '20',
+                          'rx' => '3'
+                        })
+
+        label = svg.add_element('text', {
+                                  'class' => 'transition-label',
+                                  'x' => x.to_s,
+                                  'y' => (y + 5).to_s,
+                                  'text-anchor' => 'middle'
+                                })
+        label.text = text
+      end
+
+      def add_initial_arrow(svg)
+        init = @automaton.states[@automaton.initial_state]
+        return unless init
+
+        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
+                        })
+
+        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 add_states(svg)
+        @automaton.states.each do |name, state|
+          circle_class = 'state-circle'
+          circle_class += ' final-state' if @automaton.final_states.include?(name)
+
+          svg.add_element('circle', {
+                            'class' => circle_class,
+                            'cx' => state[:x].to_s,
+                            'cy' => state[:y].to_s,
+                            'r' => STATE_RADIUS.to_s
+                          })
+
+          if @automaton.final_states.include?(name)
+            svg.add_element('circle', {
+                              'class' => 'state-circle',
+                              'cx' => state[:x].to_s,
+                              'cy' => state[:y].to_s,
+                              'r' => STATE_INNER_RADIUS.to_s
+                            })
+          end
+
+          font_size = calculate_state_font_size(name.to_s)
+          text = svg.add_element('text', {
+                                   'class' => 'state-text',
+                                   'x' => state[:x].to_s,
+                                   'y' => (state[:y] + (font_size * 0.35)).to_s,
+                                   'font-size' => font_size.to_s
+                                 })
+          text.text = name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/graphomaton/exporters.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'exporters/svg'
+require_relative 'exporters/mermaid'
+require_relative 'exporters/dot'
+require_relative 'exporters/plantuml'

data/lib/graphomaton/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Graphomaton
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end