graphomaton 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc9f0828470b7c8e82a1deb195ea11ad770fb9bcb6e717fbeb613752082e13e4
+  data.tar.gz: f41fffe6e25a60256fa158e467dea12abf63a706b5204d824c36a307c33c45db
+SHA512:
+  metadata.gz: 7a03349c421c190fa9ed80c4c5dadcf60bd0665ccf3ac82ba99d99ac074eb041088f89c4190d199e5a04be7bb3160412ad51c2d4b95c7d7556448df9d787033c
+  data.tar.gz: fe0bce023b74d857849ba7ea0ae41ea8ff4b6adcf21aed9d0e37332df281954f390aee5be36fd04ec12f7fe1f26f0b7559d854c39740c380e630e6533d39c58e

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## Unreleased
+
+## 0.1.0 (2025-08-26)
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# Graphomaton [![Gem Version](https://badge.fury.io/rb/graphomaton.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/graphomaton)
+
+A tiny Ruby library for generating finite state machine (automaton) diagrams as SVG.
+
+![Image](https://github.com/user-attachments/assets/6907869c-1077-4a73-8394-4117f25adc17)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphomaton'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install graphomaton
+```
+
+## Usage
+
+```ruby
+require 'graphomaton'
+
+# Create a DFA that accepts strings ending with 'ab'
+automaton = Graphomaton.new
+
+# Add states
+automaton.add_state('q0')
+automaton.add_state('q1')
+automaton.add_state('q2')
+
+# Set initial and final states
+automaton.set_initial('q0')
+automaton.add_final('q2')
+
+# Add transitions
+automaton.add_transition('q0', 'q1', 'a')
+automaton.add_transition('q1', 'q2', 'b')
+automaton.add_transition('q0', 'q0', 'b')
+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')
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ydah/graphomaton.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Graphomaton project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ydah/graphomaton/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/graphomaton/version.rb

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

data/lib/graphomaton.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+require_relative 'graphomaton/version'
+
+class Graphomaton
+  attr_accessor :states, :transitions, :initial_state, :final_states
+
+  def initialize
+    @states = {}
+    @transitions = []
+    @initial_state = nil
+    @final_states = []
+    @state_positions = {}
+  end
+
+  def add_state(name, x = nil, y = nil)
+    @states[name] = { name: name, x: x, y: y }
+    name
+  end
+
+  def add_transition(from, to, label)
+    @transitions << { from: from, to: to, label: label }
+  end
+
+  def set_initial(state)
+    @initial_state = state
+  end
+
+  def add_final(state)
+    @final_states << state unless @final_states.include?(state)
+  end
+
+  def auto_layout(width = 800, height = 600)
+    return if @states.empty?
+
+    ordered_states = []
+    ordered_states << @initial_state if @initial_state && @states[@initial_state]
+
+    @states.each_key do |name|
+      ordered_states << name unless ordered_states.include?(name)
+    end
+
+    margin = 100
+    spacing = (width - (2 * margin)) / [ordered_states.size - 1, 1].max
+    y_center = height / 2
+
+    ordered_states.each_with_index do |name, index|
+      if @states[name][:x].nil? || @states[name][:y].nil?
+        @states[name][:x] = margin + (index * spacing)
+        @states[name][:y] = y_center
+      end
+    end
+  end
+
+  def count_parallel_transitions(from, to)
+    count = 0
+    @transitions.each do |trans|
+      if (trans[:from] == from && trans[:to] == to) ||
+         (trans[:from] == to && trans[:to] == from)
+        count += 1
+      end
+    end
+    count
+  end
+
+  def get_transition_index(from, to, label)
+    index = 0
+    @transitions.each do |trans|
+      next unless (trans[:from] == from && trans[:to] == to) ||
+                  (trans[:from] == to && trans[:to] == from)
+      return index if trans[:from] == from && trans[:to] == to && trans[:label] == label
+
+      index += 1
+    end
+    index
+  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
+                      })
+
+      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
+
+    @states.each do |name, state|
+      circle_class = 'state-circle'
+      circle_class += ' final-state' if @final_states.include?(name)
+
+      svg.add_element('circle', {
+                        'class' => circle_class,
+                        'cx' => state[:x].to_s,
+                        'cy' => state[:y].to_s,
+                        'r' => '30'
+                      })
+
+      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
+
+      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
+
+    doc.to_s
+  end
+
+  def save_svg(filename, width = 800, height = 600)
+    File.write(filename, to_svg(width, height))
+  end
+end

data/sample/basic.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../lib/graphomaton'
+
+automaton = Graphomaton.new
+
+automaton.add_state('q0')
+automaton.add_state('q1')
+
+automaton.set_initial('q0')
+automaton.add_final('q0')
+
+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.save_svg('automaton.svg')
+puts 'Generated automaton.svg'

data/sample/complex.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../lib/graphomaton'
+
+
+complex = Graphomaton.new
+
+complex.add_state('A')
+complex.add_state('B')
+complex.add_state('C')
+
+complex.set_initial('A')
+complex.add_final('C')
+
+complex.add_transition('A', 'B', 'x')
+complex.add_transition('A', 'B', 'y')
+
+complex.add_transition('B', 'C', 'a')
+complex.add_transition('C', 'B', 'b')
+
+complex.add_transition('B', 'B', 'loop')
+
+complex.save_svg('complex_transitions.svg')
+puts 'Generated complex_transitions.svg'

data/sample/nfa.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../lib/graphomaton'
+
+nfa = Graphomaton.new
+
+nfa.add_state('q0')
+nfa.add_state('q1')
+nfa.add_state('q2')
+
+nfa.set_initial('q0')
+nfa.add_final('q2')
+
+nfa.add_transition('q0', 'q0', 'a,b')
+nfa.add_transition('q0', 'q1', 'a')
+nfa.add_transition('q1', 'q2', 'b')
+
+nfa.save_svg('nfa_example.svg', 600, 400)
+puts 'Generated nfa_example.svg'

data/spec/graphomaton_spec.rb

@@ -0,0 +1,371 @@
+# 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(2) # 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 >= 2
+      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(6)
+
+      # 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

@@ -0,0 +1,13 @@
+# 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

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: graphomaton
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A tiny Ruby library for generating finite state machine (automaton) diagrams
+  as SVG.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codespellignore"
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/graphomaton.rb
+- lib/graphomaton/version.rb
+- sample/basic.rb
+- sample/complex.rb
+- sample/nfa.rb
+- spec/graphomaton_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ydah/graphomaton
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/graphomaton
+  source_code_uri: https://github.com/ydah/graphomaton
+  changelog_uri: https://github.com/ydah/graphomaton/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.8.0.dev
+specification_version: 4
+summary: A tiny Ruby library for generating finite state machine (automaton) diagrams
+  as SVG.
+test_files: []