mmd2svg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f32fd990c261c1696e29f9a804f588ffdb36bcc5228c5b5c0d34501c3c1d1c26
+  data.tar.gz: f8420494972f1952b2524c46be923fdb6fd9697f6a41d79ab0d68f6f582b67d1
+SHA512:
+  metadata.gz: 0b9d96109ce33815b20097a96ba74075a4725a83e4115b08826d948874f36266782a9a140da36b9bef5e50d00edb7a196d1e0ac152c16545a5429f95d8f776d5
+  data.tar.gz: b66781a0bff7d71725d0514a56b99a216f7179b3a55633d8d707720f2bcfc4593a1b953b85481a051251769208e21183c9142bcf12390e270a9e5a587cd813d7

data/.rspec

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

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-10-29
+
+- Initial release

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,262 @@
+# mermaid2svg
+
+Convert Mermaid diagrams to SVG files using Puppeteer. Supports both CLI and programmatic usage with batch conversion capabilities.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mermaid2svg'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install mermaid2svg
+```
+
+## Usage
+
+### Command Line Interface
+
+#### Basic Usage
+
+```bash
+# Convert a single file
+mermaid2svg diagram.mmd -o output.svg
+
+# Convert with options
+mermaid2svg diagram.mmd -o output.svg --theme dark --background transparent
+
+# Batch conversion from directory
+mermaid2svg diagrams/ -o output/
+
+# Batch conversion with glob pattern
+mermaid2svg diagrams/*.mmd -o output/
+
+# Recursive directory conversion
+mermaid2svg diagrams/ -o output/ --recursive
+```
+
+#### CLI Options
+
+```
+Options:
+  -o, --output PATH          Output file or directory path (required)
+  -t, --theme THEME          Theme: default, dark, forest, neutral (default: default)
+  -b, --background COLOR     Background color: transparent, white, or #hexcode (default: white)
+  -w, --width WIDTH          Output width in pixels
+  -h, --height HEIGHT        Output height in pixels
+  -c, --config FILE          Config file path (default: .mermaid2svg.yml)
+  -r, --recursive            Process directories recursively
+  --timeout MILLISECONDS     Puppeteer timeout in ms (default: 30000)
+  --skip-errors              Continue processing even if errors occur
+  --version                  Show version
+  --help                     Show help message
+```
+
+### Ruby API
+
+#### Single File Conversion
+
+```ruby
+require 'mermaid2svg'
+
+# Render from code string
+mermaid_code = <<~MERMAID
+  graph TD
+    A[Start] --> B[Process]
+    B --> C[End]
+MERMAID
+
+Mermaid2svg.render(mermaid_code, output: 'diagram.svg')
+
+# Render from file
+Mermaid2svg.render('diagram.mmd', output: 'output.svg')
+
+# Get SVG as string
+svg_string = Mermaid2svg.render_to_string(mermaid_code)
+```
+
+#### Batch Conversion
+
+```ruby
+# Convert all .mmd files in a directory
+results = Mermaid2svg.render_batch('diagrams/', output_dir: 'output/')
+
+# With glob pattern
+results = Mermaid2svg.render_batch('diagrams/*.mmd', output_dir: 'output/')
+
+# Recursive conversion
+results = Mermaid2svg.render_batch(
+  'diagrams/',
+  output_dir: 'output/',
+  recursive: true
+)
+
+# Check results
+puts "Succeeded: #{results[:succeeded].count}"
+puts "Failed: #{results[:failed].count}"
+```
+
+#### With Options
+
+```ruby
+Mermaid2svg.render(
+  mermaid_code,
+  output: 'diagram.svg',
+  theme: 'dark',
+  background_color: 'transparent',
+  width: 800,
+  height: 600
+)
+```
+
+#### Global Configuration
+
+```ruby
+Mermaid2svg.configure do |config|
+  config.theme = 'dark'
+  config.background_color = 'transparent'
+  config.puppeteer_timeout = 60000
+end
+
+# Now all renders use these settings
+Mermaid2svg.render(code, output: 'diagram.svg')
+```
+
+### Configuration File
+
+Create a `.mermaid2svg.yml` file in your project root:
+
+```yaml
+# Theme setting
+theme: default  # default, dark, forest, neutral
+
+# Background color
+background_color: white  # transparent, white, or #hexcode
+
+# Output size (optional)
+# width: 800
+# height: 600
+
+# Puppeteer settings
+puppeteer:
+  headless: true
+  timeout: 30000
+  args:
+    - '--no-sandbox'
+    - '--disable-setuid-sandbox'
+
+# Mermaid.js settings
+mermaid:
+  securityLevel: 'loose'
+  startOnLoad: true
+  theme: default
+  logLevel: 'error'
+
+# Batch conversion settings
+batch:
+  recursive: false
+  overwrite: true
+  skip_errors: false
+```
+
+## Supported Mermaid Diagram Types
+
+This gem supports all diagram types that Mermaid.js supports:
+
+- Flowchart
+- Sequence Diagram
+- Class Diagram
+- State Diagram
+- Entity Relationship Diagram
+- User Journey
+- Gantt Chart
+- Pie Chart
+- Git Graph
+- And more...
+
+## Error Handling
+
+The gem provides custom exceptions for different error scenarios:
+
+```ruby
+begin
+  Mermaid2svg.render('invalid.mmd', output: 'out.svg')
+rescue Mermaid2svg::RenderError => e
+  puts "Render failed: #{e.message}"
+rescue Mermaid2svg::FileNotFoundError => e
+  puts "File not found: #{e.message}"
+rescue Mermaid2svg::PuppeteerError => e
+  puts "Puppeteer error: #{e.message}"
+rescue Mermaid2svg::ConfigError => e
+  puts "Configuration error: #{e.message}"
+end
+```
+
+## Examples
+
+### Example 1: Simple Flowchart
+
+```ruby
+code = <<~MERMAID
+  graph LR
+    A[Square Rect] --> B((Circle))
+    A --> C(Round Rect)
+    B --> D{Rhombus}
+    C --> D
+MERMAID
+
+Mermaid2svg.render(code, output: 'flowchart.svg')
+```
+
+### Example 2: Sequence Diagram with Dark Theme
+
+```ruby
+code = <<~MERMAID
+  sequenceDiagram
+    Alice->>John: Hello John, how are you?
+    John-->>Alice: Great!
+    Alice-)John: See you later!
+MERMAID
+
+Mermaid2svg.render(
+  code,
+  output: 'sequence.svg',
+  theme: 'dark',
+  background_color: 'transparent'
+)
+```
+
+### Example 3: Batch Convert Project Diagrams
+
+```ruby
+results = Mermaid2svg.render_batch(
+  'docs/diagrams/',
+  output_dir: 'public/images/',
+  recursive: true,
+  theme: 'forest'
+)
+
+results[:failed].each do |failure|
+  puts "Failed: #{failure[:file]} - #{failure[:error]}"
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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/examples/class.mmd

@@ -0,0 +1,21 @@
+classDiagram
+    Animal <|-- Duck
+    Animal <|-- Fish
+    Animal <|-- Zebra
+    Animal : +int age
+    Animal : +String gender
+    Animal: +isMammal()
+    Animal: +mate()
+    class Duck{
+        +String beakColor
+        +swim()
+        +quack()
+    }
+    class Fish{
+        -int sizeInFeet
+        -canEat()
+    }
+    class Zebra{
+        +bool is_wild
+        +run()
+    }

data/examples/demo.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/mmd2svg'
+
+puts '=== Mmd2svg Demo ==='
+puts ''
+
+# Example 1: Simple render to string
+puts '1. Rendering a simple diagram to string...'
+simple_diagram = <<~MERMAID
+  graph LR
+    A[Hello] --> B[World]
+MERMAID
+
+begin
+  svg = Mmd2svg.render_to_string(simple_diagram)
+  puts "✓ Successfully generated SVG (#{svg.length} characters)"
+rescue StandardError => e
+  puts "✗ Error: #{e.message}"
+end
+puts ''
+
+# Example 2: Render to file
+puts '2. Rendering to file...'
+begin
+  Mmd2svg.render(simple_diagram, output: 'demo_output.svg')
+  puts '✓ Saved to demo_output.svg'
+rescue StandardError => e
+  puts "✗ Error: #{e.message}"
+end
+puts ''
+
+# Example 3: Using configuration
+puts '3. Using custom configuration...'
+Mmd2svg.configure do |config|
+  config.theme = 'dark'
+  config.background_color = 'transparent'
+end
+
+complex_diagram = <<~MERMAID
+  sequenceDiagram
+    participant A as Alice
+    participant B as Bob
+    A->>B: Hello Bob!
+    B->>A: Hello Alice!
+MERMAID
+
+begin
+  Mmd2svg.render(complex_diagram, output: 'demo_dark.svg')
+  puts '✓ Saved dark theme diagram to demo_dark.svg'
+rescue StandardError => e
+  puts "✗ Error: #{e.message}"
+end
+puts ''
+
+# Example 4: Batch conversion
+puts '4. Batch conversion of examples...'
+begin
+  results = Mmd2svg.render_batch(
+    '../examples/',
+    output_dir: 'demo_batch_output/',
+    theme: 'forest'
+  )
+
+  puts '✓ Batch conversion completed:'
+  puts "  - Succeeded: #{results[:succeeded].count}"
+  puts "  - Failed: #{results[:failed].count}"
+
+  results[:succeeded].each do |result|
+    puts "    ✓ #{result[:input]} → #{result[:output]}"
+  end
+
+  results[:failed].each do |result|
+    puts "    ✗ #{result[:file]}: #{result[:error]}"
+  end
+rescue StandardError => e
+  puts "✗ Error: #{e.message}"
+end
+puts ''
+
+puts '=== Demo Complete ==='
+puts ''
+puts 'Check the generated files:'
+puts '  - demo_output.svg'
+puts '  - demo_dark.svg'
+puts '  - demo_batch_output/'

data/examples/flowchart.mmd

@@ -0,0 +1,6 @@
+graph TD
+    A[Start] --> B{Is it working?}
+    B -->|Yes| C[Great!]
+    B -->|No| D[Debug]
+    D --> A
+    C --> E[End]

data/examples/sequence.mmd

@@ -0,0 +1,11 @@
+sequenceDiagram
+    participant Alice
+    participant Bob
+    Alice->>John: Hello John, how are you?
+    loop Healthcheck
+        John->>John: Fight against hypochondria
+    end
+    Note right of John: Rational thoughts<br/>prevail!
+    John-->>Alice: Great!
+    John->>Bob: How about you?
+    Bob-->>John: Jolly good!

data/exe/mmd2svg

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/mmd2svg'
+require_relative '../lib/mmd2svg/cli'
+
+Mmd2svg::CLI.start(ARGV)

data/lib/mmd2svg/batch_renderer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Mmd2svg
+  class BatchRenderer
+    def initialize(config = Config.new)
+      @config = config
+      @renderer = Renderer.new(config)
+      @results = { succeeded: [], failed: [] }
+    end
+
+    def render_batch(input, output_dir:)
+      files = FileFinder.find_files(input, recursive: @config.recursive)
+      raise FileNotFoundError, "No Mermaid files found in: #{input}" if files.empty?
+
+      base_dir = File.directory?(input) ? input : nil
+      files.each do |file|
+        process_file(file, output_dir, base_dir)
+      end
+      @results
+    end
+
+    private
+
+    def process_file(input_file, output_dir, base_dir)
+      output_file = FileFinder.output_path(input_file, output_dir, base_dir)
+      FileUtils.mkdir_p(File.dirname(output_file))
+      if !@config.overwrite && File.exist?(output_file)
+        @results[:failed] << {
+          file: input_file,
+          error: "Output file already exists: #{output_file}"
+        }
+        return
+      end
+
+      mermaid_code = File.read(input_file)
+      @renderer.render(mermaid_code, output: output_file)
+      @results[:succeeded] << {
+        input: input_file,
+        output: output_file
+      }
+    rescue StandardError => e
+      @results[:failed] << {
+        file: input_file,
+        error: e.message
+      }
+      raise unless @config.skip_errors
+    end
+  end
+end

data/lib/mmd2svg/cli.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'fileutils'
+
+module Mmd2svg
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    class_option :config,
+                 type: :string,
+                 aliases: '-c',
+                 desc: 'Config file path (default: .mermaid2svg.yml)'
+
+    desc 'INPUT', 'Convert Mermaid diagram(s) to SVG'
+    option :output,
+           type: :string,
+           aliases: '-o',
+           desc: 'Output file or directory path (default: INPUT.svg)'
+    option :theme,
+           type: :string,
+           aliases: '-t',
+           desc: 'Theme: default, dark, forest, neutral'
+    option :background,
+           type: :string,
+           aliases: '-b',
+           desc: 'Background color (transparent, white, or hex)'
+    option :width,
+           type: :numeric,
+           aliases: '-w',
+           desc: 'Output width in pixels'
+    option :height,
+           type: :numeric,
+           aliases: '-h',
+           desc: 'Output height in pixels'
+    option :recursive,
+           type: :boolean,
+           aliases: '-r',
+           default: false,
+           desc: 'Process directories recursively'
+    option :timeout,
+           type: :numeric,
+           desc: 'Puppeteer timeout in milliseconds'
+    option :skip_errors,
+           type: :boolean,
+           default: false,
+           desc: 'Continue processing even if errors occur'
+
+    def convert(input)
+      config = load_config
+      apply_options_to_config(config)
+      output = determine_output(input)
+      if batch_conversion?(input, output)
+        perform_batch_conversion(input, output, config)
+      else
+        perform_single_conversion(input, output, config)
+      end
+    rescue Mermaid2svg::Error => e
+      error_exit(e.message)
+    rescue StandardError => e
+      error_exit("Unexpected error: #{e.message}")
+    end
+
+    desc 'version', 'Show version'
+    def version
+      puts "mermaid2svg version #{Mermaid2svg::VERSION}"
+    end
+
+    desc 'help [COMMAND]', 'Describe available commands or one specific command'
+    def help(command = nil)
+      if command.nil?
+        print_usage
+      else
+        super
+      end
+    end
+
+    default_task :convert
+
+    def self.start(given_args = ARGV, config = {})
+      if given_args.any? && !%w[convert version help].include?(given_args.first) && !given_args.first.start_with?('-')
+        given_args = ['convert'] + given_args
+      end
+      super(given_args, config)
+    end
+
+    private
+
+    def print_usage
+      puts "Usage: mermaid2svg INPUT [OPTIONS]"
+      puts ""
+      puts "Convert Mermaid diagram(s) to SVG"
+      puts ""
+      puts "Arguments:"
+      puts "  INPUT                          Input file, directory, or glob pattern"
+      puts ""
+      puts "Options:"
+      puts "  -o, --output=PATH              Output file or directory path (default: INPUT.svg)"
+      puts "  -t, --theme=THEME              Theme: default, dark, forest, neutral"
+      puts "  -b, --background=COLOR         Background color (transparent, white, or hex)"
+      puts "  -w, --width=WIDTH              Output width in pixels"
+      puts "  -h, --height=HEIGHT            Output height in pixels"
+      puts "  -r, --recursive                Process directories recursively"
+      puts "      --timeout=MILLISECONDS     Puppeteer timeout in milliseconds (default: 30000)"
+      puts "      --skip-errors              Continue processing even if errors occur"
+      puts "  -c, --config=FILE              Config file path (default: .mermaid2svg.yml)"
+      puts ""
+      puts "Commands:"
+      puts "  mermaid2svg version            Show version"
+      puts "  mermaid2svg help               Show this help message"
+      puts ""
+      puts "Examples:"
+      puts "  mermaid2svg diagram.mmd                          # Convert to diagram.svg"
+      puts "  mermaid2svg diagram.mmd -o output.svg            # Specify output file"
+      puts "  mermaid2svg diagram.mmd --theme dark             # Use dark theme"
+      puts "  mermaid2svg examples/ -o output/                 # Batch conversion"
+      puts "  mermaid2svg examples/ -o output/ --recursive     # Recursive batch conversion"
+    end
+
+    def determine_output(input)
+      return options[:output] if options[:output]
+
+      if File.file?(input)
+        input.sub(/\.(mmd|mermaid)$/i, '.svg')
+      else
+        'output'
+      end
+    end
+
+    def load_config
+      config_file = options[:config] || Config.find_config_file
+      if config_file && File.exist?(config_file)
+        puts "Loading config from: #{config_file}" if options[:verbose]
+        Config.load_from_file(config_file)
+      else
+        Config.new
+      end
+    end
+
+    def apply_options_to_config(config)
+      config.theme = options[:theme] if options[:theme]
+      config.background_color = options[:background] if options[:background]
+      config.width = options[:width] if options[:width]
+      config.height = options[:height] if options[:height]
+      config.puppeteer_timeout = options[:timeout] if options[:timeout]
+      config.recursive = options[:recursive]
+      config.skip_errors = options[:skip_errors]
+    end
+
+    def batch_conversion?(input, output)
+      File.directory?(input) || input.include?('*') || 
+        (File.exist?(input) && File.exist?(output) && File.directory?(output))
+    end
+
+    def perform_batch_conversion(input, output, config)
+      output_dir = output
+
+      puts "Processing files from: #{input}"
+      puts "Output directory: #{output_dir}"
+      puts ''
+
+      batch_renderer = BatchRenderer.new(config)
+      results = batch_renderer.render_batch(input, output_dir: output_dir)
+
+      display_batch_results(results)
+    end
+
+    def perform_single_conversion(input, output, config)
+      raise FileNotFoundError, "Input file not found: #{input}" unless File.exist?(input)
+
+      mermaid_code = File.read(input)
+      renderer = Renderer.new(config)
+      renderer.render(mermaid_code, output: output)
+      puts "✓ #{input} → #{output}"
+    end
+
+    def display_batch_results(results)
+      results[:succeeded].each do |result|
+        puts "✓ #{result[:input]} → #{result[:output]}"
+      end
+      results[:failed].each do |result|
+        puts "✗ #{result[:file]} → Error: #{result[:error]}"
+      end
+      puts ''
+      puts "#{results[:succeeded].count} succeeded, #{results[:failed].count} failed"
+      exit(1) if results[:failed].any? && !options[:skip_errors]
+    end
+
+    def error_exit(message)
+      warn "Error: #{message}"
+      exit(1)
+    end
+  end
+end

data/lib/mmd2svg/config.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Mmd2svg
+  class Config
+    DEFAULT_CONFIG = {
+      'theme' => 'default',
+      'background_color' => 'white',
+      'puppeteer' => {
+        'headless' => true,
+        'timeout' => 30_000,
+        'args' => ['--no-sandbox', '--disable-setuid-sandbox']
+      },
+      'mermaid' => {
+        'securityLevel' => 'loose',
+        'startOnLoad' => true,
+        'logLevel' => 'error'
+      },
+      'batch' => {
+        'recursive' => false,
+        'overwrite' => true,
+        'skip_errors' => false
+      }
+    }.freeze
+
+    attr_accessor :theme, :background_color, :width, :height,
+                  :puppeteer_timeout, :puppeteer_headless, :puppeteer_args,
+                  :mermaid_config, :recursive, :overwrite, :skip_errors
+
+    def initialize(config_hash = {})
+      merged_config = DEFAULT_CONFIG.merge(config_hash)
+
+      @theme = merged_config['theme']
+      @background_color = merged_config['background_color']
+      @width = merged_config['width']
+      @height = merged_config['height']
+
+      @puppeteer_headless = merged_config['puppeteer']['headless']
+      @puppeteer_timeout = merged_config['puppeteer']['timeout']
+      @puppeteer_args = merged_config['puppeteer']['args']
+
+      @mermaid_config = merged_config['mermaid']
+
+      @recursive = merged_config['batch']['recursive']
+      @overwrite = merged_config['batch']['overwrite']
+      @skip_errors = merged_config['batch']['skip_errors']
+    end
+
+    def self.load_from_file(file_path)
+      return new unless File.exist?(file_path)
+
+      config_hash = YAML.load_file(file_path)
+      new(config_hash)
+    rescue StandardError => e
+      raise ConfigError, "Failed to load config file: #{e.message}"
+    end
+
+    def self.find_config_file
+      current_dir = Dir.pwd
+      config_file = File.join(current_dir, '.mmd2svg.yml')
+
+      return config_file if File.exist?(config_file)
+
+      nil
+    end
+
+    def to_h
+      {
+        theme: @theme,
+        background_color: @background_color,
+        width: @width,
+        height: @height,
+        puppeteer_timeout: @puppeteer_timeout,
+        puppeteer_headless: @puppeteer_headless,
+        puppeteer_args: @puppeteer_args,
+        mermaid_config: @mermaid_config,
+        recursive: @recursive,
+        overwrite: @overwrite,
+        skip_errors: @skip_errors
+      }
+    end
+
+    def dup
+      Config.new(DEFAULT_CONFIG.merge(to_h.transform_keys(&:to_s)))
+    end
+  end
+end

data/lib/mmd2svg/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Mmd2svg
+  class Error < StandardError; end
+  class RenderError < Error; end
+  class ConfigError < Error; end
+  class FileNotFoundError < Error; end
+  class PuppeteerError < Error; end
+end

data/lib/mmd2svg/file_finder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mmd2svg
+  class FileFinder
+    MERMAID_EXTENSIONS = %w[.mmd .mermaid].freeze
+
+    def self.find_files(input, recursive: false)
+      if File.directory?(input)
+        find_in_directory(input, recursive)
+      elsif input.include?('*')
+        Dir.glob(input).select { |f| File.file?(f) && mermaid_file?(f) }
+      elsif File.file?(input)
+        mermaid_file?(input) ? [input] : []
+      else
+        raise FileNotFoundError, "Input not found: #{input}"
+      end
+    end
+
+    def self.find_in_directory(dir, recursive)
+      pattern = recursive ? File.join(dir, '**', '*') : File.join(dir, '*')
+      Dir.glob(pattern).select { |f| File.file?(f) && mermaid_file?(f) }
+    end
+
+    def self.mermaid_file?(path)
+      MERMAID_EXTENSIONS.include?(File.extname(path).downcase)
+    end
+
+    def self.output_path(input_path, output_dir, base_dir = nil)
+      relative_path =
+        if base_dir
+          input_path.sub(%r{^#{Regexp.escape(base_dir)}/}, '')
+        else
+          File.basename(input_path)
+        end
+
+      output_file = relative_path.sub(/\.(mmd|mermaid)$/i, '.svg')
+      File.join(output_dir, output_file)
+    end
+  end
+end

data/lib/mmd2svg/renderer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'puppeteer'
+require 'tempfile'
+
+module Mmd2svg
+  class Renderer
+    def initialize(config = Config.new)
+      @config = config
+    end
+
+    def render(mermaid_code, output: nil)
+      svg_content = render_to_string(mermaid_code)
+
+      if output
+        File.write(output, svg_content)
+        output
+      else
+        svg_content
+      end
+    rescue StandardError => e
+      raise RenderError, "Failed to render Mermaid diagram: #{e.message}"
+    end
+
+    def render_to_string(mermaid_code)
+      Puppeteer.launch(
+        headless: @config.puppeteer_headless,
+        args: @config.puppeteer_args
+      ) do |browser|
+        page = browser.new_page
+
+        html_content = build_html(mermaid_code)
+        temp_file = create_temp_html(html_content)
+
+        begin
+          page.goto("file://#{temp_file.path}", wait_until: 'networkidle0')
+          page.wait_for_function('() => window.mermaidReady === true', timeout: @config.puppeteer_timeout)
+          escaped_code = escape_js(mermaid_code)
+          svg_content = page.evaluate(<<~JS)
+            async () => {
+              const code = `#{escaped_code}`;
+              return await window.renderMermaid(code);
+            }
+          JS
+
+          apply_size(svg_content) if @config.width || @config.height
+
+          svg_content
+        ensure
+          temp_file.close
+          temp_file.unlink
+        end
+      end
+    rescue Puppeteer::TimeoutError
+      raise PuppeteerError, "Puppeteer timeout after #{@config.puppeteer_timeout}ms"
+    rescue StandardError => e
+      raise RenderError, "Failed to render: #{e.message}"
+    end
+
+    private
+
+    def build_html(_mermaid_code)
+      template = File.read(template_path)
+      template.gsub('%<theme>s', @config.theme)
+              .gsub('%<security_level>s', @config.mermaid_config['securityLevel'])
+              .gsub('%<log_level>s', @config.mermaid_config['logLevel'])
+              .gsub('%<background_color>s', @config.background_color)
+    end
+
+    def template_path
+      File.expand_path('../../templates/render.html', __dir__)
+    end
+
+    def create_temp_html(content)
+      temp = Tempfile.new(['mermaid', '.html'])
+      temp.write(content)
+      temp.flush
+      temp
+    end
+
+    def escape_js(str)
+      str.gsub('\\', '\\\\\\\\')
+         .gsub('`', '\\`')
+         .gsub('$', '\\$')
+         .gsub("\n", '\\n')
+         .gsub("\r", '\\r')
+    end
+
+    def apply_size(svg_content)
+      svg_content.sub!(/width="[^"]*"/, %(width="#{@config.width}")) if @config.width
+      svg_content.sub!(/height="[^"]*"/, %(height="#{@config.height}")) if @config.height
+      svg_content
+    end
+  end
+end

data/lib/mmd2svg/version.rb

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

data/lib/mmd2svg.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'mmd2svg/version'
+require_relative 'mmd2svg/errors'
+require_relative 'mmd2svg/config'
+require_relative 'mmd2svg/renderer'
+require_relative 'mmd2svg/file_finder'
+require_relative 'mmd2svg/batch_renderer'
+
+module Mmd2svg
+  class << self
+    attr_writer :config
+
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield(config) if block_given?
+    end
+
+    # Render a single Mermaid diagram
+    # @param code [String] Mermaid diagram code or file path
+    # @param output [String, nil] Output file path (optional)
+    # @param options [Hash] Rendering options
+    # @return [String] SVG content or output file path
+    def render(code, output: nil, **options)
+      local_config = build_config(options)
+      renderer = Renderer.new(local_config)
+
+      mermaid_code = File.exist?(code) ? File.read(code) : code
+      renderer.render(mermaid_code, output: output)
+    end
+
+    # Render Mermaid diagram to string
+    # @param code [String] Mermaid diagram code
+    # @param options [Hash] Rendering options
+    # @return [String] SVG content
+    def render_to_string(code, **options)
+      local_config = build_config(options)
+      renderer = Renderer.new(local_config)
+
+      renderer.render_to_string(code)
+    end
+
+    # Batch render multiple Mermaid files
+    # @param input [String] Input directory or glob pattern
+    # @param output_dir [String] Output directory
+    # @param options [Hash] Rendering options
+    # @return [Hash] Results with :succeeded and :failed arrays
+    def render_batch(input, output_dir:, **options)
+      local_config = build_config(options)
+      batch_renderer = BatchRenderer.new(local_config)
+
+      batch_renderer.render_batch(input, output_dir: output_dir)
+    end
+
+    private
+
+    def build_config(options)
+      local_config = config.dup
+
+      local_config.theme = options[:theme] if options[:theme]
+      local_config.background_color = options[:background_color] if options[:background_color]
+      local_config.width = options[:width] if options[:width]
+      local_config.height = options[:height] if options[:height]
+      local_config.puppeteer_timeout = options[:timeout] if options[:timeout]
+      local_config.recursive = options[:recursive] if options.key?(:recursive)
+      local_config.skip_errors = options[:skip_errors] if options.key?(:skip_errors)
+
+      local_config
+    end
+  end
+end

data/spec/mermaid2svg_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Mmd2svg do
+  it 'has a version number' do
+    expect(Mmd2svg::VERSION).not_to be nil
+  end
+
+  describe '.render_to_string' do
+    it 'renders a simple graph to SVG string' do
+      mermaid_code = <<~MERMAID
+        graph TD
+          A[Start] --> B[End]
+      MERMAID
+
+      svg = Mmd2svg.render_to_string(mermaid_code)
+
+      expect(svg).to be_a(String)
+      expect(svg).to include('<svg')
+      expect(svg).to include('</svg>')
+    end
+  end
+
+  describe '.configure' do
+    it 'allows configuration via block' do
+      Mmd2svg.configure do |config|
+        config.theme = 'dark'
+        config.background_color = 'transparent'
+      end
+
+      expect(Mmd2svg.config.theme).to eq('dark')
+      expect(Mmd2svg.config.background_color).to eq('transparent')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'mmd2svg'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/templates/render.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="UTF-8">
+  <script type="module">
+    import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs';
+
+    const config = {
+      startOnLoad: false,
+      theme: '%<theme>s',
+      securityLevel: '%<security_level>s',
+      logLevel: '%<log_level>s'
+    };
+
+    mermaid.initialize(config);
+
+    window.renderMermaid = async function (code) {
+      try {
+        const { svg } = await mermaid.render('mermaid-diagram', code);
+        return svg;
+      } catch (error) {
+        throw new Error('Mermaid rendering failed: ' + error.message);
+      }
+    };
+
+    window.mermaidReady = true;
+  </script>
+  <style>
+    body {
+      margin: 0;
+      padding: 20px;
+      background-color: %<background_color>s;
+    }
+    #container {
+      display: inline-block;
+    }
+  </style>
+</head>
+<body>
+  <div id="container"></div>
+</body>
+</html>

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: mmd2svg
+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:
+- !ruby/object:Gem::Dependency
+  name: puppeteer-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.45'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.45'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: A command-line tool and library to convert Mermaid diagram definitions
+  into SVG files.
+email:
+- t.yudai92@gmail.com
+executables:
+- mmd2svg
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/class.mmd
+- examples/demo.rb
+- examples/flowchart.mmd
+- examples/sequence.mmd
+- exe/mmd2svg
+- lib/mmd2svg.rb
+- lib/mmd2svg/batch_renderer.rb
+- lib/mmd2svg/cli.rb
+- lib/mmd2svg/config.rb
+- lib/mmd2svg/errors.rb
+- lib/mmd2svg/file_finder.rb
+- lib/mmd2svg/renderer.rb
+- lib/mmd2svg/version.rb
+- spec/mermaid2svg_spec.rb
+- spec/spec_helper.rb
+- templates/render.html
+homepage: https://github.com/ydah/mmd2svg
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/mmd2svg
+  source_code_uri: https://github.com/ydah/mmd2svg
+  changelog_uri: https://github.com/ydah/mmd2svg/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.7.2
+specification_version: 4
+summary: Convert Mermaid diagrams to SVG
+test_files: []