automograph 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2a137a5c9fb5e32a1229fbe58dd1eb0143cd1dbeec612c54962b0a28b98276d
+  data.tar.gz: 4182ed787561105dbeaefe75f2096c752ea3f2cc3a59d98b254462c0af7c1b1a
+SHA512:
+  metadata.gz: 3a0aa78d72ceb0e484d1dbc07240d55077528deace5f69f1132a0994db3208832c71808665f480c5907ef1d372f16044b0c7eb07b7586f5e33a3bba1624da9e8
+  data.tar.gz: 3f0fdf171417b00408dd3ce24d553f7fcc2be99b2115ce3f6a0b97b506949ebf89129f6c6072c3f27b9537a5da1f72c832c44c6f0bc79f752e8a332959f95837

data/README.md

@@ -0,0 +1,101 @@
+# Automograph
+
+A pure Ruby library for visualizing automata and state machines. Supports multiple output formats including Mermaid, GraphViz DOT, PlantUML, and interactive HTML.
+
+## Features
+
+- Runs as Pure Ruby code with no external dependencies.
+- Exports to multiple formats such as HTML, Mermaid, GraphViz DOT, and PlantUML.
+- Adopts a generic model to work with any automaton or state machine, not just Lrama.
+- Produces interactive HTML for browsing states with click-to-view details.
+- Remains customizable to let you control layout, styling, and filtering.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'automograph'
+```
+
+Or install it yourself as:
+
+```bash
+gem install automograph
+```
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'automograph'
+
+# Create a model
+model = Automograph::Model.new(name: "Simple DFA")
+model.add_state(0, label: "Start", initial: true)
+model.add_state(1, label: "Middle")
+model.add_state(2, label: "Accept", accept: true)
+model.add_transition(from: 0, to: 1, label: "a")
+model.add_transition(from: 1, to: 2, label: "b")
+model.initial_state_id = 0
+
+# Render to HTML
+html = Automograph.render(model, format: :html)
+File.write("diagram.html", html)
+
+# Or use render_to_file
+Automograph.render_to_file(model, "diagram.html")  # Auto-detects format from extension
+Automograph.render_to_file(model, "diagram.mmd")   # Mermaid
+Automograph.render_to_file(model, "diagram.dot")   # GraphViz
+Automograph.render_to_file(model, "diagram.puml")  # PlantUML
+```
+
+### From JSON
+
+```ruby
+json = {
+  name: "LALR(1) Automaton",
+  states: [
+    { id: 0, label: "State 0", initial: true, description: "$accept → • S $end" },
+    { id: 1, label: "State 1", description: "S → A • B" },
+    { id: 2, label: "State 2", accept: true, description: "S → A B •" }
+  ],
+  transitions: [
+    { from: 0, to: 1, label: "A", type: "shift" },
+    { from: 1, to: 2, label: "B", type: "shift" }
+  ]
+}
+
+model = Automograph::Model.from_hash(json)
+Automograph.render_to_file(model, "output.html")
+```
+
+### With Options
+
+```ruby
+Automograph.render(model,
+  format: :html,
+  direction: :TB,              # Top to Bottom (default: :LR)
+  show_description: true,      # Show state descriptions (default: true)
+  highlight_accept: true,      # Highlight accept states (default: true)
+  highlight_initial: true,     # Highlight initial state (default: true)
+  max_states: 50,              # Limit number of states displayed
+  title: "My Automaton"        # Custom title
+)
+```
+
+## Output Formats
+
+- HTML (Mermaid Embedded)
+- Mermaid
+- GraphViz DOT
+- PlantUML
+
+## License
+
+MIT License
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.

data/lib/automograph/formatter/base.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Automograph
+  module Formatter
+    # Registry for formatters
+    @formatters = {}
+
+    # Register a formatter
+    #
+    # @param name [Symbol] Formatter name
+    # @param klass [Class] Formatter class
+    def self.register(name, klass)
+      @formatters[name.to_sym] = klass
+    end
+
+    # Get a formatter by name
+    #
+    # @param name [Symbol] Formatter name
+    # @return [Class] Formatter class
+    # @raise [ArgumentError] If formatter not found
+    def self.for(name)
+      @formatters[name.to_sym] or raise ArgumentError, "Unknown format: #{name}. Available formats: #{@formatters.keys.join(', ')}"
+    end
+
+    # Base class for all formatters
+    class Base
+      attr_reader :model, :options
+
+      def initialize(model, **options)
+        @model = model
+        @options = Options.from_hash(options)
+      end
+
+      # Render the model to a string
+      #
+      # @return [String] Rendered output
+      # @raise [NotImplementedError] Must be implemented by subclasses
+      def render
+        raise NotImplementedError, "#{self.class}#render must be implemented"
+      end
+
+      protected
+
+      # Get filtered states based on options
+      #
+      # @return [Array<State>] Filtered states
+      def filtered_states
+        states = @model.states.values
+        states = states.select(&@options.state_filter) if @options.state_filter
+        states = states.first(@options.max_states) if @options.max_states
+        states
+      end
+
+      # Get filtered transitions based on filtered states
+      #
+      # @return [Array<Transition>] Filtered transitions
+      def filtered_transitions
+        state_ids = filtered_states.map(&:id)
+        @model.transitions.select { |t| state_ids.include?(t.from) && state_ids.include?(t.to) }
+      end
+
+      # Escape special characters in labels
+      #
+      # @param text [String] Text to escape
+      # @return [String] Escaped text
+      def escape_label(text)
+        text.to_s.gsub('"', '\\"').gsub("\n", "\\n")
+      end
+    end
+  end
+end

data/lib/automograph/formatter/graphviz.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Automograph
+  module Formatter
+    # GraphViz DOT formatter
+    class Graphviz < Base
+      def render
+        lines = []
+        lines << "digraph #{sanitize_id(@model.name)} {"
+        lines << "    rankdir=#{@options.direction};"
+        lines << "    node [shape=box, style=rounded];"
+        lines << ""
+
+        # Initial state marker
+        if @model.initial_state
+          lines << '    __start__ [shape=point, width=0.2];'
+          lines << "    __start__ -> State#{@model.initial_state_id};"
+          lines << ""
+        end
+
+        # State definitions
+        filtered_states.each do |state|
+          attrs = state_attributes(state)
+          lines << "    State#{state.id} [#{attrs}];"
+        end
+        lines << ""
+
+        # Transitions
+        filtered_transitions.each do |t|
+          style = transition_style(t)
+          lines << "    State#{t.from} -> State#{t.to} [label=\"#{escape_label(t.label)}\"#{style}];"
+        end
+
+        # Accept state markers
+        @model.accept_states.each do |state|
+          next unless filtered_states.include?(state)
+
+          lines << ""
+          lines << "    __accept_#{state.id}__ [shape=doublecircle, width=0.3, label=\"\"];"
+          lines << "    State#{state.id} -> __accept_#{state.id}__;"
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      private
+
+      def sanitize_id(name)
+        name.gsub(/[^a-zA-Z0-9_]/, '_')
+      end
+
+      def state_attributes(state)
+        attrs = []
+        label_parts = [state.label]
+        if @options.show_description && state.description
+          label_parts << "---"
+          label_parts << state.description
+        end
+        attrs << "label=\"#{escape_label(label_parts.join("\\n"))}\""
+
+        if state.accept? && @options.highlight_accept
+          attrs << "shape=doublebox"
+          attrs << "style=\"rounded,bold\""
+        end
+
+        if state.initial? && @options.highlight_initial
+          attrs << "penwidth=2"
+        end
+
+        attrs.join(", ")
+      end
+
+      def transition_style(t)
+        case t.type
+        when :goto then ", style=dashed"
+        when :reduce then ", style=dotted, color=gray"
+        else ""
+        end
+      end
+    end
+
+    register :graphviz, Graphviz
+    register :dot, Graphviz  # Alias
+  end
+end

data/lib/automograph/formatter/html.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Automograph
+  module Formatter
+    # HTML formatter with embedded Mermaid diagram
+    class Html < Base
+      TEMPLATE = <<~'HTML'
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><%= @model.name %></title>
+    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f5f5f5; }
+        .header { background: #2d3748; color: white; padding: 1rem 2rem; }
+        .header h1 { font-size: 1.25rem; font-weight: 500; }
+        .stats { font-size: 0.875rem; opacity: 0.8; margin-top: 0.5rem; }
+        .controls { background: white; padding: 0.75rem 2rem; border-bottom: 1px solid #e2e8f0; }
+        .controls label { margin-right: 1rem; font-size: 0.875rem; }
+        .diagram-container { padding: 2rem; overflow: auto; height: calc(100vh - 120px); }
+        .mermaid { background: white; padding: 2rem; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+        .side-panel {
+            position: fixed;
+            right: -400px;
+            top: 0;
+            width: 400px;
+            height: 100vh;
+            background: white;
+            box-shadow: -2px 0 10px rgba(0,0,0,0.1);
+            transition: right 0.3s;
+            z-index: 100;
+        }
+        .side-panel.open { right: 0; }
+        .panel-header {
+            padding: 1rem;
+            background: #2d3748;
+            color: white;
+            display: flex;
+            justify-content: space-between;
+        }
+        .panel-content {
+            padding: 1rem;
+            overflow-y: auto;
+            max-height: calc(100vh - 60px);
+        }
+        .panel-content pre {
+            background: #f7fafc;
+            padding: 1rem;
+            border-radius: 4px;
+            font-size: 0.875rem;
+            white-space: pre-wrap;
+        }
+        .close-btn {
+            background: none;
+            border: none;
+            color: white;
+            font-size: 1.5rem;
+            cursor: pointer;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1><%= @model.name %></h1>
+        <div class="stats">
+            States: <%= @model.states.size %> |
+            Transitions: <%= @model.transitions.size %> |
+            Accept States: <%= @model.accept_states.size %>
+        </div>
+    </div>
+    <div class="controls">
+        <label>
+            <input type="checkbox" id="showDesc" <%= @options.show_description ? 'checked' : '' %>>
+            Show Descriptions
+        </label>
+        <input type="text" placeholder="Search state..." id="search" style="padding: 0.25rem 0.5rem;">
+    </div>
+    <div class="diagram-container">
+        <pre class="mermaid">
+<%= mermaid_content %>
+        </pre>
+    </div>
+    <div class="side-panel" id="panel">
+        <div class="panel-header">
+            <span id="panelTitle">State Details</span>
+            <button class="close-btn" onclick="closePanel()">&times;</button>
+        </div>
+        <div class="panel-content">
+            <pre id="panelContent"></pre>
+        </div>
+    </div>
+    <script>
+        mermaid.initialize({ startOnLoad: true, theme: 'neutral', securityLevel: 'loose' });
+        const stateData = <%= state_data_json %>;
+        document.querySelector('.mermaid').addEventListener('click', e => {
+            const node = e.target.closest('.node');
+            if (node) {
+                const id = node.id.replace('state-', '').replace('State', '');
+                showState(id);
+            }
+        });
+        function showState(id) {
+            const state = stateData[id];
+            if (!state) return;
+            document.getElementById('panelTitle').textContent = state.label;
+            document.getElementById('panelContent').textContent = state.description || 'No description';
+            document.getElementById('panel').classList.add('open');
+        }
+        function closePanel() {
+            document.getElementById('panel').classList.remove('open');
+        }
+        document.getElementById('search').addEventListener('input', e => {
+            const q = e.target.value.toLowerCase();
+            document.querySelectorAll('.node').forEach(n => {
+                n.style.opacity = n.textContent.toLowerCase().includes(q) ? '1' : '0.3';
+            });
+        });
+    </script>
+</body>
+</html>
+      HTML
+
+      def render
+        ERB.new(TEMPLATE, trim_mode: '-').result(binding)
+      end
+
+      private
+
+      def mermaid_content
+        Mermaid.new(@model, **@options.to_h).render
+      end
+
+      def state_data_json
+        data = {}
+        @model.states.each do |id, state|
+          data[id] = { label: state.label, description: state.description }
+        end
+        JSON.generate(data)
+      end
+    end
+
+    register :html, Html
+  end
+end

data/lib/automograph/formatter/mermaid.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Automograph
+  module Formatter
+    # Mermaid state diagram formatter
+    class Mermaid < Base
+      def render
+        lines = []
+        lines << "stateDiagram-v2"
+        lines << "    direction #{@options.direction}"
+        lines << ""
+
+        # Initial state transition
+        if @model.initial_state
+          lines << "    [*] --> State#{@model.initial_state_id}"
+          lines << ""
+        end
+
+        # State definitions
+        filtered_states.each do |state|
+          lines << state_definition(state)
+          lines << note_definition(state) if @options.show_description && state.description
+          lines << ""
+        end
+
+        # Transitions
+        filtered_transitions.each do |t|
+          lines << "    State#{t.from} --> State#{t.to} : #{escape_label(t.label)}"
+        end
+
+        # Accept states to final
+        @model.accept_states.each do |state|
+          lines << "    State#{state.id} --> [*]" if filtered_states.include?(state)
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def state_definition(state)
+        suffix = state.accept? ? " ✓" : ""
+        "    State#{state.id}: #{state.label}#{suffix}"
+      end
+
+      def note_definition(state)
+        desc = state.description.gsub("\n", "\\n")
+        <<~NOTE.chomp
+              note right of State#{state.id}
+                  #{desc}
+              end note
+        NOTE
+      end
+    end
+
+    register :mermaid, Mermaid
+  end
+end

data/lib/automograph/formatter/plantuml.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Automograph
+  module Formatter
+    # PlantUML state diagram formatter
+    class Plantuml < Base
+      def render
+        lines = []
+        lines << "@startuml"
+        lines << "title #{@model.name}"
+        lines << "left to right direction" if @options.direction == :LR
+        lines << ""
+
+        # State definitions
+        filtered_states.each do |state|
+          lines << state_definition(state)
+        end
+        lines << ""
+
+        # Initial state
+        if @model.initial_state
+          lines << "[*] --> State#{@model.initial_state_id}"
+        end
+
+        # Transitions
+        filtered_transitions.each do |t|
+          arrow = transition_arrow(t)
+          lines << "State#{t.from} #{arrow} State#{t.to} : #{escape_label(t.label)}"
+        end
+
+        # Accept states
+        @model.accept_states.each do |state|
+          lines << "State#{state.id} --> [*]" if filtered_states.include?(state)
+        end
+
+        lines << ""
+        lines << "@enduml"
+        lines.join("\n")
+      end
+
+      private
+
+      def state_definition(state)
+        lines = []
+        lines << "state \"#{state.label}\" as State#{state.id}"
+
+        if @options.show_description && state.description
+          state.description.each_line do |line|
+            lines << "State#{state.id} : #{line.strip}"
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      def transition_arrow(t)
+        case t.type
+        when :goto then "-->"
+        when :reduce then "-[dotted]->"
+        else "-->"
+        end
+      end
+    end
+
+    register :plantuml, Plantuml
+    register :puml, Plantuml  # Alias
+  end
+end

data/lib/automograph/model.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Automograph
+  # Represents a generic automaton/state machine model
+  class Model
+    attr_reader :name, :states, :transitions, :metadata
+    attr_accessor :initial_state_id
+
+    def initialize(name: "Automaton")
+      @name = name
+      @states = {}          # id => State
+      @transitions = []     # Array<Transition>
+      @metadata = {}
+      @initial_state_id = nil
+    end
+
+    # Add a state to the model
+    #
+    # @param id [Integer] State identifier
+    # @param label [String] Display label for the state
+    # @param description [String, nil] Optional description (e.g., LR items)
+    # @param accept [Boolean] Whether this is an accepting state
+    # @param initial [Boolean] Whether this is the initial state
+    # @param metadata [Hash] Additional metadata
+    # @return [State] The created state
+    def add_state(id, label: nil, description: nil, accept: false, initial: false, metadata: {})
+      @states[id] = State.new(
+        id: id,
+        label: label,
+        description: description,
+        accept: accept,
+        initial: initial,
+        metadata: metadata
+      )
+    end
+
+    # Add a transition between states
+    #
+    # @param from [Integer] Source state ID
+    # @param to [Integer] Target state ID
+    # @param label [String] Transition label (e.g., symbol name)
+    # @param type [Symbol, nil] Transition type (:shift, :goto, :reduce, etc.)
+    # @param metadata [Hash] Additional metadata
+    # @return [Transition] The created transition
+    def add_transition(from:, to:, label:, type: nil, metadata: {})
+      transition = Transition.new(
+        from: from,
+        to: to,
+        label: label,
+        type: type,
+        metadata: metadata
+      )
+      @transitions << transition
+      transition
+    end
+
+    # Get the initial state
+    #
+    # @return [State, nil] The initial state
+    def initial_state
+      @states[@initial_state_id]
+    end
+
+    # Get all accepting states
+    #
+    # @return [Array<State>] Array of accepting states
+    def accept_states
+      @states.values.select(&:accept?)
+    end
+
+    # Create a model from a hash
+    #
+    # @param hash [Hash] Hash representation of the model
+    # @return [Model] The created model
+    def self.from_hash(hash)
+      model = new(name: hash[:name] || hash["name"] || "Automaton")
+
+      (hash[:states] || hash["states"] || []).each do |s|
+        id = s[:id] || s["id"]
+        model.add_state(
+          id,
+          label: s[:label] || s["label"],
+          description: s[:description] || s["description"],
+          accept: s[:accept] || s["accept"] || false,
+          initial: s[:initial] || s["initial"] || false,
+          metadata: s[:metadata] || s["metadata"] || {}
+        )
+        model.initial_state_id = id if s[:initial] || s["initial"]
+      end
+
+      (hash[:transitions] || hash["transitions"] || []).each do |t|
+        model.add_transition(
+          from: t[:from] || t["from"],
+          to: t[:to] || t["to"],
+          label: t[:label] || t["label"],
+          type: (t[:type] || t["type"])&.to_sym,
+          metadata: t[:metadata] || t["metadata"] || {}
+        )
+      end
+
+      model
+    end
+
+    # Create a model from JSON
+    #
+    # @param json_string [String] JSON representation
+    # @return [Model] The created model
+    def self.from_json(json_string)
+      from_hash(JSON.parse(json_string, symbolize_names: true))
+    end
+
+    # Convert the model to a hash
+    #
+    # @return [Hash] Hash representation
+    def to_hash
+      {
+        name: @name,
+        states: @states.values.map(&:to_hash),
+        transitions: @transitions.map(&:to_hash),
+        metadata: @metadata
+      }
+    end
+
+    # Convert the model to JSON
+    #
+    # @return [String] JSON representation
+    def to_json(*_args)
+      JSON.pretty_generate(to_hash)
+    end
+  end
+
+  # Represents a state in the automaton
+  class State
+    attr_reader :id, :label, :description, :metadata
+    attr_accessor :accept, :initial
+
+    def initialize(id:, label: nil, description: nil, accept: false, initial: false, metadata: {})
+      @id = id
+      @label = label || "State #{id}"
+      @description = description
+      @accept = accept
+      @initial = initial
+      @metadata = metadata || {}
+    end
+
+    # Check if this is an accepting state
+    #
+    # @return [Boolean]
+    def accept?
+      @accept
+    end
+
+    # Check if this is the initial state
+    #
+    # @return [Boolean]
+    def initial?
+      @initial
+    end
+
+    # Convert the state to a hash
+    #
+    # @return [Hash]
+    def to_hash
+      {
+        id: @id,
+        label: @label,
+        description: @description,
+        accept: @accept,
+        initial: @initial,
+        metadata: @metadata
+      }
+    end
+  end
+
+  # Represents a transition between states
+  class Transition
+    attr_reader :from, :to, :label, :type, :metadata
+
+    def initialize(from:, to:, label:, type: nil, metadata: {})
+      @from = from
+      @to = to
+      @label = label
+      @type = type  # :shift, :goto, :reduce, nil (generic)
+      @metadata = metadata || {}
+    end
+
+    # Convert the transition to a hash
+    #
+    # @return [Hash]
+    def to_hash
+      {
+        from: @from,
+        to: @to,
+        label: @label,
+        type: @type,
+        metadata: @metadata
+      }
+    end
+  end
+end

data/lib/automograph/options.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Automograph
+  # Options for diagram rendering
+  class Options
+    # Display options
+    attr_accessor :show_description    # Show state descriptions (e.g., LR items)
+    attr_accessor :show_metadata       # Show metadata
+    attr_accessor :highlight_accept    # Highlight accepting states
+    attr_accessor :highlight_initial   # Highlight initial state
+
+    # Layout
+    attr_accessor :direction           # :LR, :TB, :RL, :BT
+
+    # Filtering
+    attr_accessor :state_filter        # Proc to filter states
+    attr_accessor :max_states          # Maximum number of states to display
+
+    # Style
+    attr_accessor :theme               # :default, :dark, :minimal
+    attr_accessor :title               # Diagram title
+
+    def initialize
+      @show_description = true
+      @show_metadata = false
+      @highlight_accept = true
+      @highlight_initial = true
+      @direction = :LR
+      @theme = :default
+      @state_filter = nil
+      @max_states = nil
+      @title = nil
+    end
+
+    # Create options from a hash
+    #
+    # @param hash [Hash] Option values
+    # @return [Options] The created options
+    def self.from_hash(hash)
+      opts = new
+      hash.each do |k, v|
+        setter = "#{k}="
+        opts.send(setter, v) if opts.respond_to?(setter)
+      end
+      opts
+    end
+
+    # Convert options to a hash
+    #
+    # @return [Hash] Hash representation
+    def to_h
+      {
+        show_description: @show_description,
+        show_metadata: @show_metadata,
+        highlight_accept: @highlight_accept,
+        highlight_initial: @highlight_initial,
+        direction: @direction,
+        state_filter: @state_filter,
+        max_states: @max_states,
+        theme: @theme,
+        title: @title
+      }
+    end
+  end
+end

data/lib/automograph/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Automograph
+  VERSION = "0.1.0"
+end

data/lib/automograph.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "automograph/version"
+require_relative "automograph/model"
+require_relative "automograph/options"
+require_relative "automograph/formatter/base"
+require_relative "automograph/formatter/mermaid"
+require_relative "automograph/formatter/html"
+require_relative "automograph/formatter/graphviz"
+require_relative "automograph/formatter/plantuml"
+
+# Automograph is a generic automaton/state machine visualization library
+module Automograph
+  class Error < StandardError; end
+
+  # Render a model to a string
+  #
+  # @param model [Automograph::Model] The automaton model
+  # @param format [Symbol] Output format (:html, :mermaid, :graphviz, :plantuml)
+  # @param options [Hash] Rendering options
+  # @return [String] Rendered output
+  def self.render(model, format: :html, **options)
+    formatter = Formatter.for(format)
+    formatter.new(model, **options).render
+  end
+
+  # Render a model to a file
+  #
+  # @param model [Automograph::Model] The automaton model
+  # @param path [String] Output file path
+  # @param format [Symbol, nil] Output format (auto-detected from extension if nil)
+  # @param options [Hash] Rendering options
+  # @return [String] The output file path
+  def self.render_to_file(model, path, format: nil, **options)
+    format ||= detect_format(path)
+    output = render(model, format: format, **options)
+    File.write(path, output)
+    path
+  end
+
+  # Detect format from file extension
+  #
+  # @param path [String] File path
+  # @return [Symbol] Detected format
+  # @api private
+  def self.detect_format(path)
+    case File.extname(path).downcase
+    when ".html", ".htm" then :html
+    when ".dot", ".gv" then :graphviz
+    when ".puml", ".plantuml" then :plantuml
+    when ".mmd", ".mermaid" then :mermaid
+    else :html
+    end
+  end
+  private_class_method :detect_format
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: automograph
+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: Automograph is a generic automaton/state machine visualization library
+  that supports multiple output formats including Mermaid, GraphViz DOT, PlantUML,
+  and interactive HTML.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/automograph.rb
+- lib/automograph/formatter/base.rb
+- lib/automograph/formatter/graphviz.rb
+- lib/automograph/formatter/html.rb
+- lib/automograph/formatter/mermaid.rb
+- lib/automograph/formatter/plantuml.rb
+- lib/automograph/model.rb
+- lib/automograph/options.rb
+- lib/automograph/version.rb
+homepage: https://github.com/ydah/automograph
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/automograph
+  changelog_uri: https://github.com/ydah/automograph/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Pure Ruby library for visualizing automata and state machines
+test_files: []