├── cmd
    ├── testdata
    │   ├── ascii
    │   │   ├── single_node.txt
    │   │   ├── self_reference.txt
    │   │   ├── two_nodes_linked.txt
    │   │   ├── single_node_longer_name.txt
    │   │   ├── custom_padding.txt
    │   │   ├── subgraph_empty.txt
    │   │   ├── self_reference_with_edge.txt
    │   │   ├── three_nodes_single_line.txt
    │   │   ├── three_nodes.txt
    │   │   ├── ampersand_without_edge.txt
    │   │   ├── two_single_root_nodes.txt
    │   │   ├── subgraph_single_node.txt
    │   │   ├── two_nodes_longer_names.txt
    │   │   ├── back_reference_from_child.txt
    │   │   ├── flowchart_tb_simple.txt
    │   │   ├── ampersand_lhs.txt
    │   │   ├── ampersand_rhs.txt
    │   │   ├── subgraph_multiple_nodes.txt
    │   │   ├── two_root_nodes.txt
    │   │   ├── ampersand_lhs_and_rhs.txt
    │   │   ├── two_layer_single_graph.txt
    │   │   ├── graph_tb_direction.txt
    │   │   ├── subgraph_td_direction.txt
    │   │   ├── subgraph_two_separate.txt
    │   │   ├── preserve_order_of_definition.txt
    │   │   ├── subgraph_nested.txt
    │   │   ├── comments.txt
    │   │   ├── subgraph_node_outside_lr.txt
    │   │   ├── backlink_with_short_y_padding.txt
    │   │   ├── two_layer_single_graph_longer_names.txt
    │   │   ├── two_root_nodes_longer_names.txt
    │   │   ├── backlink_from_bottom.txt
    │   │   ├── backlink_from_top.txt
    │   │   ├── subgraph_mixed_nodes.txt
    │   │   ├── subgraph_three_separate.txt
    │   │   ├── subgraph_three_levels_nested.txt
    │   │   ├── subgraph_mixed_nodes_td.txt
    │   │   ├── subgraph_with_labels.txt
    │   │   ├── subgraph_complex_nested.txt
    │   │   ├── subgraph_multiple_edges.txt
    │   │   ├── subgraph_nested_with_external.txt
    │   │   ├── subgraph_td_multiple_paddingy.txt
    │   │   ├── subgraph_td_multiple.txt
    │   │   └── subgraph_complex_mixed.txt
    │   ├── extended-chars
    │   │   ├── single_node.txt
    │   │   ├── self_reference.txt
    │   │   ├── two_nodes_linked.txt
    │   │   ├── single_node_longer_name.txt
    │   │   ├── self_reference_with_edge.txt
    │   │   ├── three_nodes.txt
    │   │   ├── three_nodes_single_line.txt
    │   │   ├── ampersand_without_edge.txt
    │   │   ├── two_single_root_nodes.txt
    │   │   ├── two_nodes_longer_names.txt
    │   │   ├── back_reference_from_child.txt
    │   │   ├── ampersand_lhs.txt
    │   │   ├── ampersand_rhs.txt
    │   │   ├── ampersand_lhs_and_rhs.txt
    │   │   ├── two_root_nodes.txt
    │   │   ├── two_layer_single_graph.txt
    │   │   ├── preserve_order_of_definition.txt
    │   │   ├── comments.txt
    │   │   ├── two_layer_single_graph_longer_names.txt
    │   │   ├── two_root_nodes_longer_names.txt
    │   │   ├── backlink_from_top.txt
    │   │   └── backlink_from_bottom.txt
    │   ├── sequence-ascii
    │   │   ├── self_message.txt
    │   │   ├── dotted_arrows_only.txt
    │   │   ├── simple_two_participants.txt
    │   │   └── three_participants.txt
    │   └── sequence
    │   │   ├── single_message.txt
    │   │   ├── simple_two_participants.txt
    │   │   ├── dotted_arrows_only.txt
    │   │   ├── messages_without_labels.txt
    │   │   ├── self_message.txt
    │   │   ├── multiword_labels.txt
    │   │   ├── bidirectional_messages.txt
    │   │   ├── adjacent_participants_communication.txt
    │   │   ├── four_participants.txt
    │   │   ├── three_participants.txt
    │   │   └── long_participant_names.txt
    ├── math.go
    ├── render.go
    ├── sequence_example_test.go
    ├── diagram.go
    ├── root.go
    ├── mapping_node.go
    ├── graph_test.go
    ├── mapping_edge.go
    ├── web.go
    ├── direction.go
    ├── integration_test.go
    ├── arrow.go
    └── parse.go
├── docs
    └── colored_graph.png
├── main.go
├── .pre-commit-config.yaml
├── .gitignore
├── Dockerfile.test
├── internal
    ├── diagram
    │   ├── interface.go
    │   ├── utils.go
    │   ├── testutil
    │   │   └── testutil.go
    │   └── config.go
    └── sequence
    │   ├── example_test.go
    │   ├── charset.go
    │   ├── parser.go
    │   ├── renderer_test.go
    │   ├── renderer.go
    │   └── sequence_test.go
├── scripts
    ├── fix_test.sh
    └── release.sh
├── .dockerignore
├── .vscode
    └── launch.json
├── Dockerfile
├── .air.toml
├── .github
    ├── workflows
    │   ├── check-goreleaser.yaml
    │   ├── release.yaml
    │   └── test.yaml
    └── FUNDING.yml
├── PKGBUILD
├── .cursor
    └── rules
    │   └── tests.mdc
├── flake.nix
├── LICENSE
├── .goreleaser.yaml
├── Makefile
├── go.mod
├── flake.lock
├── static
    ├── script.js
    └── style.css
├── templates
    └── index.tmpl
└── go.sum


/cmd/testdata/ascii/single_node.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | A
3 | ---
4 | +---+
5 | |   |
6 | | A |
7 | |   |
8 | +---+
9 | 


--------------------------------------------------------------------------------
/docs/colored_graph.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlexanderGrooff/mermaid-ascii/HEAD/docs/colored_graph.png


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/single_node.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | A
3 | ---
4 | ┌───┐
5 | │   │
6 | │ A │
7 | │   │
8 | └───┘
9 | 


--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "github.com/AlexanderGrooff/mermaid-ascii/cmd"
4 | 
5 | func main() {
6 | 	cmd.Execute()
7 | }
8 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/self_reference.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> A
 3 | ---
 4 | +---+  
 5 | |   |  
 6 | | A |-+
 7 | |   | |
 8 | +---+ |
 9 |   ^   |
10 |   +---+
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_nodes_linked.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | A --> B
3 | ---
4 | +---+     +---+
5 | |   |     |   |
6 | | A |---->| B |
7 | |   |     |   |
8 | +---+     +---+
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/single_node_longer_name.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | LongerName
3 | ---
4 | +------------+
5 | |            |
6 | | LongerName |
7 | |            |
8 | +------------+
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/self_reference.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> A
 3 | ---
 4 | ┌───┐  
 5 | │   │  
 6 | │ A ├─┐
 7 | │   │ │
 8 | └───┘ │
 9 |   ▲   │
10 |   └───┘
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_nodes_linked.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | A --> B
3 | ---
4 | ┌───┐     ┌───┐
5 | │   │     │   │
6 | │ A ├────►│ B │
7 | │   │     │   │
8 | └───┘     └───┘
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/single_node_longer_name.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | LongerName
3 | ---
4 | ┌────────────┐
5 | │            │
6 | │ LongerName │
7 | │            │
8 | └────────────┘
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/custom_padding.txt:
--------------------------------------------------------------------------------
 1 | paddingX=2
 2 | paddingY=1
 3 | graph LR
 4 | A --> B
 5 | ---
 6 | +---+  +---+
 7 | |   |  |   |
 8 | | A |->| B |
 9 | |   |  |   |
10 | +---+  +---+
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_empty.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph one
 3 | end
 4 | A --> B
 5 | ---
 6 | +---+     +---+
 7 | |   |     |   |
 8 | | A |---->| B |
 9 | |   |     |   |
10 | +---+     +---+
11 | 


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
1 | repos:
2 | - repo: https://github.com/dnephin/pre-commit-golang
3 |   rev: v0.5.0
4 |   hooks:
5 |     - id: go-fmt
6 |     - id: no-go-testing
7 |     - id: golangci-lint
8 |     - id: go-unit-tests
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence-ascii/self_message.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     Alice->>Alice: Think
 3 | ---
 4 | +-------+
 5 | | Alice |
 6 | +---+---+
 7 |     |
 8 |     | Think
 9 |     +--+
10 |     |  |
11 |     |<-+
12 |     |
13 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/self_reference_with_edge.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> A & B
 3 | ---
 4 | +---+     +---+
 5 | |   |     |   |
 6 | | A |--+->| B |
 7 | |   |  |  |   |
 8 | +---+  |  +---+
 9 |   ^    |       
10 |   +----+       
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/three_nodes_single_line.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | A --> B --> C
3 | ---
4 | +---+     +---+     +---+
5 | |   |     |   |     |   |
6 | | A |---->| B |---->| C |
7 | |   |     |   |     |   |
8 | +---+     +---+     +---+
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/three_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | B --> C
 4 | ---
 5 | +---+     +---+     +---+
 6 | |   |     |   |     |   |
 7 | | A |---->| B |---->| C |
 8 | |   |     |   |     |   |
 9 | +---+     +---+     +---+
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Dev artifacts
 2 | .direnv
 3 | *.mermaid
 4 | /tmp
 5 | .playwright-mcp
 6 | 
 7 | # Editor
 8 | .idea
 9 | *.patch
10 | 
11 | # Build artifacts
12 | build
13 | dist/
14 | mermaid-ascii
15 | *.tar.gz
16 | *.tar.zst
17 | result
18 | 


--------------------------------------------------------------------------------
/Dockerfile.test:
--------------------------------------------------------------------------------
 1 | FROM golang:1.25-alpine AS test
 2 | WORKDIR /app
 3 | RUN apk add --no-cache git
 4 | COPY go.mod go.sum ./
 5 | RUN go mod download
 6 | COPY . .
 7 | RUN go test ./... -v
 8 | CMD ["echo", "Tests passed!"]
 9 | 
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/ampersand_without_edge.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A & B
 3 | ---
 4 | +---+
 5 | |   |
 6 | | A |
 7 | |   |
 8 | +---+
 9 |      
10 |      
11 |      
12 |      
13 |      
14 | +---+
15 | |   |
16 | | B |
17 | |   |
18 | +---+
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_single_root_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A
 3 | B
 4 | ---
 5 | +---+
 6 | |   |
 7 | | A |
 8 | |   |
 9 | +---+
10 |      
11 |      
12 |      
13 |      
14 |      
15 | +---+
16 | |   |
17 | | B |
18 | |   |
19 | +---+
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/self_reference_with_edge.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> A & B
 3 | ---
 4 | ┌───┐     ┌───┐
 5 | │   │     │   │
 6 | │ A ├──┬─►│ B │
 7 | │   │  │  │   │
 8 | └───┘  │  └───┘
 9 |   ▲    │       
10 |   └────┘       
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/three_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | B --> C
 4 | ---
 5 | ┌───┐     ┌───┐     ┌───┐
 6 | │   │     │   │     │   │
 7 | │ A ├────►│ B ├────►│ C │
 8 | │   │     │   │     │   │
 9 | └───┘     └───┘     └───┘
10 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/three_nodes_single_line.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | A --> B --> C
3 | ---
4 | ┌───┐     ┌───┐     ┌───┐
5 | │   │     │   │     │   │
6 | │ A ├────►│ B ├────►│ C │
7 | │   │     │   │     │   │
8 | └───┘     └───┘     └───┘
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/ampersand_without_edge.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A & B
 3 | ---
 4 | ┌───┐
 5 | │   │
 6 | │ A │
 7 | │   │
 8 | └───┘
 9 |      
10 |      
11 |      
12 |      
13 |      
14 | ┌───┐
15 | │   │
16 | │ B │
17 | │   │
18 | └───┘
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_single_root_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A
 3 | B
 4 | ---
 5 | ┌───┐
 6 | │   │
 7 | │ A │
 8 | │   │
 9 | └───┘
10 |      
11 |      
12 |      
13 |      
14 |      
15 | ┌───┐
16 | │   │
17 | │ B │
18 | │   │
19 | └───┘
20 | 


--------------------------------------------------------------------------------
/internal/diagram/interface.go:
--------------------------------------------------------------------------------
1 | package diagram
2 | 
3 | // Diagram is the interface for all diagram types (graph, sequence, etc.)
4 | type Diagram interface {
5 | 	Parse(input string) error
6 | 	Render(config *Config) (string, error)
7 | 	Type() string
8 | }
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_single_node.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph one
 3 |     A
 4 | end
 5 | ---
 6 | +-------+
 7 | |  one  |
 8 | |       |
 9 | |       |
10 | | +---+ |
11 | | |   | |
12 | | | A | |
13 | | |   | |
14 | | +---+ |
15 | |       |
16 | +-------+
17 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/single_message.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     A->>B: Message
 5 | ---
 6 | ┌───┐     ┌───┐
 7 | │ A │     │ B │
 8 | └─┬─┘     └─┬─┘
 9 |   │         │
10 |   │ Message │
11 |   ├────────►│
12 |   │         │
13 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/simple_two_participants.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     A->>B: Hello
 5 | ---
 6 | ┌───┐     ┌───┐
 7 | │ A │     │ B │
 8 | └─┬─┘     └─┬─┘
 9 |   │         │
10 |   │ Hello   │
11 |   ├────────►│
12 |   │         │
13 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence-ascii/dotted_arrows_only.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     Alice-->>Bob: Response
 3 | ---
 4 | +-------+     +-----+
 5 | | Alice |     | Bob |
 6 | +---+---+     +--+--+
 7 |     |            |
 8 |     | Response   |
 9 |     +...........>|
10 |     |            |
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence-ascii/simple_two_participants.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     A->>B: Hello
 5 | ---
 6 | +---+     +---+
 7 | | A |     | B |
 8 | +-+-+     +-+-+
 9 |   |         |
10 |   | Hello   |
11 |   +-------->|
12 |   |         |
13 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/dotted_arrows_only.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     A-->>B: Return value
 5 | ---
 6 | ┌───┐     ┌───┐
 7 | │ A │     │ B │
 8 | └─┬─┘     └─┬─┘
 9 |   │         │
10 |   │ Return value
11 |   ├┈┈┈┈┈┈┈┈►│
12 |   │         │
13 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_nodes_longer_names.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | LongerName1 --> LongerName2
3 | ---
4 | +-------------+     +-------------+
5 | |             |     |             |
6 | | LongerName1 |---->| LongerName2 |
7 | |             |     |             |
8 | +-------------+     +-------------+
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_nodes_longer_names.txt:
--------------------------------------------------------------------------------
1 | graph LR
2 | LongerName1 --> LongerName2
3 | ---
4 | ┌─────────────┐     ┌─────────────┐
5 | │             │     │             │
6 | │ LongerName1 ├────►│ LongerName2 │
7 | │             │     │             │
8 | └─────────────┘     └─────────────┘
9 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/back_reference_from_child.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B --> C --> A
 3 | ---
 4 | +---+     +---+     +---+
 5 | |   |     |   |     |   |
 6 | | A |---->| B |---->| C |
 7 | |   |     |   |     |   |
 8 | +---+     +---+     +---+
 9 |   ^                   |  
10 |   +-------------------+  
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/messages_without_labels.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     A->>B:
 5 |     B-->>A:
 6 | ---
 7 | ┌───┐     ┌───┐
 8 | │ A │     │ B │
 9 | └─┬─┘     └─┬─┘
10 |   │         │
11 |   ├────────►│
12 |   │         │
13 |   │◄┈┈┈┈┈┈┈┈┤
14 |   │         │
15 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/back_reference_from_child.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B --> C --> A
 3 | ---
 4 | ┌───┐     ┌───┐     ┌───┐
 5 | │   │     │   │     │   │
 6 | │ A ├────►│ B ├────►│ C │
 7 | │   │     │   │     │   │
 8 | └───┘     └───┘     └─┬─┘
 9 |   ▲                   │  
10 |   └───────────────────┘  
11 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/flowchart_tb_simple.txt:
--------------------------------------------------------------------------------
 1 | flowchart TB
 2 |     A --> B
 3 |     B --> C
 4 | ---
 5 | +---+
 6 | |   |
 7 | | A |
 8 | |   |
 9 | +---+
10 |   |  
11 |   |  
12 |   |  
13 |   |  
14 |   v  
15 | +---+
16 | |   |
17 | | B |
18 | |   |
19 | +---+
20 |   |  
21 |   |  
22 |   |  
23 |   |  
24 |   v  
25 | +---+
26 | |   |
27 | | C |
28 | |   |
29 | +---+
30 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/ampersand_lhs.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B & C
 3 | ---
 4 | +---+     +---+
 5 | |   |     |   |
 6 | | A |---->| B |
 7 | |   |     |   |
 8 | +---+     +---+
 9 |   |            
10 |   |            
11 |   |            
12 |   |            
13 |   |            
14 |   |       +---+
15 |   |       |   |
16 |   +------>| C |
17 |           |   |
18 |           +---+
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/ampersand_rhs.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A & B --> C
 3 | ---
 4 | +---+     +---+
 5 | |   |     |   |
 6 | | A |---->| C |
 7 | |   |     |   |
 8 | +---+     +---+
 9 |             ^  
10 |             |  
11 |             |  
12 |             |  
13 |             |  
14 | +---+       |  
15 | |   |       |  
16 | | B |-------+  
17 | |   |          
18 | +---+          
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_multiple_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph one
 3 |     A --> B
 4 | end
 5 | ---
 6 | +-----------------+
 7 | |       one       |
 8 | |                 |
 9 | |                 |
10 | | +---+     +---+ |
11 | | |   |     |   | |
12 | | | A |---->| B | |
13 | | |   |     |   | |
14 | | +---+     +---+ |
15 | |                 |
16 | +-----------------+
17 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_root_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | C --> D
 4 | ---
 5 | +---+     +---+
 6 | |   |     |   |
 7 | | A |---->| B |
 8 | |   |     |   |
 9 | +---+     +---+
10 |                
11 |                
12 |                
13 |                
14 |                
15 | +---+     +---+
16 | |   |     |   |
17 | | C |---->| D |
18 | |   |     |   |
19 | +---+     +---+
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/ampersand_lhs.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B & C
 3 | ---
 4 | ┌───┐     ┌───┐
 5 | │   │     │   │
 6 | │ A ├────►│ B │
 7 | │   │     │   │
 8 | └─┬─┘     └───┘
 9 |   │            
10 |   │            
11 |   │            
12 |   │            
13 |   │            
14 |   │       ┌───┐
15 |   │       │   │
16 |   └──────►│ C │
17 |           │   │
18 |           └───┘
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/ampersand_rhs.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A & B --> C
 3 | ---
 4 | ┌───┐     ┌───┐
 5 | │   │     │   │
 6 | │ A ├────►│ C │
 7 | │   │     │   │
 8 | └───┘     └───┘
 9 |             ▲  
10 |             │  
11 |             │  
12 |             │  
13 |             │  
14 | ┌───┐       │  
15 | │   │       │  
16 | │ B ├───────┘  
17 | │   │          
18 | └───┘          
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/ampersand_lhs_and_rhs.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A & B --> C & D
 3 | ---
 4 | +---+     +---+
 5 | |   |     |   |
 6 | | A |--+->| C |
 7 | |   |  |  |   |
 8 | +---+  |  +---+
 9 |   |    |       
10 |   |    |       
11 |   +----+       
12 |   |    |       
13 |   |    |       
14 | +---+  |  +---+
15 | |   |  |  |   |
16 | | B |--+->| D |
17 | |   |     |   |
18 | +---+     +---+
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/self_message.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     A->>A: Self call
 5 |     A->>B: Then to B
 6 | ---
 7 | ┌───┐     ┌───┐
 8 | │ A │     │ B │
 9 | └─┬─┘     └─┬─┘
10 |   │         │
11 |   │ Self call      
12 |   ├──┐      │
13 |   │  │      │
14 |   │◄─┘      │
15 |   │         │
16 |   │ Then to B
17 |   ├────────►│
18 |   │         │
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_layer_single_graph.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | A --> C
 4 | ---
 5 | +---+     +---+
 6 | |   |     |   |
 7 | | A |---->| B |
 8 | |   |     |   |
 9 | +---+     +---+
10 |   |            
11 |   |            
12 |   |            
13 |   |            
14 |   |            
15 |   |       +---+
16 |   |       |   |
17 |   +------>| C |
18 |           |   |
19 |           +---+
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/ampersand_lhs_and_rhs.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A & B --> C & D
 3 | ---
 4 | ┌───┐     ┌───┐
 5 | │   │     │   │
 6 | │ A ├──┬─►│ C │
 7 | │   │  │  │   │
 8 | └─┬─┘  │  └───┘
 9 |   │    │       
10 |   │    │       
11 |   ├────┤       
12 |   │    │       
13 |   │    │       
14 | ┌─┴─┐  │  ┌───┐
15 | │   │  │  │   │
16 | │ B ├──┴─►│ D │
17 | │   │     │   │
18 | └───┘     └───┘
19 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_root_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | C --> D
 4 | ---
 5 | ┌───┐     ┌───┐
 6 | │   │     │   │
 7 | │ A ├────►│ B │
 8 | │   │     │   │
 9 | └───┘     └───┘
10 |                
11 |                
12 |                
13 |                
14 |                
15 | ┌───┐     ┌───┐
16 | │   │     │   │
17 | │ C ├────►│ D │
18 | │   │     │   │
19 | └───┘     └───┘
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_layer_single_graph.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | A --> C
 4 | ---
 5 | ┌───┐     ┌───┐
 6 | │   │     │   │
 7 | │ A ├────►│ B │
 8 | │   │     │   │
 9 | └─┬─┘     └───┘
10 |   │            
11 |   │            
12 |   │            
13 |   │            
14 |   │            
15 |   │       ┌───┐
16 |   │       │   │
17 |   └──────►│ C │
18 |           │   │
19 |           └───┘
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/graph_tb_direction.txt:
--------------------------------------------------------------------------------
 1 | graph TB
 2 | subgraph one
 3 |     A --> B
 4 | end
 5 | ---
 6 | +-------+
 7 | |  one  |
 8 | |       |
 9 | |       |
10 | | +---+ |
11 | | |   | |
12 | | | A | |
13 | | |   | |
14 | | +---+ |
15 | |   |   |
16 | |   |   |
17 | |   |   |
18 | |   |   |
19 | |   v   |
20 | | +---+ |
21 | | |   | |
22 | | | B | |
23 | | |   | |
24 | | +---+ |
25 | |       |
26 | +-------+
27 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_td_direction.txt:
--------------------------------------------------------------------------------
 1 | graph TD
 2 | subgraph one
 3 |     A --> B
 4 | end
 5 | ---
 6 | +-------+
 7 | |  one  |
 8 | |       |
 9 | |       |
10 | | +---+ |
11 | | |   | |
12 | | | A | |
13 | | |   | |
14 | | +---+ |
15 | |   |   |
16 | |   |   |
17 | |   |   |
18 | |   |   |
19 | |   v   |
20 | | +---+ |
21 | | |   | |
22 | | | B | |
23 | | |   | |
24 | | +---+ |
25 | |       |
26 | +-------+
27 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_two_separate.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph one
 3 |     A
 4 | end
 5 | subgraph two
 6 |     B
 7 | end
 8 | A --> B
 9 | ---
10 | +-------+ +-------+
11 | |  one  | |  two  |
12 | |       | |       |
13 | |       | |       |
14 | | +---+ | | +---+ |
15 | | |   | | | |   | |
16 | | | A |---->| B | |
17 | | |   | | | |   | |
18 | | +---+ | | +---+ |
19 | |       | |       |
20 | +-------+ +-------+
21 | 


--------------------------------------------------------------------------------
/cmd/math.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | func Min(x, y int) int {
 4 | 	if x < y {
 5 | 		return x
 6 | 	}
 7 | 	return y
 8 | }
 9 | 
10 | func Max(x, y int) int {
11 | 	if x > y {
12 | 		return x
13 | 	}
14 | 	return y
15 | }
16 | 
17 | func Abs(x int) int {
18 | 	if x < 0 {
19 | 		return -x
20 | 	}
21 | 	return x
22 | }
23 | 
24 | func CeilDiv(x, y int) int {
25 | 	if x%y == 0 {
26 | 		return x / y
27 | 	}
28 | 	return x/y + 1
29 | }
30 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/preserve_order_of_definition.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A
 3 | B
 4 | B --> A
 5 | A --> A
 6 | B --> C
 7 | C --> A
 8 | ---
 9 | +---+     +---+
10 | |   |     |   |
11 | | A |<-+--| C |
12 | |   |  |  |   |
13 | +---+  |  +---+
14 |   ^    |    ^  
15 |   |    |    |  
16 |   +----+    |  
17 |   |         |  
18 |   |         |  
19 | +---+       |  
20 | |   |       |  
21 | | B |-------+  
22 | |   |          
23 | +---+          
24 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_nested.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph outer
 3 |     subgraph inner
 4 |         A
 5 |     end
 6 | end
 7 | ---
 8 | +-----------+
 9 | |   outer   |
10 | |           |
11 | |           |
12 | | +-------+ |
13 | | | inner | |
14 | | |       | |
15 | | |       | |
16 | | | +---+ | |
17 | | | |   | | |
18 | | | | A | | |
19 | | | |   | | |
20 | | | +---+ | |
21 | | |       | |
22 | | +-------+ |
23 | |           |
24 | +-----------+
25 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/preserve_order_of_definition.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A
 3 | B
 4 | B --> A
 5 | A --> A
 6 | B --> C
 7 | C --> A
 8 | ---
 9 | ┌───┐     ┌───┐
10 | │   │     │   │
11 | │ A ├◄─┬──┤ C │
12 | │   │  │  │   │
13 | └───┘  │  └───┘
14 |   ▲    │    ▲  
15 |   │    │    │  
16 |   ├────┘    │  
17 |   │         │  
18 |   │         │  
19 | ┌─┴─┐       │  
20 | │   │       │  
21 | │ B ├───────┘  
22 | │   │          
23 | └───┘          
24 | 


--------------------------------------------------------------------------------
/scripts/fix_test.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | set -e
 4 | FILE=$1
 5 | 
 6 | if [ -z "$FILE" ]; then
 7 |     echo "Usage: $0 <file>"
 8 |     exit 1
 9 | fi
10 | 
11 | echo "Fixing $FILE"
12 | 
13 | GRAPH=$(cat $FILE | sed -n -e "/graph/,/---/ p" | head -n-1)
14 | 
15 | if [ -z "$GRAPH" ]; then
16 |     echo "No graph found in $FILE"
17 |     exit 1
18 | fi
19 | 
20 | echo "$GRAPH" > $FILE
21 | echo "---" >> $FILE
22 | echo "$GRAPH" | go run main.go ${@:2} >> $FILE
23 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/comments.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | %% This is a comment
 3 | A --> B
 4 | %% Another comment
 5 | B --> C
 6 | A --> C
 7 | %% Final comment
 8 | ---
 9 | +---+     +---+
10 | |   |     |   |
11 | | A |---->| B |
12 | |   |     |   |
13 | +---+     +---+
14 |   |         |  
15 |   |         |  
16 |   |         |  
17 |   |         |  
18 |   |         v  
19 |   |       +---+
20 |   |       |   |
21 |   +------>| C |
22 |           |   |
23 |           +---+


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
 1 | # Git
 2 | .git
 3 | .gitignore
 4 | 
 5 | # Build artifacts
 6 | mermaid-ascii
 7 | build/
 8 | *.tar.gz
 9 | 
10 | # Documentation
11 | README.md
12 | LICENSE
13 | docs/
14 | *.md
15 | 
16 | # Development files
17 | .vscode/
18 | .idea/
19 | *.swp
20 | *.swo
21 | *~
22 | 
23 | # Nix files
24 | flake.nix
25 | flake.lock
26 | 
27 | # Other package files
28 | PKGBUILD
29 | scripts/
30 | 
31 | # Test artifacts
32 | *.test
33 | coverage.out
34 | 
35 | 
36 | 
37 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_node_outside_lr.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | X
 3 | subgraph one
 4 |     A --> B
 5 | end
 6 | ---
 7 |         +-----------------+
 8 |         |       one       |
 9 |         |                 |
10 |         |                 |
11 | +---+   | +---+     +---+ |
12 | |   |   | |   |     |   | |
13 | | X |   | | A |---->| B | |
14 | |   |   | |   |     |   | |
15 | +---+   | +---+     +---+ |
16 |         |                 |
17 |         +-----------------+


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/comments.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | %% This is a comment
 3 | A --> B
 4 | %% Another comment
 5 | B --> C
 6 | A --> C
 7 | %% Final comment
 8 | ---
 9 | ┌───┐     ┌───┐
10 | │   │     │   │
11 | │ A ├────►│ B │
12 | │   │     │   │
13 | └─┬─┘     └─┬─┘
14 |   │         │  
15 |   │         │  
16 |   │         │  
17 |   │         │  
18 |   │         ▼  
19 |   │       ┌───┐
20 |   │       │   │
21 |   └──────►│ C │
22 |           │   │
23 |           └───┘


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Use IntelliSense to learn about possible attributes.
 3 |     // Hover to view descriptions of existing attributes.
 4 |     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         {
 8 |             "name": "Launch Package",
 9 |             "type": "go",
10 |             "request": "launch",
11 |             "mode": "auto",
12 |             "program": "main.go"
13 |         }
14 |     ]
15 | }


--------------------------------------------------------------------------------
/cmd/testdata/sequence/multiword_labels.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant User
 3 |     participant System
 4 |     User->>System: This is a very long message with multiple words
 5 |     System-->>User: Short reply
 6 | ---
 7 | ┌──────┐     ┌────────┐
 8 | │ User │     │ System │
 9 | └───┬──┘     └────┬───┘
10 |     │             │
11 |     │ This is a very long message with multiple words
12 |     ├────────────►│
13 |     │             │
14 |     │ Short reply │
15 |     │◄┈┈┈┈┈┈┈┈┈┈┈┈┤
16 |     │             │
17 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/backlink_with_short_y_padding.txt:
--------------------------------------------------------------------------------
 1 | paddingX=5
 2 | paddingY=3
 3 | graph LR
 4 | A --> B & C
 5 | B --> C & D
 6 | D --> C
 7 | ---
 8 | +---+     +---+     +---+
 9 | |   |     |   |     |   |
10 | | A |---->| B |--+->| D |
11 | |   |     |   |  |  |   |
12 | +---+     +---+  |  +---+
13 |   |         |    |       
14 |   |         +----+       
15 |   |         v            
16 |   |       +---+          
17 |   |       |   |          
18 |   +------>| C |          
19 |           |   |          
20 |           +---+          


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_layer_single_graph_longer_names.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | ABC --> BCDEFG
 3 | ABC --> CDEFGHI
 4 | ---
 5 | +-----+     +---------+
 6 | |     |     |         |
 7 | | ABC |---->|  BCDEFG |
 8 | |     |     |         |
 9 | +-----+     +---------+
10 |    |                   
11 |    |                   
12 |    |                   
13 |    |                   
14 |    |                   
15 |    |        +---------+
16 |    |        |         |
17 |    +------->| CDEFGHI |
18 |             |         |
19 |             +---------+
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_layer_single_graph_longer_names.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | ABC --> BCDEFG
 3 | ABC --> CDEFGHI
 4 | ---
 5 | ┌─────┐     ┌─────────┐
 6 | │     │     │         │
 7 | │ ABC ├────►│  BCDEFG │
 8 | │     │     │         │
 9 | └──┬──┘     └─────────┘
10 |    │                   
11 |    │                   
12 |    │                   
13 |    │                   
14 |    │                   
15 |    │        ┌─────────┐
16 |    │        │         │
17 |    └───────►│ CDEFGHI │
18 |             │         │
19 |             └─────────┘
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/two_root_nodes_longer_names.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | ABC --> BCDEFG
 3 | CDEFGH --> DEF
 4 | ---
 5 | +--------+     +--------+
 6 | |        |     |        |
 7 | |  ABC   |---->| BCDEFG |
 8 | |        |     |        |
 9 | +--------+     +--------+
10 |                          
11 |                          
12 |                          
13 |                          
14 |                          
15 | +--------+     +--------+
16 | |        |     |        |
17 | | CDEFGH |---->|  DEF   |
18 | |        |     |        |
19 | +--------+     +--------+
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/two_root_nodes_longer_names.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | ABC --> BCDEFG
 3 | CDEFGH --> DEF
 4 | ---
 5 | ┌────────┐     ┌────────┐
 6 | │        │     │        │
 7 | │  ABC   ├────►│ BCDEFG │
 8 | │        │     │        │
 9 | └────────┘     └────────┘
10 |                          
11 |                          
12 |                          
13 |                          
14 |                          
15 | ┌────────┐     ┌────────┐
16 | │        │     │        │
17 | │ CDEFGH ├────►│  DEF   │
18 | │        │     │        │
19 | └────────┘     └────────┘
20 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/backlink_from_bottom.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | B --> C
 4 | A --> C
 5 | B --> D
 6 | C --> D
 7 | ---
 8 | +---+     +---+     +---+
 9 | |   |     |   |     |   |
10 | | A |---->| B |---->| D |
11 | |   |     |   |     |   |
12 | +---+     +---+     +---+
13 |   |         |         ^  
14 |   |         |         |  
15 |   |         |         |  
16 |   |         |         |  
17 |   |         v         |  
18 |   |       +---+       |  
19 |   |       |   |       |  
20 |   +------>| C |-------+  
21 |           |   |          
22 |           +---+          
23 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/backlink_from_top.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | B --> C
 4 | A --> C
 5 | B --> D
 6 | D --> C
 7 | ---
 8 | +---+     +---+     +---+
 9 | |   |     |   |     |   |
10 | | A |---->| B |--+->| D |
11 | |   |     |   |  |  |   |
12 | +---+     +---+  |  +---+
13 |   |         |    |       
14 |   |         |    |       
15 |   |         +----+       
16 |   |         |            
17 |   |         v            
18 |   |       +---+          
19 |   |       |   |          
20 |   +------>| C |          
21 |           |   |          
22 |           +---+          
23 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_mixed_nodes.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | X
 3 | subgraph one
 4 |     A --> B
 5 | end
 6 | Y
 7 | X --> A
 8 | B --> Y
 9 | ---
10 |         +-----------------+        
11 |         |       one       |        
12 |         |                 |        
13 |         |                 |        
14 | +---+   | +---+     +---+ |   +---+
15 | |   |   | |   |     |   | |   |   |
16 | | X |---->| A |---->| B |---->| Y |
17 | |   |   | |   |     |   | |   |   |
18 | +---+   | +---+     +---+ |   +---+
19 |         |                 |        
20 |         +-----------------+        
21 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/backlink_from_top.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | B --> C
 4 | A --> C
 5 | B --> D
 6 | D --> C
 7 | ---
 8 | ┌───┐     ┌───┐     ┌───┐
 9 | │   │     │   │     │   │
10 | │ A ├────►│ B ├──┬─►┤ D │
11 | │   │     │   │  │  │   │
12 | └─┬─┘     └─┬─┘  │  └───┘
13 |   │         │    │       
14 |   │         │    │       
15 |   │         ├────┘       
16 |   │         │            
17 |   │         ▼            
18 |   │       ┌───┐          
19 |   │       │   │          
20 |   └──────►│ C │          
21 |           │   │          
22 |           └───┘          
23 | 


--------------------------------------------------------------------------------
/cmd/testdata/extended-chars/backlink_from_bottom.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | A --> B
 3 | B --> C
 4 | A --> C
 5 | B --> D
 6 | C --> D
 7 | ---
 8 | ┌───┐     ┌───┐     ┌───┐
 9 | │   │     │   │     │   │
10 | │ A ├────►│ B ├────►│ D │
11 | │   │     │   │     │   │
12 | └─┬─┘     └─┬─┘     └───┘
13 |   │         │         ▲  
14 |   │         │         │  
15 |   │         │         │  
16 |   │         │         │  
17 |   │         ▼         │  
18 |   │       ┌───┐       │  
19 |   │       │   │       │  
20 |   └──────►│ C ├───────┘  
21 |           │   │          
22 |           └───┘          
23 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/bidirectional_messages.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant Client
 3 |     participant Server
 4 |     Client->>Server: Request
 5 |     Server-->>Client: Response
 6 |     Client->>Server: Acknowledge
 7 | ---
 8 | ┌────────┐     ┌────────┐
 9 | │ Client │     │ Server │
10 | └────┬───┘     └────┬───┘
11 |      │              │
12 |      │ Request      │
13 |      ├─────────────►│
14 |      │              │
15 |      │ Response     │
16 |      │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┤
17 |      │              │
18 |      │ Acknowledge  │
19 |      ├─────────────►│
20 |      │              │
21 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/adjacent_participants_communication.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     participant C
 5 |     A->>B: First
 6 |     B->>C: Second
 7 |     A->>C: Direct
 8 | ---
 9 | ┌───┐     ┌───┐     ┌───┐
10 | │ A │     │ B │     │ C │
11 | └─┬─┘     └─┬─┘     └─┬─┘
12 |   │         │         │
13 |   │ First   │         │
14 |   ├────────►│         │
15 |   │         │         │
16 |   │         │ Second  │
17 |   │         ├────────►│
18 |   │         │         │
19 |   │ Direct  │         │
20 |   ├──────────────────►│
21 |   │         │         │
22 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_three_separate.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph Frontend
 3 |     UI
 4 | end
 5 | subgraph Backend
 6 |     API
 7 | end
 8 | subgraph Database
 9 |     DB
10 | end
11 | UI --> API
12 | API --> DB
13 | ---
14 | +--------+ +---------+ +--------+
15 | |Frontend| | Backend | |Database|
16 | |        | |         | |        |
17 | |        | |         | |        |
18 | | +----+ | | +-----+ | | +----+ |
19 | | |    | | | |     | | | |    | |
20 | | | UI |---->| API |---->| DB | |
21 | | |    | | | |     | | | |    | |
22 | | +----+ | | +-----+ | | +----+ |
23 | |        | |         | |        |
24 | +--------+ +---------+ +--------+
25 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence-ascii/three_participants.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     Alice->>Bob: Step 1
 3 |     Bob->>Charlie: Step 2
 4 |     Charlie-->>Alice: Done
 5 | ---
 6 | +-------+     +-----+     +---------+
 7 | | Alice |     | Bob |     | Charlie |
 8 | +---+---+     +--+--+     +----+----+
 9 |     |            |             |
10 |     | Step 1     |             |
11 |     +----------->|             |
12 |     |            |             |
13 |     |            | Step 2      |
14 |     |            +------------>|
15 |     |            |             |
16 |     | Done       |             |
17 |     |<.........................+
18 |     |            |             |
19 | 


--------------------------------------------------------------------------------
/scripts/release.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | set -e
 4 | set -x
 5 | 
 6 | if [ -z "$1" ]; then
 7 |   echo "Usage: $0 <version>"
 8 |   exit 1
 9 | fi
10 | NEXT_TAG=$1
11 | CURRENT_TAG=$(git tag | tail -n1)
12 | 
13 | # Replace all occurrences of the current version with the next version
14 | rg -F -l "${CURRENT_TAG}" | grep -v 'go\.mod\|go\.sum' | xargs sed -i "s/${CURRENT_TAG}/${NEXT_TAG}/g"
15 | git add .
16 | git commit -am "release version ${NEXT_TAG}"
17 | 
18 | # Show changes of last commit
19 | git show HEAD
20 | 
21 | # Ask for confirmation before pushing
22 | read -p "Push to origin? [y/N] " -n 1 -r
23 | 
24 | git tag ${NEXT_TAG}
25 | git push
26 | git push --tags
27 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM golang:1.25-alpine AS builder
 2 | WORKDIR /build
 3 | COPY go.mod go.sum ./
 4 | RUN go mod download
 5 | COPY . .
 6 | RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o mermaid-ascii .
 7 | 
 8 | FROM alpine:latest
 9 | RUN apk --no-cache add ca-certificates
10 | RUN addgroup -g 1000 mermaid && \
11 |     adduser -D -u 1000 -G mermaid mermaid
12 | 
13 | WORKDIR /app
14 | COPY --from=builder /build/mermaid-ascii /usr/local/bin/mermaid-ascii
15 | COPY --from=builder /build/templates /app/templates
16 | RUN chown -R mermaid:mermaid /app
17 | 
18 | USER mermaid
19 | EXPOSE 3001
20 | ENTRYPOINT ["mermaid-ascii"]
21 | CMD ["--help"]
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/.air.toml:
--------------------------------------------------------------------------------
 1 | # Air configuration for mermaid-ascii web server live reloads
 2 | 
 3 | root = "."
 4 | tmp_dir = "tmp"
 5 | 
 6 | [build]
 7 | cmd = "go build -o tmp/mermaid-ascii ./"
 8 | bin = "tmp/mermaid-ascii web"
 9 | full_bin = ""
10 | include_ext = ["go", "tmpl", "html"]
11 | exclude_dir = ["tmp", "testdata", "vendor"]
12 | exclude_file = []
13 | exclude_regex = []
14 | include_dir = [".", "cmd", "templates"]
15 | delay = 1000
16 | kill_delay = 500
17 | send_interrupt = false
18 | stop_on_error = true
19 | 
20 | [log]
21 | time = false
22 | 
23 | [color]
24 | main = "white"
25 | watcher = "cyan"
26 | build = "yellow"
27 | runner = "green"
28 | 
29 | [misc]
30 | clean_on_exit = false
31 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_three_levels_nested.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph level1
 3 |     subgraph level2
 4 |         subgraph level3
 5 |             A
 6 |         end
 7 |     end
 8 | end
 9 | ---
10 | +---------------+
11 | |    level1     |
12 | |               |
13 | |               |
14 | | +-----------+ |
15 | | |  level2   | |
16 | | |           | |
17 | | |           | |
18 | | | +-------+ | |
19 | | | |level3 | | |
20 | | | |       | | |
21 | | | |       | | |
22 | | | | +---+ | | |
23 | | | | |   | | | |
24 | | | | | A | | | |
25 | | | | |   | | | |
26 | | | | +---+ | | |
27 | | | |       | | |
28 | | | +-------+ | |
29 | | |           | |
30 | | +-----------+ |
31 | |               |
32 | +---------------+
33 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_mixed_nodes_td.txt:
--------------------------------------------------------------------------------
 1 | graph TD
 2 | X
 3 | subgraph one
 4 |     A --> B
 5 | end
 6 | Y
 7 | X --> A
 8 | B --> Y
 9 | ---
10 |   +---+  
11 |   |   |  
12 |   | X |  
13 |   |   |  
14 |   +---+  
15 |     |    
16 |     |    
17 |     |    
18 |     |    
19 |     |    
20 | +---|---+
21 | |  one  |
22 | |   |   |
23 | |   v   |
24 | | +---+ |
25 | | |   | |
26 | | | A | |
27 | | |   | |
28 | | +---+ |
29 | |   |   |
30 | |   |   |
31 | |   |   |
32 | |   |   |
33 | |   v   |
34 | | +---+ |
35 | | |   | |
36 | | | B | |
37 | | |   | |
38 | | +---+ |
39 | |   |   |
40 | +---|---+
41 |     |    
42 |     |    
43 |     v    
44 |   +---+  
45 |   |   |  
46 |   | Y |  
47 |   |   |  
48 |   +---+  
49 | 


--------------------------------------------------------------------------------
/.github/workflows/check-goreleaser.yaml:
--------------------------------------------------------------------------------
 1 | name: lint release config
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |   pull_request:
 8 |     branches:
 9 |       - "*"
10 | 
11 | permissions:
12 |   contents: write
13 | 
14 | jobs:
15 |   goreleaser:
16 |     runs-on: ubuntu-latest
17 |     steps:
18 |       - uses: actions/checkout@v3
19 |         with:
20 |           fetch-depth: 0
21 |       - run: git fetch --force --tags
22 |       - uses: actions/setup-go@v3
23 |         with:
24 |           go-version: '>=1.20.1'
25 |           cache: true
26 |       - uses: goreleaser/goreleaser-action@v4
27 |         with:
28 |           distribution: goreleaser
29 |           version: latest
30 |           args: check
31 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_with_labels.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph one
 3 |     A -->|sends| B
 4 | end
 5 | subgraph two
 6 |     C -->|receives| D
 7 | end
 8 | B -->|data| C
 9 | ---
10 | +-------------------+  +----------------------+
11 | |        one        |  |         two          |
12 | |                   |  |                      |
13 | |                   |  |                      |
14 | | +---+       +---+ |  | +---+          +---+ |
15 | | |   |       |   | |  | |   |          |   | |
16 | | | A |-sends>| B |data->| C |receives->| D | |
17 | | |   |       |   | |  | |   |          |   | |
18 | | +---+       +---+ |  | +---+          +---+ |
19 | |                   |  |                      |
20 | +-------------------+  +----------------------+
21 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yaml:
--------------------------------------------------------------------------------
 1 | name: release
 2 | 
 3 | on:
 4 |   push:
 5 |     # run only against tags
 6 |     tags:
 7 |       - '*'
 8 | 
 9 | permissions:
10 |   contents: write
11 | 
12 | jobs:
13 |   goreleaser:
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |       - uses: actions/checkout@v3
17 |         with:
18 |           fetch-depth: 0
19 |       - run: git fetch --force --tags
20 |       - uses: actions/setup-go@v3
21 |         with:
22 |           go-version: '>=1.20.1'
23 |           cache: true
24 |       - uses: goreleaser/goreleaser-action@v4
25 |         with:
26 |           distribution: goreleaser
27 |           version: latest
28 |           args: release --clean
29 |         env:
30 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
31 | 


--------------------------------------------------------------------------------
/cmd/render.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
 7 | )
 8 | 
 9 | func RenderDiagram(input string, config *diagram.Config) (string, error) {
10 | 	if config == nil {
11 | 		config = diagram.DefaultConfig()
12 | 	}
13 | 
14 | 	diag, err := DiagramFactory(input)
15 | 	if err != nil {
16 | 		return "", fmt.Errorf("failed to detect diagram type: %w", err)
17 | 	}
18 | 
19 | 	if err := diag.Parse(input); err != nil {
20 | 		return "", fmt.Errorf("failed to parse %s diagram: %w", diag.Type(), err)
21 | 	}
22 | 
23 | 	output, err := diag.Render(config)
24 | 	if err != nil {
25 | 		return "", fmt.Errorf("failed to render %s diagram: %w", diag.Type(), err)
26 | 	}
27 | 
28 | 	return output, nil
29 | }
30 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/four_participants.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant A
 3 |     participant B
 4 |     participant C
 5 |     participant D
 6 |     A->>B: Msg1
 7 |     B->>C: Msg2
 8 |     C->>D: Msg3
 9 |     D-->>A: Response
10 | ---
11 | ┌───┐     ┌───┐     ┌───┐     ┌───┐
12 | │ A │     │ B │     │ C │     │ D │
13 | └─┬─┘     └─┬─┘     └─┬─┘     └─┬─┘
14 |   │         │         │         │
15 |   │ Msg1    │         │         │
16 |   ├────────►│         │         │
17 |   │         │         │         │
18 |   │         │ Msg2    │         │
19 |   │         ├────────►│         │
20 |   │         │         │         │
21 |   │         │         │ Msg3    │
22 |   │         │         ├────────►│
23 |   │         │         │         │
24 |   │ Response│         │         │
25 |   │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
26 |   │         │         │         │
27 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_complex_nested.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph outer
 3 |     A
 4 |     subgraph inner
 5 |         B
 6 |     end
 7 |     C
 8 | end
 9 | D
10 | ---
11 | +-----------+
12 | |   outer   |
13 | |           |
14 | |           |
15 | |   +---+   |
16 | |   |   |   |
17 | |   | A |   |
18 | |   |   |   |
19 | |   +---+   |
20 | |           |
21 | | +-------+ |
22 | | | inner | |
23 | | |       | |
24 | | |       | |
25 | | | +---+ | |
26 | | | |   | | |
27 | | | | B | | |
28 | | | |   | | |
29 | | | +---+ | |
30 | | |       | |
31 | | +-------+ |
32 | |           |
33 | |           |
34 | |           |
35 | |   +---+   |
36 | |   |   |   |
37 | |   | C |   |
38 | |   |   |   |
39 | |   +---+   |
40 | |           |
41 | +-----------+
42 |              
43 |              
44 |              
45 |     +---+    
46 |     |   |    
47 |     | D |    
48 |     |   |    
49 |     +---+    
50 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_multiple_edges.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | subgraph one
 3 |     A --> B
 4 |     A --> C
 5 | end
 6 | subgraph two
 7 |     D --> E
 8 | end
 9 | B --> D
10 | C --> E
11 | ---
12 | +-----------------+ +-------+
13 | |       one       | |  two  |
14 | |                 | |       |
15 | |                 | |       |
16 | | +---+     +---+ | | +---+ |
17 | | |   |     |   | | | |   | |
18 | | | A |---->| B |---->| D | |
19 | | |   |     |   | | | |   | |
20 | | +---+     +---+ | | +---+ |
21 | |   |             | |   |   |
22 | |   |             | |   |   |
23 | |   |             | |   |   |
24 | |   |             | |   |   |
25 | |   |             | |   v   |
26 | |   |       +---+ | | +---+ |
27 | |   |       |   | | | |   | |
28 | |   +------>| C |---->| E | |
29 | |           |   | | | |   | |
30 | |           +---+ | | +---+ |
31 | |                 | |       |
32 | +-----------------+ +-------+
33 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yaml:
--------------------------------------------------------------------------------
 1 | name: test
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |   pull_request:
 8 |     branches:
 9 |       - "*"
10 | 
11 | permissions:
12 |   contents: write
13 | 
14 | jobs:
15 |   goreleaser:
16 |     runs-on: ubuntu-latest
17 |     steps:
18 |       - uses: actions/checkout@v3
19 |         with:
20 |           fetch-depth: 0
21 |       - name: Set up Go
22 |         uses: actions/setup-go@v3
23 |         with:
24 |           go-version: '1.22'
25 |       - name: Run Go tests
26 |         run: go test ./...
27 |   check_nix:
28 |     name: Build Nix targets
29 |     runs-on: ubuntu-22.04
30 |     steps:
31 |       - uses: actions/checkout@v3
32 |       - name: Check Nix flake inputs
33 |         uses: DeterminateSystems/flake-checker-action@v4 # This action
34 |       - name: Install Nix
35 |         uses: DeterminateSystems/nix-installer-action@v3
36 |       - name: Build default package
37 |         run: nix build
38 | 


--------------------------------------------------------------------------------
/PKGBUILD:
--------------------------------------------------------------------------------
 1 | pkgname='mermaid-ascii'
 2 | pkgver=0.6.0
 3 | pkgrel=1
 4 | pkgdesc='Render Mermaid ASCII in textual form'
 5 | arch=(x86_64)
 6 | url="https://github.com/AlexanderGrooff/${pkgname}"
 7 | license=('MIT')
 8 | makedepends=('go')
 9 | source=("git+${url}.git#tag=${pkgver}")
10 | sha256sums=('SKIP')
11 | 
12 | pkgver() {
13 |   cd "${pkgname}"
14 |   git describe --tags
15 | }
16 | 
17 | prepare(){
18 |   cd "${pkgname}"
19 |   mkdir -p build/
20 | }
21 | 
22 | build() {
23 |   cd "${pkgname}"
24 |   export CGO_CPPFLAGS="${CPPFLAGS}"
25 |   export CGO_CFLAGS="${CFLAGS}"
26 |   export CGO_CXXFLAGS="${CXXFLAGS}"
27 |   export CGO_LDFLAGS="${LDFLAGS}"
28 |   export GOFLAGS="-buildmode=pie -trimpath -ldflags=-linkmode=external -mod=readonly -modcacherw"
29 |   go build -o build
30 | }
31 | 
32 | check() {
33 |   cd "${pkgname}"
34 |   go test ./...
35 | }
36 | 
37 | package() {
38 |   cd "${pkgname}"
39 |   install -Dm755 build/${pkgname} "$pkgdir"/usr/bin/${pkgname}
40 | }
41 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/three_participants.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant User
 3 |     participant WebApp
 4 |     participant Database
 5 |     User->>WebApp: Login Request
 6 |     WebApp->>Database: Query User Credentials
 7 |     Database-->>WebApp: Return User Data
 8 |     WebApp-->>User: Login Success
 9 | ---
10 | ┌──────┐     ┌────────┐     ┌──────────┐
11 | │ User │     │ WebApp │     │ Database │
12 | └───┬──┘     └────┬───┘     └─────┬────┘
13 |     │             │               │
14 |     │ Login Request               │
15 |     ├────────────►│               │
16 |     │             │               │
17 |     │             │ Query User Credentials
18 |     │             ├──────────────►│
19 |     │             │               │
20 |     │             │ Return User Data
21 |     │             │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
22 |     │             │               │
23 |     │ Login Success               │
24 |     │◄┈┈┈┈┈┈┈┈┈┈┈┈┤               │
25 |     │             │               │
26 | 


--------------------------------------------------------------------------------
/internal/sequence/example_test.go:
--------------------------------------------------------------------------------
 1 | package sequence_test
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"log"
 6 | 
 7 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/sequence"
 8 | )
 9 | 
10 | func ExampleParse() {
11 | 	input := `sequenceDiagram
12 |     Alice->>Bob: Hello
13 |     Bob-->>Alice: Hi`
14 | 
15 | 	sd, err := sequence.Parse(input)
16 | 	if err != nil {
17 | 		log.Fatal(err)
18 | 	}
19 | 
20 | 	fmt.Printf("Participants: %d\n", len(sd.Participants))
21 | 	fmt.Printf("Messages: %d\n", len(sd.Messages))
22 | 	// Output:
23 | 	// Participants: 2
24 | 	// Messages: 2
25 | }
26 | 
27 | func ExampleIsSequenceDiagram() {
28 | 	sequenceInput := `sequenceDiagram
29 |     A->>B: Test`
30 | 
31 | 	graphInput := `graph LR
32 |     A-->B`
33 | 
34 | 	fmt.Printf("First is sequence: %v\n", sequence.IsSequenceDiagram(sequenceInput))
35 | 	fmt.Printf("Second is sequence: %v\n", sequence.IsSequenceDiagram(graphInput))
36 | 	// Output:
37 | 	// First is sequence: true
38 | 	// Second is sequence: false
39 | }
40 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: ["AlexanderGrooff"]  # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
12 | polar: # Replace with a single Polar username
13 | buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
14 | thanks_dev: # Replace with a single thanks.dev username
15 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
16 | 


--------------------------------------------------------------------------------
/.cursor/rules/tests.mdc:
--------------------------------------------------------------------------------
 1 | ---
 2 | alwaysApply: true
 3 | ---
 4 | For **every change you make**, ensure that you add tests for the new functionality. Test coverage is non-negotiable!
 5 | Run tests locally by running `go test ./...` in the root directory. This is fast, and should be done regularly.
 6 | 
 7 | Tests are added through the `testdata/ascii` directory. The file name should be the name of the test case, and the file should contain the mermaid code to test.
 8 | The first section of the file should be the mermaid code to test, and the second section should be the expected output.
 9 | The sections are separated by a line that contains only `---`.
10 | 
11 | For example, if you add a new feature that allows you to add a comment to a node, you should add a new file to the `testdata/ascii` directory called `comments.txt` with the following content:
12 | 
13 | ```mermaid
14 | graph LR
15 | A --> B
16 | %% This is a comment
17 | ---
18 | +---+      +---+
19 | |   |      |   |
20 | | A | ---> | B |
21 | |   |      |   |
22 | +---+      +---+
23 | ```
24 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_nested_with_external.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | X
 3 | subgraph outer
 4 |     A
 5 |     subgraph inner
 6 |         B --> C
 7 |     end
 8 |     A --> B
 9 | end
10 | X --> A
11 | C --> Y
12 | Y
13 | ---
14 |         +-----------------------------+      
15 |         |            outer            |      
16 |         |                             |      
17 |         |                             |      
18 |         |         +-----------------+ |      
19 |         |         |      inner      | |      
20 |         |         |                 | |      
21 |         |         |                 | |      
22 | +---+   | +---+   | +---+     +---+ | | +---+
23 | |   |   | |   |   | |   |     |   | | | |   |
24 | | X |---->| A |---->| B |---->| C |---->| Y |
25 | |   |   | |   |   | |   |     |   | | | |   |
26 | +---+   | +---+   | +---+     +---+ | | +---+
27 |         |         |                 | |      
28 |         |         +-----------------+ |      
29 |         |                             |      
30 |         +-----------------------------+      
31 | 


--------------------------------------------------------------------------------
/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   inputs = {
 3 |     alex.url = "github:AlexanderGrooff/nix-flakes";
 4 |   };
 5 | 
 6 |   outputs = {
 7 |     self,
 8 |     flake-utils,
 9 |     nixpkgs,
10 |     alex,
11 |   }:
12 |     flake-utils.lib.eachDefaultSystem (
13 |       system: let
14 |         pkgs = import nixpkgs {inherit system;};
15 |       in {
16 |         devShells.default = pkgs.mkShell {
17 |           nativeBuildInputs = [
18 |             pkgs.go_1_23
19 |             pkgs.pre-commit
20 |             pkgs.golangci-lint
21 | 
22 |             # Add other Go tools or dependencies here if needed, e.g.:
23 |             pkgs.gopls
24 |             pkgs.delve
25 |             pkgs.goreleaser
26 |             pkgs.air
27 |           ];
28 | 
29 |           # Disable hardening for cgo
30 |           hardeningDisable = [ "all" ];
31 |         };
32 |         packages.default = pkgs.buildGoModule {
33 |           name = "mermaid-ascii";
34 |           src = ./.;
35 |           vendorHash = "sha256-aB9sbTtlHbptM2995jizGFtSmEIg3i8zWkXz1zzbIek=";
36 |         };
37 |       }
38 |     );
39 | }
40 | 


--------------------------------------------------------------------------------
/cmd/sequence_example_test.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
 7 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/sequence"
 8 | )
 9 | 
10 | // ExampleParse demonstrates basic sequence diagram parsing and rendering.
11 | func ExampleParse() {
12 | 	input := `sequenceDiagram
13 |     Alice->>Bob: Hello
14 |     Bob-->>Alice: Hi`
15 | 
16 | 	// Parse the Mermaid syntax
17 | 	parsed, err := sequence.Parse(input)
18 | 	if err != nil {
19 | 		fmt.Printf("Parse error: %v\n", err)
20 | 		return
21 | 	}
22 | 
23 | 	// Render with ASCII characters
24 | 	config := diagram.NewTestConfig(true, "cli")
25 | 
26 | 	output, err := sequence.Render(parsed, config)
27 | 	if err != nil {
28 | 		fmt.Printf("Render error: %v\n", err)
29 | 		return
30 | 	}
31 | 
32 | 	fmt.Print(output)
33 | 	// Output:
34 | 	// +-------+     +-----+
35 | 	// | Alice |     | Bob |
36 | 	// +---+---+     +--+--+
37 | 	//     |            |
38 | 	//     | Hello      |
39 | 	//     +----------->|
40 | 	//     |            |
41 | 	//     | Hi         |
42 | 	//     |<...........+
43 | 	//     |            |
44 | }
45 | 


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


--------------------------------------------------------------------------------
/.goreleaser.yaml:
--------------------------------------------------------------------------------
 1 | # yaml-language-server: $schema=https://goreleaser.com/static/schema.json
 2 | # vim: set ts=2 sw=2 tw=0 fo=cnqoj
 3 | 
 4 | version: 2
 5 | project_name: mermaid-ascii
 6 | 
 7 | before:
 8 |   hooks:
 9 |     # You may remove this if you don't use go modules.
10 |     - go mod tidy
11 |     # you may remove this if you don't need go generate
12 |     - go generate ./...
13 | 
14 | builds:
15 |   - env:
16 |       - CGO_ENABLED=0
17 |     goos:
18 |       - linux
19 |       - windows
20 |       - darwin
21 | 
22 | archives:
23 |   - formats:
24 |       - tar.gz
25 |     # this name template makes the OS and Arch compatible with the results of `uname`.
26 |     name_template: >-
27 |       {{ .ProjectName }}_
28 |       {{- title .Os }}_
29 |       {{- if eq .Arch "amd64" }}x86_64
30 |       {{- else if eq .Arch "386" }}i386
31 |       {{- else }}{{ .Arch }}{{ end }}
32 |       {{- if .Arm }}v{{ .Arm }}{{ end }}
33 |     # use zip for windows archives
34 |     format_overrides:
35 |       - goos: windows
36 |         formats:
37 |           - zip
38 | 
39 | changelog:
40 |   sort: asc
41 |   filters:
42 |     exclude:
43 |       - "^docs:"
44 |       - "^test:"
45 | 


--------------------------------------------------------------------------------
/internal/diagram/utils.go:
--------------------------------------------------------------------------------
 1 | package diagram
 2 | 
 3 | import (
 4 | 	"regexp"
 5 | 	"strings"
 6 | )
 7 | 
 8 | // removeComments removes Mermaid comment lines from input.
 9 | // This function is shared between graph and sequence diagram parsers.
10 | // It handles both full-line comments (%% at start) and inline comments (%% after content).
11 | func RemoveComments(lines []string) []string {
12 | 	cleaned := make([]string, 0, len(lines))
13 | 
14 | 	for _, line := range lines {
15 | 		// Skip lines that start with %% (full-line comments)
16 | 		if strings.HasPrefix(strings.TrimSpace(line), "%%") {
17 | 			continue
18 | 		}
19 | 
20 | 		// Remove inline comments (anything after %%)
21 | 		if idx := strings.Index(line, "%%"); idx != -1 {
22 | 			line = strings.TrimSpace(line[:idx])
23 | 		}
24 | 
25 | 		// Only keep non-empty lines after comment removal
26 | 		if len(strings.TrimSpace(line)) > 0 {
27 | 			cleaned = append(cleaned, line)
28 | 		}
29 | 	}
30 | 
31 | 	return cleaned
32 | }
33 | 
34 | // SplitLines splits input on both actual newlines and escaped newlines (for curl compatibility).
35 | func SplitLines(input string) []string {
36 | 	newlinePattern := regexp.MustCompile(`\n|\\n`)
37 | 	return newlinePattern.Split(input, -1)
38 | }
39 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_td_multiple_paddingy.txt:
--------------------------------------------------------------------------------
 1 | paddingX=3
 2 | paddingY=3
 3 | graph TD
 4 | subgraph Frontend
 5 |     UI --> API
 6 | end
 7 | subgraph Backend
 8 |     API --> Database
 9 |     API --> Cache
10 | end
11 | ---
12 | +--------------+            
13 | |  Frontend    |            
14 | |              |            
15 | |              |            
16 | | +----------+ |            
17 | | |          | |            
18 | | |    UI    | |            
19 | | |          | |            
20 | | +----------+ |            
21 | |       |      |            
22 | |       |      |            
23 | |       v      |            
24 | | +----------+ |            
25 | | |          | |            
26 | | |   API    |-------+      
27 | | |          | |     |      
28 | | +----------+ |     |      
29 | |       |      |     |      
30 | +-------|------+     |      
31 |         |            |      
32 | +-------|------------|-----+
33 | |       | Backend    |     |
34 | |       |            |     |
35 | |       v            v     |
36 | | +----------+   +-------+ |
37 | | |          |   |       | |
38 | | | Database |   | Cache | |
39 | | |          |   |       | |
40 | | +----------+   +-------+ |
41 | |                          |
42 | +--------------------------+
43 | 


--------------------------------------------------------------------------------
/cmd/testdata/sequence/long_participant_names.txt:
--------------------------------------------------------------------------------
 1 | sequenceDiagram
 2 |     participant UserInterface
 3 |     participant BackendAPI
 4 |     participant DatabaseServer
 5 |     UserInterface->>BackendAPI: Send Request
 6 |     BackendAPI->>DatabaseServer: Query Data
 7 |     DatabaseServer-->>BackendAPI: Return Results
 8 |     BackendAPI-->>UserInterface: Send Response
 9 | ---
10 | ┌───────────────┐     ┌────────────┐     ┌────────────────┐
11 | │ UserInterface │     │ BackendAPI │     │ DatabaseServer │
12 | └───────┬───────┘     └──────┬─────┘     └────────┬───────┘
13 |         │                    │                    │
14 |         │ Send Request       │                    │
15 |         ├───────────────────►│                    │
16 |         │                    │                    │
17 |         │                    │ Query Data         │
18 |         │                    ├───────────────────►│
19 |         │                    │                    │
20 |         │                    │ Return Results     │
21 |         │                    │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
22 |         │                    │                    │
23 |         │ Send Response      │                    │
24 |         │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤                    │
25 |         │                    │                    │
26 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | PREFIX ?= /usr/local/bin
 2 | pkgname ?= mermaid-ascii
 3 | 
 4 | targets += $(PREFIX)/$(pkgname)
 5 | 
 6 | ifneq (,$(wildcard /usr/share/bash-completion/completions/))
 7 |   targets += /usr/share/bash-completion/completions/$(pkgname)
 8 | endif
 9 | 
10 | all: build/$(pkgname) build/completions/bash build/completions/zsh build/completions/fish
11 | 
12 | build/$(pkgname): cmd/*.go | build/
13 | 	go build -o $@
14 | 
15 | .PHONY: install
16 | install: $(targets)
17 | 
18 | $(PREFIX)/$(pkgname): build/$(pkgname) | $(PREFIX)
19 | 	install -m 755 $< $@
20 | /usr/share/bash-completion/completions/$(pkgname): build/completions/bash
21 | 	install -m 755 $< $@
22 | 
23 | build/completions/%: build/$(pkgname) | build/completions/
24 | 	./$< completion $(@F) > $@
25 | 
26 | %/:
27 | 	mkdir -p $@
28 | 
29 | .PHONY: clean
30 | clean:
31 | 	$(RM) -r build
32 | 
33 | .PHONY: uninstall
34 | uninstall:
35 | 	$(RM) $(targets)
36 | 
37 | .PHONY: test
38 | test:
39 | 	go test ./... -v
40 | 
41 | .PHONY: docker-build
42 | docker-build:
43 | 	docker build -t mermaid-ascii:latest .
44 | 
45 | .PHONY: docker-test
46 | docker-test:
47 | 	docker build --target test -t mermaid-ascii:test -f Dockerfile.test .
48 | 
49 | .PHONY: docker-run
50 | docker-run:
51 | 	docker run -i mermaid-ascii:latest
52 | 
53 | dev:
54 | 	air
55 | 


--------------------------------------------------------------------------------
/internal/sequence/charset.go:
--------------------------------------------------------------------------------
 1 | package sequence
 2 | 
 3 | // BoxChars defines the characters used for drawing the diagram.
 4 | type BoxChars struct {
 5 | 	TopLeft      rune
 6 | 	TopRight     rune
 7 | 	BottomLeft   rune
 8 | 	BottomRight  rune
 9 | 	Horizontal   rune
10 | 	Vertical     rune
11 | 	TeeDown      rune
12 | 	TeeRight     rune
13 | 	TeeLeft      rune
14 | 	Cross        rune
15 | 	ArrowRight   rune
16 | 	ArrowLeft    rune
17 | 	SolidLine    rune
18 | 	DottedLine   rune
19 | 	SelfTopRight rune
20 | 	SelfBottom   rune
21 | }
22 | 
23 | var ASCII = BoxChars{
24 | 	TopLeft:      '+',
25 | 	TopRight:     '+',
26 | 	BottomLeft:   '+',
27 | 	BottomRight:  '+',
28 | 	Horizontal:   '-',
29 | 	Vertical:     '|',
30 | 	TeeDown:      '+',
31 | 	TeeRight:     '+',
32 | 	TeeLeft:      '+',
33 | 	Cross:        '+',
34 | 	ArrowRight:   '>',
35 | 	ArrowLeft:    '<',
36 | 	SolidLine:    '-',
37 | 	DottedLine:   '.',
38 | 	SelfTopRight: '+',
39 | 	SelfBottom:   '+',
40 | }
41 | 
42 | var Unicode = BoxChars{
43 | 	TopLeft:      '┌',
44 | 	TopRight:     '┐',
45 | 	BottomLeft:   '└',
46 | 	BottomRight:  '┘',
47 | 	Horizontal:   '─',
48 | 	Vertical:     '│',
49 | 	TeeDown:      '┬',
50 | 	TeeRight:     '├',
51 | 	TeeLeft:      '┤',
52 | 	Cross:        '┼',
53 | 	ArrowRight:   '►',
54 | 	ArrowLeft:    '◄',
55 | 	SolidLine:    '─',
56 | 	DottedLine:   '┈',
57 | 	SelfTopRight: '┐',
58 | 	SelfBottom:   '┘',
59 | }
60 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_td_multiple.txt:
--------------------------------------------------------------------------------
 1 | graph TD
 2 | subgraph Frontend
 3 |     UI --> API
 4 | end
 5 | subgraph Backend
 6 |     API --> Database
 7 |     API --> Cache
 8 | end
 9 | ---
10 | +--------------+              
11 | |  Frontend    |              
12 | |              |              
13 | |              |              
14 | | +----------+ |              
15 | | |          | |              
16 | | |    UI    | |              
17 | | |          | |              
18 | | +----------+ |              
19 | |       |      |              
20 | |       |      |              
21 | |       |      |              
22 | |       |      |              
23 | |       v      |              
24 | | +----------+ |              
25 | | |          | |              
26 | | |   API    |---------+      
27 | | |          | |       |      
28 | | +----------+ |       |      
29 | |       |      |       |      
30 | +-------|------+       |      
31 |         |              |      
32 |         |              |      
33 |         |              |      
34 | +-------|--------------|-----+
35 | |       |  Backend     |     |
36 | |       |              |     |
37 | |       v              v     |
38 | | +----------+     +-------+ |
39 | | |          |     |       | |
40 | | | Database |     | Cache | |
41 | | |          |     |       | |
42 | | +----------+     +-------+ |
43 | |                            |
44 | +----------------------------+
45 | 


--------------------------------------------------------------------------------
/cmd/testdata/ascii/subgraph_complex_mixed.txt:
--------------------------------------------------------------------------------
 1 | graph LR
 2 | Start
 3 | subgraph Processing
 4 |     A --> B
 5 |     B --> C
 6 | end
 7 | subgraph Storage
 8 |     D
 9 |     E
10 | end
11 | Start --> A
12 | C --> D
13 | C --> E
14 | D --> End
15 | E --> End
16 | End
17 | ---
18 |             +---------------------------+ +-------+          
19 |             |        Processing         | |Storage|          
20 |             |                           | |       |          
21 |             |                           | |       |          
22 | +-------+   | +---+     +---+     +---+ | | +---+ |   +-----+
23 | |       |   | |   |     |   |     |   | | | |   | |   |     |
24 | | Start |---->| A |---->| B |---->| C |---->| D |---->| End |
25 | |       |   | |   |     |   |     |   | | | |   | |   |     |
26 | +-------+   | +---+     +---+     +---+ | | +---+ |   +-----+
27 |             |                       |   | |       |      ^   
28 |             +-----------------------|---+ |       |      |   
29 |                                     |     |       |      |   
30 |                                     |     |       |      |   
31 |                                     |     |       |      |   
32 |                                     |     | +---+ |      |   
33 |                                     |     | |   | |      |   
34 |                                     +------>| E |--------+   
35 |                                           | |   | |          
36 |                                           | +---+ |          
37 |                                           |       |          
38 |                                           +-------+          
39 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/AlexanderGrooff/mermaid-ascii
 2 | 
 3 | go 1.21
 4 | 
 5 | require (
 6 | 	github.com/elliotchance/orderedmap/v2 v2.2.0
 7 | 	github.com/gin-gonic/gin v1.10.0
 8 | 	github.com/gookit/color v1.5.4
 9 | 	github.com/mattn/go-runewidth v0.0.19
10 | 	github.com/sirupsen/logrus v1.9.0
11 | 	github.com/spf13/cobra v1.6.1
12 | )
13 | 
14 | require (
15 | 	github.com/bytedance/sonic v1.11.6 // indirect
16 | 	github.com/bytedance/sonic/loader v0.1.1 // indirect
17 | 	github.com/clipperhouse/uax29/v2 v2.2.0 // indirect
18 | 	github.com/cloudwego/base64x v0.1.4 // indirect
19 | 	github.com/cloudwego/iasm v0.2.0 // indirect
20 | 	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
21 | 	github.com/gin-contrib/sse v0.1.0 // indirect
22 | 	github.com/go-playground/locales v0.14.1 // indirect
23 | 	github.com/go-playground/universal-translator v0.18.1 // indirect
24 | 	github.com/go-playground/validator/v10 v10.20.0 // indirect
25 | 	github.com/goccy/go-json v0.10.2 // indirect
26 | 	github.com/google/go-cmp v0.5.9 // indirect
27 | 	github.com/inconshreveable/mousetrap v1.0.1 // indirect
28 | 	github.com/json-iterator/go v1.1.12 // indirect
29 | 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
30 | 	github.com/leodido/go-urn v1.4.0 // indirect
31 | 	github.com/mattn/go-isatty v0.0.20 // indirect
32 | 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
33 | 	github.com/modern-go/reflect2 v1.0.2 // indirect
34 | 	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
35 | 	github.com/spf13/pflag v1.0.5 // indirect
36 | 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
37 | 	github.com/ugorji/go/codec v1.2.12 // indirect
38 | 	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 // indirect
39 | 	golang.org/x/arch v0.8.0 // indirect
40 | 	golang.org/x/crypto v0.23.0 // indirect
41 | 	golang.org/x/net v0.25.0 // indirect
42 | 	golang.org/x/sys v0.20.0 // indirect
43 | 	golang.org/x/text v0.15.0 // indirect
44 | 	google.golang.org/protobuf v1.34.1 // indirect
45 | 	gopkg.in/yaml.v3 v3.0.1 // indirect
46 | )
47 | 


--------------------------------------------------------------------------------
/cmd/diagram.go:
--------------------------------------------------------------------------------
 1 | package cmd
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"strings"
 6 | 
 7 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
 8 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/sequence"
 9 | )
10 | 
11 | func DiagramFactory(input string) (diagram.Diagram, error) {
12 | 	input = strings.TrimSpace(input)
13 | 
14 | 	if sequence.IsSequenceDiagram(input) {
15 | 		return &SequenceDiagram{}, nil
16 | 	}
17 | 
18 | 	lines := strings.Split(input, "\n")
19 | 	for _, line := range lines {
20 | 		trimmed := strings.TrimSpace(line)
21 | 		if trimmed == "" || strings.HasPrefix(trimmed, "%%") {
22 | 			continue
23 | 		}
24 | 		if strings.HasPrefix(trimmed, "graph ") || strings.HasPrefix(trimmed, "flowchart ") {
25 | 			return &GraphDiagram{}, nil
26 | 		}
27 | 		if !strings.HasPrefix(trimmed, "%%") {
28 | 			return &GraphDiagram{}, nil
29 | 		}
30 | 	}
31 | 
32 | 	return &GraphDiagram{}, nil
33 | }
34 | 
35 | type SequenceDiagram struct {
36 | 	parsed *sequence.SequenceDiagram
37 | }
38 | 
39 | func (sd *SequenceDiagram) Parse(input string) error {
40 | 	parsed, err := sequence.Parse(input)
41 | 	if err != nil {
42 | 		return err
43 | 	}
44 | 	sd.parsed = parsed
45 | 	return nil
46 | }
47 | 
48 | func (sd *SequenceDiagram) Render(config *diagram.Config) (string, error) {
49 | 	if sd.parsed == nil {
50 | 		return "", fmt.Errorf("sequence diagram not parsed: call Parse() before Render()")
51 | 	}
52 | 	return sequence.Render(sd.parsed, config)
53 | }
54 | 
55 | func (sd *SequenceDiagram) Type() string {
56 | 	return "sequence"
57 | }
58 | 
59 | type GraphDiagram struct {
60 | 	properties *graphProperties
61 | }
62 | 
63 | func (gd *GraphDiagram) Parse(input string) error {
64 | 	properties, err := mermaidFileToMap(input, "cli")
65 | 	if err != nil {
66 | 		return err
67 | 	}
68 | 	gd.properties = properties
69 | 	return nil
70 | }
71 | 
72 | func (gd *GraphDiagram) Render(config *diagram.Config) (string, error) {
73 | 	if gd.properties == nil {
74 | 		return "", fmt.Errorf("graph diagram not parsed: call Parse() before Render()")
75 | 	}
76 | 
77 | 	if config == nil {
78 | 		config = diagram.DefaultConfig()
79 | 	}
80 | 
81 | 	styleType := config.StyleType
82 | 	if styleType == "" {
83 | 		styleType = "cli"
84 | 	}
85 | 	gd.properties.styleType = styleType
86 | 	gd.properties.useAscii = config.UseAscii
87 | 
88 | 	return drawMap(gd.properties), nil
89 | }
90 | 
91 | func (gd *GraphDiagram) Type() string {
92 | 	return "graph"
93 | }
94 | 


--------------------------------------------------------------------------------
/cmd/root.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"io"
  6 | 	"os"
  7 | 
  8 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
  9 | 	log "github.com/sirupsen/logrus"
 10 | 	"github.com/spf13/cobra"
 11 | )
 12 | 
 13 | // Global flags
 14 | var Verbose bool
 15 | var Coords bool
 16 | var boxBorderPadding = 1
 17 | var paddingBetweenX = 5
 18 | var paddingBetweenY = 5
 19 | var graphDirection = "LR"
 20 | var useAscii = false
 21 | 
 22 | // rootCmd represents the base command when called without any subcommands
 23 | var rootCmd = &cobra.Command{
 24 | 	Use:   "mermaid-ascii",
 25 | 	Short: "Generate ASCII diagrams from mermaid code.",
 26 | 	Run: func(cmd *cobra.Command, args []string) {
 27 | 		if Verbose {
 28 | 			log.SetLevel(log.DebugLevel)
 29 | 		} else {
 30 | 			log.SetLevel(log.InfoLevel)
 31 | 		}
 32 | 
 33 | 		var mermaid []byte
 34 | 		var err error
 35 | 
 36 | 		filePath := cmd.Flag("file").Value.String()
 37 | 		if filePath == "" || filePath == "-" {
 38 | 			// Read from stdin
 39 | 			mermaid, err = io.ReadAll(os.Stdin)
 40 | 			if err != nil {
 41 | 				log.Fatal("Failed to read from stdin: ", err)
 42 | 				return
 43 | 			}
 44 | 		} else {
 45 | 			// Read from file
 46 | 			mermaid, err = os.ReadFile(filePath)
 47 | 			if err != nil {
 48 | 				log.Fatal("Failed to read mermaid file: ", err)
 49 | 				return
 50 | 			}
 51 | 		}
 52 | 
 53 | 		// Create render configuration from flags
 54 | 		config, err := diagram.NewCLIConfig(
 55 | 			useAscii,
 56 | 			Coords,
 57 | 			Verbose,
 58 | 			boxBorderPadding,
 59 | 			paddingBetweenX,
 60 | 			paddingBetweenY,
 61 | 			graphDirection,
 62 | 		)
 63 | 		if err != nil {
 64 | 			log.Fatalf("Invalid configuration: %v", err)
 65 | 		}
 66 | 
 67 | 		// Render diagram (automatically detects type)
 68 | 		output, err := RenderDiagram(string(mermaid), config)
 69 | 		if err != nil {
 70 | 			log.Fatal(err)
 71 | 		}
 72 | 		fmt.Print(output)
 73 | 	},
 74 | }
 75 | 
 76 | // Execute adds all child commands to the root command and sets flags appropriately.
 77 | // This is called by main.main(). It only needs to happen once to the rootCmd.
 78 | func Execute() {
 79 | 	err := rootCmd.Execute()
 80 | 	if err != nil {
 81 | 		os.Exit(1)
 82 | 	}
 83 | }
 84 | 
 85 | func init() {
 86 | 	// Here you will define your flags and configuration settings.
 87 | 	// Cobra supports persistent flags, which, if defined here,
 88 | 	// will be global for your application.
 89 | 
 90 | 	rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "Verbose output")
 91 | 	rootCmd.PersistentFlags().BoolVarP(&useAscii, "ascii", "a", false, "Don't use extended character set")
 92 | 	rootCmd.PersistentFlags().BoolVarP(&Coords, "coords", "c", false, "Show coordinates")
 93 | 	rootCmd.PersistentFlags().IntVarP(&paddingBetweenX, "paddingX", "x", paddingBetweenX, "Horizontal space between nodes")
 94 | 	rootCmd.PersistentFlags().IntVarP(&paddingBetweenY, "paddingY", "y", paddingBetweenY, "Vertical space between nodes")
 95 | 	rootCmd.PersistentFlags().IntVarP(&boxBorderPadding, "borderPadding", "p", boxBorderPadding, "Padding between text and border")
 96 | 
 97 | 	// Cobra also supports local flags, which will only run
 98 | 	// when this action is called directly.
 99 | 	rootCmd.Flags().StringP("file", "f", "", "Mermaid file to parse (use '-' for stdin)")
100 | }
101 | 


--------------------------------------------------------------------------------
/cmd/mapping_node.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	log "github.com/sirupsen/logrus"
  5 | )
  6 | 
  7 | type node struct {
  8 | 	name           string
  9 | 	drawing        *drawing
 10 | 	drawingCoord   *drawingCoord
 11 | 	gridCoord      *gridCoord
 12 | 	drawn          bool
 13 | 	index          int // Index of the node in the graph.nodes slice
 14 | 	styleClassName string
 15 | 	styleClass     styleClass
 16 | }
 17 | 
 18 | func (n node) String() string {
 19 | 	return n.name
 20 | }
 21 | 
 22 | func (n *node) setCoord(c *drawingCoord) {
 23 | 	n.drawingCoord = c
 24 | }
 25 | 
 26 | func (n *node) setDrawing(g graph) *drawing {
 27 | 	d := drawBox(n, g)
 28 | 	n.drawing = d
 29 | 	return d
 30 | }
 31 | 
 32 | func (g *graph) setColumnWidth(n *node) {
 33 | 	// For every node there are three columns:
 34 | 	// - 2 lines of border
 35 | 	// - 1 line of text
 36 | 	// - 2x padding
 37 | 	// - 2x margin
 38 | 	col1 := 1
 39 | 	col2 := 2*boxBorderPadding + len(n.name)
 40 | 	col3 := 1
 41 | 	colsToBePlaced := []int{col1, col2, col3}
 42 | 	rowsToBePlaced := []int{1, 1 + 2*boxBorderPadding, 1} // Border, padding + line, border
 43 | 
 44 | 	for idx, col := range colsToBePlaced {
 45 | 		// Set new width for column if the size increased
 46 | 		xCoord := n.gridCoord.x + idx
 47 | 		g.columnWidth[xCoord] = Max(g.columnWidth[xCoord], col)
 48 | 	}
 49 | 
 50 | 	for idx, row := range rowsToBePlaced {
 51 | 		// Set new width for column if the size increased
 52 | 		yCoord := n.gridCoord.y + idx
 53 | 		g.rowHeight[yCoord] = Max(g.rowHeight[yCoord], row)
 54 | 	}
 55 | 
 56 | 	// Set padding before node
 57 | 	if n.gridCoord.x > 0 {
 58 | 		g.columnWidth[n.gridCoord.x-1] = g.paddingX // TODO: x2?
 59 | 	}
 60 | 	if n.gridCoord.y > 0 {
 61 | 		basePadding := g.paddingY
 62 | 
 63 | 		// Add extra padding if node is in a subgraph AND has incoming edges from outside
 64 | 		// This accounts for subgraph visual overhead (border, label, padding)
 65 | 		// and allows arrows to continue as | for longer before becoming arrow heads
 66 | 		if g.hasIncomingEdgeFromOutsideSubgraph(n) {
 67 | 			const subgraphOverhead = 4
 68 | 			basePadding += subgraphOverhead
 69 | 			log.Debugf("Adding subgraph overhead of %d to rowHeight before node %s", subgraphOverhead, n.name)
 70 | 		}
 71 | 
 72 | 		// Use Max to preserve the largest padding requirement for this row
 73 | 		// (multiple nodes may share the same Y coordinate)
 74 | 		g.rowHeight[n.gridCoord.y-1] = Max(g.rowHeight[n.gridCoord.y-1], basePadding)
 75 | 	}
 76 | }
 77 | 
 78 | func (g *graph) increaseGridSizeForPath(path []gridCoord) {
 79 | 	for _, c := range path {
 80 | 		if _, exists := g.columnWidth[c.x]; !exists {
 81 | 			g.columnWidth[c.x] = g.paddingX / 2
 82 | 		}
 83 | 		if _, exists := g.rowHeight[c.y]; !exists {
 84 | 			g.rowHeight[c.y] = g.paddingY / 2
 85 | 		}
 86 | 	}
 87 | }
 88 | 
 89 | func (g *graph) reserveSpotInGrid(n *node, requestedCoord *gridCoord) *gridCoord {
 90 | 	if g.grid[*requestedCoord] != nil {
 91 | 		log.Debugf("Coord %d,%d is already taken", requestedCoord.x, requestedCoord.y)
 92 | 		// Next column is 4 coords further. This is because every node is 3 coords wide + 1 coord inbetween.
 93 | 		if graphDirection == "LR" {
 94 | 			return g.reserveSpotInGrid(n, &gridCoord{x: requestedCoord.x, y: requestedCoord.y + 4})
 95 | 		} else {
 96 | 			return g.reserveSpotInGrid(n, &gridCoord{x: requestedCoord.x + 4, y: requestedCoord.y})
 97 | 		}
 98 | 	}
 99 | 	// Reserve border + middle + border for node
100 | 	log.Debugf("Reserving coord %v for node %v", requestedCoord, n)
101 | 	for x := 0; x < 3; x++ {
102 | 		for y := 0; y < 3; y++ {
103 | 			reservedCoord := gridCoord{x: requestedCoord.x + x, y: requestedCoord.y + y}
104 | 			g.grid[reservedCoord] = n
105 | 		}
106 | 	}
107 | 	n.gridCoord = requestedCoord
108 | 	return requestedCoord
109 | }
110 | 


--------------------------------------------------------------------------------
/internal/diagram/testutil/testutil.go:
--------------------------------------------------------------------------------
  1 | package testutil
  2 | 
  3 | import (
  4 | 	"bufio"
  5 | 	"fmt"
  6 | 	"os"
  7 | 	"regexp"
  8 | 	"strconv"
  9 | 	"strings"
 10 | )
 11 | 
 12 | // TestCase represents a test case for diagram rendering.
 13 | // It contains the input Mermaid syntax and expected output.
 14 | type TestCase struct {
 15 | 	Mermaid  string
 16 | 	Expected string
 17 | 	PaddingX int
 18 | 	PaddingY int
 19 | }
 20 | 
 21 | // ReadTestCase reads a test case file with optional padding configuration.
 22 | // File format:
 23 | //
 24 | //	[paddingX = N]  // optional
 25 | //	[paddingY = N]  // optional
 26 | //	<mermaid code>
 27 | //	---
 28 | //	<expected output>
 29 | //
 30 | // For sequence diagrams, use ReadSequenceTestCase which doesn't support padding config.
 31 | func ReadTestCase(filePath string) (*TestCase, error) {
 32 | 	tc := &TestCase{PaddingX: 5, PaddingY: 5}
 33 | 
 34 | 	file, err := os.Open(filePath)
 35 | 	if err != nil {
 36 | 		return nil, err
 37 | 	}
 38 | 	defer file.Close()
 39 | 
 40 | 	scanner := bufio.NewScanner(file)
 41 | 	var mermaid, expected strings.Builder
 42 | 	inMermaid := true
 43 | 	mermaidStarted := false
 44 | 	paddingRegex := regexp.MustCompile(`^(?i)(padding[xy])\s*=\s*(\d+)\s*$`)
 45 | 
 46 | 	for scanner.Scan() {
 47 | 		line := scanner.Text()
 48 | 		if line == "---" {
 49 | 			inMermaid = false
 50 | 			continue
 51 | 		}
 52 | 		if inMermaid {
 53 | 			trimmed := strings.TrimSpace(line)
 54 | 			if !mermaidStarted {
 55 | 				if trimmed == "" {
 56 | 					continue
 57 | 				}
 58 | 				if match := paddingRegex.FindStringSubmatch(trimmed); match != nil {
 59 | 					paddingValue, convErr := strconv.Atoi(match[2])
 60 | 					if convErr != nil {
 61 | 						return nil, convErr
 62 | 					}
 63 | 					if strings.EqualFold(match[1], "paddingX") {
 64 | 						tc.PaddingX = paddingValue
 65 | 					} else {
 66 | 						tc.PaddingY = paddingValue
 67 | 					}
 68 | 					continue
 69 | 				}
 70 | 			}
 71 | 			mermaidStarted = true
 72 | 			mermaid.WriteString(line + "\n")
 73 | 		} else {
 74 | 			expected.WriteString(line + "\n")
 75 | 		}
 76 | 	}
 77 | 
 78 | 	tc.Mermaid = mermaid.String()
 79 | 	tc.Expected = strings.TrimSuffix(expected.String(), "\n")
 80 | 	return tc, scanner.Err()
 81 | }
 82 | 
 83 | // ReadSequenceTestCase reads a test case file for sequence diagrams.
 84 | // Uses more precise "\n---\n" separator to avoid matching "---" in ASCII box borders.
 85 | // File format:
 86 | //
 87 | //	<mermaid code>
 88 | //	---
 89 | //	<expected output>
 90 | func ReadSequenceTestCase(filePath string) (*TestCase, error) {
 91 | 	content, err := os.ReadFile(filePath)
 92 | 	if err != nil {
 93 | 		return nil, err
 94 | 	}
 95 | 
 96 | 	// Split on "\n---\n" to avoid matching "---" in ASCII box borders
 97 | 	parts := strings.Split(string(content), "\n---\n")
 98 | 	if len(parts) != 2 {
 99 | 		return nil, fmt.Errorf("test case file must have exactly one '---' separator (on its own line)")
100 | 	}
101 | 
102 | 	return &TestCase{
103 | 		Mermaid:  strings.TrimSpace(parts[0]),
104 | 		Expected: strings.TrimSpace(parts[1]),
105 | 		PaddingX: 5,
106 | 		PaddingY: 5,
107 | 	}, nil
108 | }
109 | 
110 | // NormalizeWhitespace removes trailing spaces and empty lines for comparison.
111 | // This is useful for comparing expected vs actual output where trailing whitespace doesn't matter.
112 | func NormalizeWhitespace(s string) string {
113 | 	lines := strings.Split(s, "\n")
114 | 	var normalized []string
115 | 	for _, line := range lines {
116 | 		trimmed := strings.TrimRight(line, " ")
117 | 		if trimmed != "" || len(normalized) > 0 {
118 | 			normalized = append(normalized, trimmed)
119 | 		}
120 | 	}
121 | 	// Remove trailing empty lines
122 | 	for len(normalized) > 0 && normalized[len(normalized)-1] == "" {
123 | 		normalized = normalized[:len(normalized)-1]
124 | 	}
125 | 	return strings.Join(normalized, "\n")
126 | }
127 | 
128 | // VisualizeWhitespace replaces spaces with · for debugging test failures.
129 | func VisualizeWhitespace(s string) string {
130 | 	return strings.ReplaceAll(s, " ", "·")
131 | }
132 | 


--------------------------------------------------------------------------------
/cmd/graph_test.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"os"
  5 | 	"path/filepath"
  6 | 	"strings"
  7 | 	"testing"
  8 | 
  9 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
 10 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram/testutil"
 11 | 	log "github.com/sirupsen/logrus"
 12 | )
 13 | 
 14 | func verifyMap(t *testing.T, testCaseFile string, useAscii bool) {
 15 | 	tc, err := testutil.ReadTestCase(testCaseFile)
 16 | 	if err != nil {
 17 | 		t.Fatalf("Failed to read test case file: %v", err)
 18 | 	}
 19 | 
 20 | 	properties, err := mermaidFileToMap(tc.Mermaid, "cli")
 21 | 	if err != nil {
 22 | 		log.Fatal("Failed to parse mermaid: ", err)
 23 | 	}
 24 | 	properties.paddingX = tc.PaddingX
 25 | 	properties.paddingY = tc.PaddingY
 26 | 	properties.useAscii = useAscii
 27 | 	actualMap := drawMap(properties)
 28 | 	if tc.Expected != actualMap {
 29 | 		expectedWithSpaces := testutil.VisualizeWhitespace(tc.Expected)
 30 | 		actualWithSpaces := testutil.VisualizeWhitespace(actualMap)
 31 | 		t.Errorf("Map didn't match actual map\nExpected:\n%v\nActual:\n%v", expectedWithSpaces, actualWithSpaces)
 32 | 	}
 33 | }
 34 | 
 35 | func TestASCII(t *testing.T) {
 36 | 	dir := "testdata/ascii"
 37 | 	files, err := os.ReadDir(dir)
 38 | 	if err != nil {
 39 | 		t.Fatalf("Failed to read directory %s: %v", dir, err)
 40 | 	}
 41 | 
 42 | 	for _, file := range files {
 43 | 		if !file.IsDir() && strings.HasSuffix(file.Name(), ".txt") {
 44 | 			t.Run(file.Name(), func(t *testing.T) {
 45 | 				verifyMap(t, filepath.Join(dir, file.Name()), true)
 46 | 			})
 47 | 		}
 48 | 	}
 49 | }
 50 | 
 51 | func TestExtendedChars(t *testing.T) {
 52 | 	dir := "testdata/extended-chars"
 53 | 	files, err := os.ReadDir(dir)
 54 | 	if err != nil {
 55 | 		t.Fatalf("Failed to read directory %s: %v", dir, err)
 56 | 	}
 57 | 
 58 | 	for _, file := range files {
 59 | 		if !file.IsDir() && strings.HasSuffix(file.Name(), ".txt") {
 60 | 			t.Run(file.Name(), func(t *testing.T) {
 61 | 				verifyMap(t, filepath.Join(dir, file.Name()), false)
 62 | 			})
 63 | 		}
 64 | 	}
 65 | }
 66 | 
 67 | // TestGraphUseAsciiConfig tests that RenderDiagram respects config.UseAscii for graphs
 68 | func TestGraphUseAsciiConfig(t *testing.T) {
 69 | 	mermaidInput := `graph LR
 70 | A --> B`
 71 | 
 72 | 	// Test with UseAscii = true (should produce ASCII output)
 73 | 	asciiConfig := &diagram.Config{
 74 | 		UseAscii:         true,
 75 | 		BoxBorderPadding: 1,
 76 | 		PaddingBetweenX:  5,
 77 | 		PaddingBetweenY:  5,
 78 | 		GraphDirection:   "LR",
 79 | 		StyleType:        "cli",
 80 | 	}
 81 | 	asciiOutput, err := RenderDiagram(mermaidInput, asciiConfig)
 82 | 	if err != nil {
 83 | 		t.Fatalf("Failed to render with ASCII config: %v", err)
 84 | 	}
 85 | 
 86 | 	// Test with UseAscii = false (should produce Unicode output)
 87 | 	unicodeConfig := &diagram.Config{
 88 | 		UseAscii:         false,
 89 | 		BoxBorderPadding: 1,
 90 | 		PaddingBetweenX:  5,
 91 | 		PaddingBetweenY:  5,
 92 | 		GraphDirection:   "LR",
 93 | 		StyleType:        "cli",
 94 | 	}
 95 | 	unicodeOutput, err := RenderDiagram(mermaidInput, unicodeConfig)
 96 | 	if err != nil {
 97 | 		t.Fatalf("Failed to render with Unicode config: %v", err)
 98 | 	}
 99 | 
100 | 	// Verify outputs are different
101 | 	if asciiOutput == unicodeOutput {
102 | 		t.Errorf("ASCII and Unicode outputs should be different, but they were identical:\n%s", asciiOutput)
103 | 	}
104 | 
105 | 	// Verify ASCII output contains ASCII characters (not Unicode box-drawing)
106 | 	if strings.Contains(asciiOutput, "┌") || strings.Contains(asciiOutput, "─") || strings.Contains(asciiOutput, "│") {
107 | 		t.Errorf("ASCII output should not contain Unicode box-drawing characters, but found:\n%s", asciiOutput)
108 | 	}
109 | 
110 | 	// Verify Unicode output contains Unicode characters
111 | 	if !strings.Contains(unicodeOutput, "┌") && !strings.Contains(unicodeOutput, "─") && !strings.Contains(unicodeOutput, "│") {
112 | 		t.Errorf("Unicode output should contain Unicode box-drawing characters, but found:\n%s", unicodeOutput)
113 | 	}
114 | }
115 | 
116 | // Sequence diagram tests moved to sequence_test.go
117 | 


--------------------------------------------------------------------------------
/cmd/mapping_edge.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 
  6 | 	log "github.com/sirupsen/logrus"
  7 | )
  8 | 
  9 | type edge struct {
 10 | 	from      *node
 11 | 	to        *node
 12 | 	text      string
 13 | 	path      []gridCoord
 14 | 	labelLine []gridCoord
 15 | 	startDir  direction
 16 | 	endDir    direction
 17 | }
 18 | 
 19 | func (g *graph) determinePath(e *edge) {
 20 | 	// Get both paths and use least amount of steps
 21 | 	var preferredPath, alternativePath []gridCoord
 22 | 	var from, to gridCoord
 23 | 	var err error
 24 | 	preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir := determineStartAndEndDir(e)
 25 | 
 26 | 	from = e.from.gridCoord.Direction(preferredDir)
 27 | 	to = e.to.gridCoord.Direction(preferredOppositeDir)
 28 | 	log.Debugf("Determining preferred path from %v (direction %v) to %v (direction %v)", *e.from, preferredDir, *e.to, preferredOppositeDir)
 29 | 
 30 | 	// Get preferred path
 31 | 	preferredPath, err = g.getPath(from, to)
 32 | 	if err != nil {
 33 | 		fmt.Printf("Error getting path from %v to %v: %v", from, to, err)
 34 | 		// This is a big assumption, but if we can't get the preferred path, we assume the alternative path is better
 35 | 		e.startDir = alternativeDir
 36 | 		e.endDir = alternativeOppositeDir
 37 | 		e.path = alternativePath
 38 | 		return
 39 | 	}
 40 | 	preferredPath = mergePath(preferredPath)
 41 | 
 42 | 	// Alternative path
 43 | 	from = e.from.gridCoord.Direction(alternativeDir)
 44 | 	to = e.to.gridCoord.Direction(alternativeOppositeDir)
 45 | 	log.Debugf("Determining alternative path from %v (direction %v) to %v (direction %v)", *e.from, alternativeDir, *e.to, alternativeOppositeDir)
 46 | 
 47 | 	alternativePath, err = g.getPath(from, to)
 48 | 	if err != nil {
 49 | 		fmt.Printf("Error getting path from %v to %v: %v", from, to, err)
 50 | 		e.startDir = preferredDir
 51 | 		e.endDir = preferredOppositeDir
 52 | 		e.path = preferredPath
 53 | 	}
 54 | 	alternativePath = mergePath(alternativePath)
 55 | 
 56 | 	nrStepsPreferred := len(preferredPath)
 57 | 	nrStepsAlternative := len(alternativePath)
 58 | 	if nrStepsPreferred <= nrStepsAlternative {
 59 | 		log.Debugf("Using preferred path with %v steps instead of alternative path with %v steps", nrStepsPreferred, nrStepsAlternative)
 60 | 		e.startDir = preferredDir
 61 | 		e.endDir = preferredOppositeDir
 62 | 		e.path = preferredPath
 63 | 	} else {
 64 | 		log.Debugf("Using alternative path with %v steps instead of alternative path with %v steps", nrStepsAlternative, nrStepsPreferred)
 65 | 		e.startDir = alternativeDir
 66 | 		e.endDir = alternativeOppositeDir
 67 | 		e.path = alternativePath
 68 | 	}
 69 | }
 70 | 
 71 | func (g *graph) determineLabelLine(e *edge) {
 72 | 	// What line on the path should the label be placed?
 73 | 	lenLabel := len(e.text)
 74 | 	if lenLabel == 0 {
 75 | 		return
 76 | 	}
 77 | 	prevStep := e.path[0]
 78 | 	var largestLineSize int
 79 | 	// Init to first line if we find nothing else
 80 | 	largestLine := []gridCoord{prevStep, e.path[1]}
 81 | 	largestLineSize = 0
 82 | 	for _, step := range e.path[1:] {
 83 | 		line := []gridCoord{gridCoord(prevStep), gridCoord(step)}
 84 | 		lineWidth := g.calculateLineWidth(line)
 85 | 		if lineWidth >= lenLabel {
 86 | 			largestLine = line
 87 | 			break
 88 | 		} else if lineWidth > largestLineSize {
 89 | 			largestLineSize = lineWidth
 90 | 			largestLine = line
 91 | 		}
 92 | 		prevStep = step
 93 | 	}
 94 | 
 95 | 	var maxX, minX int
 96 | 	if largestLine[0].x > largestLine[1].x {
 97 | 		maxX = largestLine[0].x
 98 | 		minX = largestLine[1].x
 99 | 	} else {
100 | 		maxX = largestLine[1].x
101 | 		minX = largestLine[0].x
102 | 	}
103 | 	middleX := minX + (maxX-minX)/2
104 | 	log.Debugf("Increasing column width for column %v from size %v to %v", middleX, g.columnWidth[middleX], lenLabel+2)
105 | 	g.columnWidth[middleX] = Max(g.columnWidth[middleX], lenLabel+2) // Wrap with dashes + arrowhead
106 | 	log.Debugf("New column sizes: %v", g.columnWidth)
107 | 	e.labelLine = largestLine
108 | }
109 | 
110 | func (g graph) calculateLineWidth(line []gridCoord) int {
111 | 	totalSize := 0
112 | 	for _, c := range line {
113 | 		totalSize += g.columnWidth[c.x]
114 | 	}
115 | 	return totalSize
116 | }
117 | 


--------------------------------------------------------------------------------
/cmd/web.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"net/http"
  6 | 	"os/exec"
  7 | 	"strconv"
  8 | 	"strings"
  9 | 	"sync"
 10 | 
 11 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
 12 | 	log "github.com/sirupsen/logrus"
 13 | 
 14 | 	"github.com/gin-gonic/gin"
 15 | 	"github.com/spf13/cobra"
 16 | )
 17 | 
 18 | // Add the resultCache variable with additional fields
 19 | var (
 20 | 	resultCache = struct {
 21 | 		sync.RWMutex
 22 | 		m map[string]cacheEntry
 23 | 	}{m: make(map[string]cacheEntry)}
 24 | 	maxCacheSize = 10000 // Maximum number of entries in the cache
 25 | )
 26 | 
 27 | type cacheEntry struct {
 28 | 	value string
 29 | }
 30 | 
 31 | var (
 32 | 	gitVersion     string
 33 | 	gitVersionOnce sync.Once
 34 | )
 35 | 
 36 | func init() {
 37 | 	rootCmd.AddCommand(webCmd)
 38 | }
 39 | 
 40 | var webCmd = &cobra.Command{
 41 | 	Use:   "web",
 42 | 	Short: "HTTP server for rendering mermaid diagrams.",
 43 | 	Run: func(cmd *cobra.Command, args []string) {
 44 | 		if Verbose {
 45 | 			log.SetLevel(log.DebugLevel)
 46 | 		} else {
 47 | 			log.SetLevel(log.InfoLevel)
 48 | 		}
 49 | 		r := setupRouter()
 50 | 		// Listen and Server in 0.0.0.0:8080
 51 | 		err := r.Run(":3001")
 52 | 		if err != nil {
 53 | 			panic(err)
 54 | 		}
 55 | 	},
 56 | }
 57 | 
 58 | // Add this function near the top of the file, after the imports
 59 | func getGitVersion() string {
 60 | 	gitVersionOnce.Do(func() {
 61 | 		log.Info("Getting git version")
 62 | 		cmd := exec.Command("git", "describe", "--tags", "--always")
 63 | 		output, err := cmd.Output()
 64 | 		if err != nil {
 65 | 			log.Warnf("Failed to get git version: %v", err)
 66 | 			gitVersion = "unknown"
 67 | 		} else {
 68 | 			gitVersion = strings.TrimSpace(string(output))
 69 | 		}
 70 | 	})
 71 | 	return gitVersion
 72 | }
 73 | 
 74 | func setupRouter() *gin.Engine {
 75 | 	r := gin.Default()
 76 | 
 77 | 	r.LoadHTMLGlob("templates/*")
 78 | 	r.Static("/static", "./static")
 79 | 	r.GET("/", func(c *gin.Context) {
 80 | 		c.HTML(http.StatusOK, "index.tmpl", gin.H{
 81 | 			"Version": getGitVersion(),
 82 | 		})
 83 | 	})
 84 | 
 85 | 	r.POST("/", renderMermaid)
 86 | 
 87 | 	// Backwards compatibility
 88 | 	r.POST("/generate", renderMermaid)
 89 | 
 90 | 	return r
 91 | }
 92 | 
 93 | func renderMermaid(c *gin.Context) {
 94 | 	mermaidString := c.PostForm("mermaid")
 95 | 	// Parse xPadding and yPadding as integers
 96 | 	xPadding := c.PostForm("xPadding")
 97 | 	if xPadding != "" {
 98 | 		if padding, err := strconv.Atoi(xPadding); err == nil {
 99 | 			paddingBetweenX = padding
100 | 		} else {
101 | 			log.Warnf("Invalid xPadding value: %s", xPadding)
102 | 		}
103 | 	}
104 | 
105 | 	yPadding := c.PostForm("yPadding")
106 | 	if yPadding != "" {
107 | 		if padding, err := strconv.Atoi(yPadding); err == nil {
108 | 			paddingBetweenY = padding
109 | 		} else {
110 | 			log.Warnf("Invalid yPadding value: %s", yPadding)
111 | 		}
112 | 	}
113 | 	useExtendedCharsData := c.PostForm("useExtendedChars")
114 | 	useAsciiMode := useExtendedCharsData == ""
115 | 	log.Debugf("Received input %s", c.Request.PostForm.Encode())
116 | 
117 | 	// Create a cache key using the input parameters
118 | 	cacheKey := mermaidString + "x" + xPadding + "y" + yPadding + "e" + useExtendedCharsData
119 | 
120 | 	// Check if the result is already in the cache
121 | 	resultCache.RLock()
122 | 	entry, found := resultCache.m[cacheKey]
123 | 	resultCache.RUnlock()
124 | 
125 | 	if found {
126 | 		log.Infof("Cache hit for key: %s", cacheKey)
127 | 		c.String(http.StatusOK, entry.value)
128 | 		return
129 | 	}
130 | 
131 | 	// Create render configuration
132 | 	config, err := diagram.NewWebConfig(
133 | 		useAsciiMode,
134 | 		boxBorderPadding,
135 | 		paddingBetweenX,
136 | 		paddingBetweenY,
137 | 	)
138 | 	if err != nil {
139 | 		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Invalid configuration: %v", err)})
140 | 		return
141 | 	}
142 | 	config.Verbose = Verbose // Allow verbose logging in web mode if enabled
143 | 	result, err := RenderDiagram(mermaidString, config)
144 | 	if err != nil {
145 | 		log.Errorf("Rendering failed: %v", err)
146 | 		c.String(http.StatusBadRequest, fmt.Sprintf("Failed to render diagram: %v", err))
147 | 		return
148 | 	}
149 | 
150 | 	// Store the result in the cache
151 | 	resultCache.Lock()
152 | 	if len(resultCache.m) >= maxCacheSize {
153 | 		log.Infof("Cache is full, removing oldest entry")
154 | 		// Remove a random entry if cache is full
155 | 		for k := range resultCache.m {
156 | 			delete(resultCache.m, k)
157 | 			break
158 | 		}
159 | 	}
160 | 	resultCache.m[cacheKey] = cacheEntry{
161 | 		value: result,
162 | 	}
163 | 	resultCache.Unlock()
164 | 
165 | 	c.String(http.StatusOK, result)
166 | }
167 | 


--------------------------------------------------------------------------------
/cmd/direction.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | type direction genericCoord
  4 | 
  5 | var (
  6 | 	Up         = direction{1, 0}
  7 | 	Down       = direction{1, 2}
  8 | 	Left       = direction{0, 1}
  9 | 	Right      = direction{2, 1}
 10 | 	UpperRight = direction{2, 0}
 11 | 	UpperLeft  = direction{0, 0}
 12 | 	LowerRight = direction{2, 2}
 13 | 	LowerLeft  = direction{0, 2}
 14 | 	Middle     = direction{1, 1}
 15 | )
 16 | 
 17 | func (d direction) getOpposite() direction {
 18 | 	switch d {
 19 | 	case Up:
 20 | 		return Down
 21 | 	case Down:
 22 | 		return Up
 23 | 	case Left:
 24 | 		return Right
 25 | 	case Right:
 26 | 		return Left
 27 | 	case UpperRight:
 28 | 		return LowerLeft
 29 | 	case UpperLeft:
 30 | 		return LowerRight
 31 | 	case LowerRight:
 32 | 		return UpperLeft
 33 | 	case LowerLeft:
 34 | 		return UpperRight
 35 | 	case Middle:
 36 | 		return Middle
 37 | 	}
 38 | 	panic("Unknown direction")
 39 | }
 40 | 
 41 | func (c gridCoord) Direction(dir direction) gridCoord {
 42 | 	return gridCoord{x: c.x + dir.x, y: c.y + dir.y}
 43 | }
 44 | func (c drawingCoord) Direction(dir direction) drawingCoord {
 45 | 	return drawingCoord{x: c.x + dir.x, y: c.y + dir.y}
 46 | }
 47 | 
 48 | func selfReferenceDirection(e *edge) (direction, direction, direction, direction) {
 49 | 	if graphDirection == "LR" {
 50 | 		return Right, Down, Down, Right
 51 | 	}
 52 | 	return Down, Right, Right, Down
 53 | }
 54 | 
 55 | func determineStartAndEndDir(e *edge) (direction, direction, direction, direction) {
 56 | 	if e.from == e.to {
 57 | 		return selfReferenceDirection(e)
 58 | 	}
 59 | 	d := determineDirection(genericCoord(*e.from.gridCoord), genericCoord(*e.to.gridCoord))
 60 | 	var preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir direction
 61 | 
 62 | 	// Check if this is a backwards flowing edge
 63 | 	isBackwards := false
 64 | 	if graphDirection == "LR" {
 65 | 		// In LR mode, backwards flow is when edge goes from right to left (Left direction)
 66 | 		isBackwards = (d == Left || d == UpperLeft || d == LowerLeft)
 67 | 	} else { // TD mode
 68 | 		// In TD mode, backwards flow is when edge goes from bottom to top (Up direction)
 69 | 		isBackwards = (d == Up || d == UpperLeft || d == UpperRight)
 70 | 	}
 71 | 
 72 | 	// LR: prefer vertical over horizontal
 73 | 	// TD: prefer horizontal over vertical
 74 | 	// TODO: This causes some squirmy lines if the corner spot is already occupied.
 75 | 	// For backwards edges, use special start positions: Down in LR mode, Right in TD mode
 76 | 	switch d {
 77 | 	case LowerRight:
 78 | 		if graphDirection == "LR" {
 79 | 			preferredDir = Down
 80 | 			preferredOppositeDir = Left
 81 | 			alternativeDir = Right
 82 | 			alternativeOppositeDir = Up
 83 | 		} else {
 84 | 			preferredDir = Right
 85 | 			preferredOppositeDir = Up
 86 | 			alternativeDir = Down
 87 | 			alternativeOppositeDir = Left
 88 | 		}
 89 | 	case UpperRight:
 90 | 		if graphDirection == "LR" {
 91 | 			preferredDir = Up
 92 | 			preferredOppositeDir = Left
 93 | 			alternativeDir = Right
 94 | 			alternativeOppositeDir = Down
 95 | 		} else {
 96 | 			preferredDir = Right
 97 | 			preferredOppositeDir = Down
 98 | 			alternativeDir = Up
 99 | 			alternativeOppositeDir = Left
100 | 		}
101 | 	case LowerLeft:
102 | 		if graphDirection == "LR" {
103 | 			// Backwards flow in LR mode - start from Down, arrive at Down
104 | 			preferredDir = Down
105 | 			preferredOppositeDir = Down // Edge goes to bottom of destination
106 | 			alternativeDir = Left
107 | 			alternativeOppositeDir = Up
108 | 		} else {
109 | 			preferredDir = Left
110 | 			preferredOppositeDir = Up
111 | 			alternativeDir = Down
112 | 			alternativeOppositeDir = Right
113 | 		}
114 | 	case UpperLeft:
115 | 		if graphDirection == "LR" {
116 | 			// Backwards flow in LR mode - start from Down, arrive at Down
117 | 			preferredDir = Down
118 | 			preferredOppositeDir = Down // Edge goes to bottom of destination
119 | 			alternativeDir = Left
120 | 			alternativeOppositeDir = Down
121 | 		} else {
122 | 			// Backwards flow in TD mode - start from Right, arrive at Right
123 | 			preferredDir = Right
124 | 			preferredOppositeDir = Right // Edge goes to right of destination
125 | 			alternativeDir = Up
126 | 			alternativeOppositeDir = Right
127 | 		}
128 | 	default:
129 | 		// Handle direct backwards flow cases
130 | 		if isBackwards {
131 | 			if graphDirection == "LR" && d == Left {
132 | 				// Direct left flow in LR mode - start from Down, arrive at Down
133 | 				preferredDir = Down
134 | 				preferredOppositeDir = Down // Edge goes to bottom of destination
135 | 				alternativeDir = Left
136 | 				alternativeOppositeDir = Right
137 | 			} else if graphDirection == "TD" && d == Up {
138 | 				// Direct up flow in TD mode - start from Right, arrive at Right
139 | 				preferredDir = Right
140 | 				preferredOppositeDir = Right // Edge goes to right of destination
141 | 				alternativeDir = Up
142 | 				alternativeOppositeDir = Down
143 | 			} else {
144 | 				preferredDir = d
145 | 				preferredOppositeDir = preferredDir.getOpposite()
146 | 				alternativeDir = d
147 | 				alternativeOppositeDir = preferredOppositeDir
148 | 			}
149 | 		} else {
150 | 			preferredDir = d
151 | 			preferredOppositeDir = preferredDir.getOpposite()
152 | 			// TODO: just return null and don't calculate alternative path
153 | 			alternativeDir = d
154 | 			alternativeOppositeDir = preferredOppositeDir
155 | 		}
156 | 	}
157 | 	return preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir
158 | }
159 | 


--------------------------------------------------------------------------------
/internal/sequence/parser.go:
--------------------------------------------------------------------------------
  1 | package sequence
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"regexp"
  6 | 	"strings"
  7 | 
  8 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
  9 | )
 10 | 
 11 | const (
 12 | 	SequenceDiagramKeyword = "sequenceDiagram"
 13 | 	SolidArrowSyntax       = "->>"
 14 | 	DottedArrowSyntax      = "-->>"
 15 | )
 16 | 
 17 | var (
 18 | 	// participantRegex matches participant declarations: participant [ID] [as Label]
 19 | 	participantRegex = regexp.MustCompile(`^\s*participant\s+(?:"([^"]+)"|(\S+))(?:\s+as\s+(.+))?$`)
 20 | 
 21 | 	// messageRegex matches messages: [From]->>[To]: [Label]
 22 | 	messageRegex = regexp.MustCompile(`^\s*(?:"([^"]+)"|([^\s\->]+))\s*(-->>|->>)\s*(?:"([^"]+)"|([^\s\->]+))\s*:\s*(.*)$`)
 23 | )
 24 | 
 25 | // SequenceDiagram represents a parsed sequence diagram.
 26 | type SequenceDiagram struct {
 27 | 	Participants []*Participant
 28 | 	Messages     []*Message
 29 | }
 30 | 
 31 | type Participant struct {
 32 | 	ID    string
 33 | 	Label string
 34 | 	Index int
 35 | }
 36 | 
 37 | type Message struct {
 38 | 	From      *Participant
 39 | 	To        *Participant
 40 | 	Label     string
 41 | 	ArrowType ArrowType
 42 | }
 43 | 
 44 | type ArrowType int
 45 | 
 46 | const (
 47 | 	SolidArrow ArrowType = iota
 48 | 	DottedArrow
 49 | )
 50 | 
 51 | func (a ArrowType) String() string {
 52 | 	switch a {
 53 | 	case SolidArrow:
 54 | 		return "solid"
 55 | 	case DottedArrow:
 56 | 		return "dotted"
 57 | 	default:
 58 | 		return fmt.Sprintf("ArrowType(%d)", a)
 59 | 	}
 60 | }
 61 | 
 62 | func IsSequenceDiagram(input string) bool {
 63 | 	lines := strings.Split(input, "\n")
 64 | 	for _, line := range lines {
 65 | 		trimmed := strings.TrimSpace(line)
 66 | 		if trimmed == "" || strings.HasPrefix(trimmed, "%%") {
 67 | 			continue
 68 | 		}
 69 | 		return strings.HasPrefix(trimmed, SequenceDiagramKeyword)
 70 | 	}
 71 | 	return false
 72 | }
 73 | 
 74 | func Parse(input string) (*SequenceDiagram, error) {
 75 | 	input = strings.TrimSpace(input)
 76 | 	if input == "" {
 77 | 		return nil, fmt.Errorf("empty input")
 78 | 	}
 79 | 
 80 | 	rawLines := diagram.SplitLines(input)
 81 | 	lines := diagram.RemoveComments(rawLines)
 82 | 	if len(lines) == 0 {
 83 | 		return nil, fmt.Errorf("no content found")
 84 | 	}
 85 | 
 86 | 	if !strings.HasPrefix(strings.TrimSpace(lines[0]), SequenceDiagramKeyword) {
 87 | 		return nil, fmt.Errorf("expected %q keyword", SequenceDiagramKeyword)
 88 | 	}
 89 | 	lines = lines[1:]
 90 | 
 91 | 	sd := &SequenceDiagram{
 92 | 		Participants: []*Participant{},
 93 | 		Messages:     []*Message{},
 94 | 	}
 95 | 	participantMap := make(map[string]*Participant)
 96 | 
 97 | 	for i, line := range lines {
 98 | 		trimmed := strings.TrimSpace(line)
 99 | 		if trimmed == "" {
100 | 			continue
101 | 		}
102 | 
103 | 		if matched, err := sd.parseParticipant(trimmed, participantMap); err != nil {
104 | 			return nil, fmt.Errorf("line %d: %w", i+2, err)
105 | 		} else if matched {
106 | 			continue
107 | 		}
108 | 
109 | 		if matched, err := sd.parseMessage(trimmed, participantMap); err != nil {
110 | 			return nil, fmt.Errorf("line %d: %w", i+2, err)
111 | 		} else if matched {
112 | 			continue
113 | 		}
114 | 
115 | 		return nil, fmt.Errorf("line %d: invalid syntax: %q", i+2, trimmed)
116 | 	}
117 | 
118 | 	if len(sd.Participants) == 0 {
119 | 		return nil, fmt.Errorf("no participants found")
120 | 	}
121 | 
122 | 	return sd, nil
123 | }
124 | 
125 | func (sd *SequenceDiagram) parseParticipant(line string, participants map[string]*Participant) (bool, error) {
126 | 	match := participantRegex.FindStringSubmatch(line)
127 | 	if match == nil {
128 | 		return false, nil
129 | 	}
130 | 
131 | 	id := match[2]
132 | 	if match[1] != "" {
133 | 		id = match[1]
134 | 	}
135 | 	label := match[3]
136 | 	if label == "" {
137 | 		label = id
138 | 	}
139 | 	label = strings.Trim(label, `"`)
140 | 
141 | 	if _, exists := participants[id]; exists {
142 | 		return true, fmt.Errorf("duplicate participant %q", id)
143 | 	}
144 | 
145 | 	p := &Participant{
146 | 		ID:    id,
147 | 		Label: label,
148 | 		Index: len(sd.Participants),
149 | 	}
150 | 	sd.Participants = append(sd.Participants, p)
151 | 	participants[id] = p
152 | 	return true, nil
153 | }
154 | 
155 | func (sd *SequenceDiagram) parseMessage(line string, participants map[string]*Participant) (bool, error) {
156 | 	match := messageRegex.FindStringSubmatch(line)
157 | 	if match == nil {
158 | 		return false, nil
159 | 	}
160 | 
161 | 	fromID := match[2]
162 | 	if match[1] != "" {
163 | 		fromID = match[1]
164 | 	}
165 | 
166 | 	arrow := match[3]
167 | 
168 | 	toID := match[5]
169 | 	if match[4] != "" {
170 | 		toID = match[4]
171 | 	}
172 | 
173 | 	label := strings.TrimSpace(match[6])
174 | 
175 | 	from := sd.getParticipant(fromID, participants)
176 | 	to := sd.getParticipant(toID, participants)
177 | 
178 | 	aType := DottedArrow
179 | 	if arrow == SolidArrowSyntax {
180 | 		aType = SolidArrow
181 | 	}
182 | 
183 | 	msg := &Message{
184 | 		From:      from,
185 | 		To:        to,
186 | 		Label:     label,
187 | 		ArrowType: aType,
188 | 	}
189 | 	sd.Messages = append(sd.Messages, msg)
190 | 	return true, nil
191 | }
192 | 
193 | func (sd *SequenceDiagram) getParticipant(id string, participants map[string]*Participant) *Participant {
194 | 	if p, exists := participants[id]; exists {
195 | 		return p
196 | 	}
197 | 
198 | 	p := &Participant{
199 | 		ID:    id,
200 | 		Label: id,
201 | 		Index: len(sd.Participants),
202 | 	}
203 | 	sd.Participants = append(sd.Participants, p)
204 | 	participants[id] = p
205 | 	return p
206 | }
207 | 


--------------------------------------------------------------------------------
/internal/sequence/renderer_test.go:
--------------------------------------------------------------------------------
  1 | package sequence
  2 | 
  3 | import (
  4 | 	"path/filepath"
  5 | 	"runtime"
  6 | 	"strings"
  7 | 	"testing"
  8 | 
  9 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
 10 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram/testutil"
 11 | )
 12 | 
 13 | // getTestDataPath returns the absolute path to testdata directory.
 14 | // This avoids brittle relative paths by using runtime.Caller to find the test file location.
 15 | func getTestDataPath() string {
 16 | 	_, filename, _, _ := runtime.Caller(0)
 17 | 	dir := filepath.Dir(filename)
 18 | 	return filepath.Join(dir, "..", "..", "cmd", "testdata")
 19 | }
 20 | 
 21 | // TestSequenceDiagramRendering tests all sequence diagram test cases with Unicode charset.
 22 | func TestSequenceDiagramRendering(t *testing.T) {
 23 | 	testDataPath := filepath.Join(getTestDataPath(), "sequence")
 24 | 
 25 | 	// Test files - stored in sequence/ directory (Unicode expected output)
 26 | 	testFiles := []string{
 27 | 		"adjacent_participants_communication.txt",
 28 | 		"bidirectional_messages.txt",
 29 | 		"dotted_arrows_only.txt",
 30 | 		"four_participants.txt",
 31 | 		"long_participant_names.txt",
 32 | 		"messages_without_labels.txt",
 33 | 		"multiword_labels.txt",
 34 | 		"self_message.txt",
 35 | 		"simple_two_participants.txt",
 36 | 		"single_message.txt",
 37 | 		"three_participants.txt",
 38 | 	}
 39 | 
 40 | 	for _, testFile := range testFiles {
 41 | 		t.Run(testFile, func(t *testing.T) {
 42 | 			verifySequenceDiagramWithCharset(t, filepath.Join(testDataPath, testFile), false)
 43 | 		})
 44 | 	}
 45 | }
 46 | 
 47 | // TestSequenceDiagramRendering_ASCII tests ASCII rendering with golden files.
 48 | // These golden files ensure ASCII output remains correct and readable.
 49 | func TestSequenceDiagramRendering_ASCII(t *testing.T) {
 50 | 	testDataPath := filepath.Join(getTestDataPath(), "sequence-ascii")
 51 | 
 52 | 	goldenFiles := []string{
 53 | 		"simple_two_participants.txt",
 54 | 		"dotted_arrows_only.txt",
 55 | 		"self_message.txt",
 56 | 		"three_participants.txt",
 57 | 	}
 58 | 
 59 | 	for _, testFile := range goldenFiles {
 60 | 		t.Run(testFile, func(t *testing.T) {
 61 | 			verifySequenceDiagramWithCharset(t, filepath.Join(testDataPath, testFile), true)
 62 | 		})
 63 | 	}
 64 | }
 65 | 
 66 | // TestSequenceDiagramRendering_ASCIISmokeTest verifies ASCII rendering works for all test inputs.
 67 | // This ensures parsing and ASCII rendering don't crash, without requiring golden files for every case.
 68 | func TestSequenceDiagramRendering_ASCIISmokeTest(t *testing.T) {
 69 | 	testDataPath := filepath.Join(getTestDataPath(), "sequence")
 70 | 
 71 | 	testFiles := []string{
 72 | 		"adjacent_participants_communication.txt",
 73 | 		"bidirectional_messages.txt",
 74 | 		"dotted_arrows_only.txt",
 75 | 		"four_participants.txt",
 76 | 		"long_participant_names.txt",
 77 | 		"messages_without_labels.txt",
 78 | 		"multiword_labels.txt",
 79 | 		"self_message.txt",
 80 | 		"simple_two_participants.txt",
 81 | 		"single_message.txt",
 82 | 		"three_participants.txt",
 83 | 	}
 84 | 
 85 | 	for _, testFile := range testFiles {
 86 | 		t.Run(testFile, func(t *testing.T) {
 87 | 			tc, err := testutil.ReadSequenceTestCase(filepath.Join(testDataPath, testFile))
 88 | 			if err != nil {
 89 | 				t.Fatalf("Failed to read test case: %v", err)
 90 | 			}
 91 | 
 92 | 			sd, err := Parse(tc.Mermaid)
 93 | 			if err != nil {
 94 | 				t.Fatalf("Failed to parse: %v", err)
 95 | 			}
 96 | 
 97 | 			config := diagram.NewTestConfig(true, "cli") // ASCII, CLI style
 98 | 
 99 | 			output, err := Render(sd, config)
100 | 			if err != nil {
101 | 				t.Fatalf("Failed to render ASCII: %v", err)
102 | 			}
103 | 
104 | 			// Smoke test - just ensure output is not empty and contains expected elements
105 | 			if len(output) == 0 {
106 | 				t.Error("ASCII output is empty")
107 | 			}
108 | 
109 | 			// Verify all participant labels appear in output
110 | 			for _, p := range sd.Participants {
111 | 				if !strings.Contains(output, p.Label) {
112 | 					t.Errorf("ASCII output missing participant label: %q", p.Label)
113 | 				}
114 | 			}
115 | 
116 | 			// Verify ASCII characters are used (not Unicode box-drawing)
117 | 			if strings.ContainsAny(output, "┌┐└┘├┤┬┴┼│─►◄┈") {
118 | 				t.Error("ASCII output contains Unicode box-drawing characters")
119 | 			}
120 | 		})
121 | 	}
122 | }
123 | 
124 | // verifySequenceDiagramWithCharset verifies a test case with the specified charset.
125 | func verifySequenceDiagramWithCharset(t *testing.T, testCaseFile string, useAscii bool) {
126 | 	tc, err := testutil.ReadSequenceTestCase(testCaseFile)
127 | 	if err != nil {
128 | 		t.Fatalf("Failed to read test case file: %v", err)
129 | 	}
130 | 
131 | 	sd, err := Parse(tc.Mermaid)
132 | 	if err != nil {
133 | 		t.Fatalf("Failed to parse sequence diagram: %v", err)
134 | 	}
135 | 
136 | 	// Create config with specified charset
137 | 	config := diagram.NewTestConfig(useAscii, "cli")
138 | 
139 | 	actual, err := Render(sd, config)
140 | 	if err != nil {
141 | 		t.Fatalf("render error: %v", err)
142 | 	}
143 | 
144 | 	expectedNormalized := testutil.NormalizeWhitespace(tc.Expected)
145 | 	actualNormalized := testutil.NormalizeWhitespace(actual)
146 | 
147 | 	if expectedNormalized != actualNormalized {
148 | 		expectedWithSpaces := testutil.VisualizeWhitespace(expectedNormalized)
149 | 		actualWithSpaces := testutil.VisualizeWhitespace(actualNormalized)
150 | 		t.Errorf("Sequence diagram didn't match\nExpected:\n%v\nActual:\n%v", expectedWithSpaces, actualWithSpaces)
151 | 	}
152 | }
153 | 


--------------------------------------------------------------------------------
/flake.lock:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nodes": {
  3 |     "alex": {
  4 |       "inputs": {
  5 |         "flake-utils": "flake-utils",
  6 |         "nixpkgs": "nixpkgs",
  7 |         "nixpkgs-python": "nixpkgs-python"
  8 |       },
  9 |       "locked": {
 10 |         "lastModified": 1727894075,
 11 |         "narHash": "sha256-2yGczQTBlMkImM95Q7fmrUX16CJ5y1OTe/KlyXwIo8g=",
 12 |         "owner": "AlexanderGrooff",
 13 |         "repo": "nix-flakes",
 14 |         "rev": "248ec1e226de7e3cd86092312910158c1fea3402",
 15 |         "type": "github"
 16 |       },
 17 |       "original": {
 18 |         "owner": "AlexanderGrooff",
 19 |         "repo": "nix-flakes",
 20 |         "type": "github"
 21 |       }
 22 |     },
 23 |     "flake-compat": {
 24 |       "flake": false,
 25 |       "locked": {
 26 |         "lastModified": 1696426674,
 27 |         "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
 28 |         "owner": "edolstra",
 29 |         "repo": "flake-compat",
 30 |         "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
 31 |         "type": "github"
 32 |       },
 33 |       "original": {
 34 |         "owner": "edolstra",
 35 |         "repo": "flake-compat",
 36 |         "type": "github"
 37 |       }
 38 |     },
 39 |     "flake-utils": {
 40 |       "inputs": {
 41 |         "systems": "systems"
 42 |       },
 43 |       "locked": {
 44 |         "lastModified": 1726560853,
 45 |         "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
 46 |         "owner": "numtide",
 47 |         "repo": "flake-utils",
 48 |         "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
 49 |         "type": "github"
 50 |       },
 51 |       "original": {
 52 |         "owner": "numtide",
 53 |         "repo": "flake-utils",
 54 |         "type": "github"
 55 |       }
 56 |     },
 57 |     "flake-utils_2": {
 58 |       "inputs": {
 59 |         "systems": "systems_2"
 60 |       },
 61 |       "locked": {
 62 |         "lastModified": 1726560853,
 63 |         "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
 64 |         "owner": "numtide",
 65 |         "repo": "flake-utils",
 66 |         "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
 67 |         "type": "github"
 68 |       },
 69 |       "original": {
 70 |         "id": "flake-utils",
 71 |         "type": "indirect"
 72 |       }
 73 |     },
 74 |     "nixpkgs": {
 75 |       "locked": {
 76 |         "lastModified": 1727893769,
 77 |         "narHash": "sha256-RQIsGOy+7VzPJ4eHS2UENKGgGnW6WXQJqm+8d7BsRKc=",
 78 |         "owner": "NixOS",
 79 |         "repo": "nixpkgs",
 80 |         "rev": "bc63f402fdf4ad861b18746174d4e1fd37fcc4b0",
 81 |         "type": "github"
 82 |       },
 83 |       "original": {
 84 |         "owner": "NixOS",
 85 |         "repo": "nixpkgs",
 86 |         "type": "github"
 87 |       }
 88 |     },
 89 |     "nixpkgs-python": {
 90 |       "inputs": {
 91 |         "flake-compat": "flake-compat",
 92 |         "nixpkgs": "nixpkgs_2"
 93 |       },
 94 |       "locked": {
 95 |         "lastModified": 1722978926,
 96 |         "narHash": "sha256-sqOOEaKJJSUFBzag/cGeeXV491TrrVFY3DFBs1w20V8=",
 97 |         "owner": "cachix",
 98 |         "repo": "nixpkgs-python",
 99 |         "rev": "7c550bca7e6cf95898e32eb2173efe7ebb447460",
100 |         "type": "github"
101 |       },
102 |       "original": {
103 |         "owner": "cachix",
104 |         "repo": "nixpkgs-python",
105 |         "type": "github"
106 |       }
107 |     },
108 |     "nixpkgs_2": {
109 |       "locked": {
110 |         "lastModified": 1719253556,
111 |         "narHash": "sha256-A/76RFUVxZ/7Y8+OMVL1Lc8LRhBxZ8ZE2bpMnvZ1VpY=",
112 |         "owner": "NixOS",
113 |         "repo": "nixpkgs",
114 |         "rev": "fc07dc3bdf2956ddd64f24612ea7fc894933eb2e",
115 |         "type": "github"
116 |       },
117 |       "original": {
118 |         "owner": "NixOS",
119 |         "ref": "nixos-24.05",
120 |         "repo": "nixpkgs",
121 |         "type": "github"
122 |       }
123 |     },
124 |     "nixpkgs_3": {
125 |       "locked": {
126 |         "lastModified": 1727811607,
127 |         "narHash": "sha256-2ByOBflaIUJKeF9q6efVcYHljZXGZ7MnCWtseRvmpm8=",
128 |         "owner": "NixOS",
129 |         "repo": "nixpkgs",
130 |         "rev": "1839883cd0068572aed75fb9442b508bbd9ef09c",
131 |         "type": "github"
132 |       },
133 |       "original": {
134 |         "id": "nixpkgs",
135 |         "type": "indirect"
136 |       }
137 |     },
138 |     "root": {
139 |       "inputs": {
140 |         "alex": "alex",
141 |         "flake-utils": "flake-utils_2",
142 |         "nixpkgs": "nixpkgs_3"
143 |       }
144 |     },
145 |     "systems": {
146 |       "locked": {
147 |         "lastModified": 1681028828,
148 |         "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
149 |         "owner": "nix-systems",
150 |         "repo": "default",
151 |         "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
152 |         "type": "github"
153 |       },
154 |       "original": {
155 |         "owner": "nix-systems",
156 |         "repo": "default",
157 |         "type": "github"
158 |       }
159 |     },
160 |     "systems_2": {
161 |       "locked": {
162 |         "lastModified": 1681028828,
163 |         "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
164 |         "owner": "nix-systems",
165 |         "repo": "default",
166 |         "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
167 |         "type": "github"
168 |       },
169 |       "original": {
170 |         "owner": "nix-systems",
171 |         "repo": "default",
172 |         "type": "github"
173 |       }
174 |     }
175 |   },
176 |   "root": "root",
177 |   "version": 7
178 | }
179 | 


--------------------------------------------------------------------------------
/static/script.js:
--------------------------------------------------------------------------------
  1 | // Initialize slider values on page load
  2 | function initializeSliderValues() {
  3 |     const sliders = document.querySelectorAll('input[type="range"]');
  4 |     sliders.forEach(slider => {
  5 |         updateSliderValue(slider);
  6 |     });
  7 | }
  8 | 
  9 | // Update slider value display
 10 | function updateSliderValue(slider) {
 11 |     const container = slider.closest('.slider-container');
 12 |     if (container) {
 13 |         const valueDisplay = container.querySelector('.slider-value');
 14 |         if (valueDisplay) {
 15 |             valueDisplay.textContent = slider.value;
 16 |         }
 17 |     }
 18 | }
 19 | 
 20 | // Set example mermaid code
 21 | function setExample(example) {
 22 |     const textarea = document.querySelector('textarea[name="mermaid"]');
 23 |     if (textarea) {
 24 |         textarea.value = example;
 25 |         // Trigger HTMX update by dispatching both input and change events
 26 |         textarea.dispatchEvent(new Event('input', { bubbles: true }));
 27 |         textarea.dispatchEvent(new Event('change', { bubbles: true }));
 28 |         // Also trigger HTMX directly if available
 29 |         if (window.htmx) {
 30 |             htmx.trigger(textarea, 'changed');
 31 |         }
 32 |     }
 33 | }
 34 | 
 35 | // Handle HTMX before swap to preserve whitespace and HTML
 36 | document.addEventListener('DOMContentLoaded', function() {
 37 |     initializeSliderValues();
 38 |     
 39 |     // Fix for preserving leading whitespace in HTMX responses
 40 |     document.body.addEventListener('htmx:beforeSwap', function(evt) {
 41 |         if (evt.detail.target.id === 'result-code') {
 42 |             // Don't use default swap behavior
 43 |             evt.preventDefault();
 44 |             
 45 |             // Get the response
 46 |             let content = evt.detail.xhr.responseText;
 47 |             
 48 |             // Check if the content has HTML color spans
 49 |             if (content.includes('<span')) {
 50 |                 // For colored content, use innerHTML
 51 |                 evt.detail.target.innerHTML = content;
 52 |             } else {
 53 |                 // For plain text, use textContent to preserve everything exactly
 54 |                 evt.detail.target.textContent = content;
 55 |             }
 56 |         }
 57 |     });
 58 | 
 59 |     // Add loading state to form during HTMX requests
 60 |     const form = document.querySelector('form');
 61 |     if (form) {
 62 |         form.addEventListener('htmx:beforeRequest', function() {
 63 |             form.classList.add('loading');
 64 |         });
 65 |         
 66 |         form.addEventListener('htmx:afterRequest', function() {
 67 |             form.classList.remove('loading');
 68 |         });
 69 |     }
 70 | });
 71 | 
 72 | // Add event listeners for sliders
 73 | document.addEventListener('DOMContentLoaded', function() {
 74 |     const sliders = document.querySelectorAll('input[type="range"]');
 75 |     sliders.forEach(slider => {
 76 |         slider.addEventListener('input', function() {
 77 |             updateSliderValue(this);
 78 |         });
 79 |     });
 80 | });
 81 | 
 82 | // Theme management
 83 | function getStoredTheme() {
 84 |     return localStorage.getItem('theme');
 85 | }
 86 | 
 87 | function setStoredTheme(theme) {
 88 |     if (theme) {
 89 |         localStorage.setItem('theme', theme);
 90 |     } else {
 91 |         localStorage.removeItem('theme');
 92 |     }
 93 | }
 94 | 
 95 | function getSystemTheme() {
 96 |     return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
 97 | }
 98 | 
 99 | function getInitialTheme() {
100 |     const stored = getStoredTheme();
101 |     if (stored) {
102 |         return stored;
103 |     }
104 |     return getSystemTheme();
105 | }
106 | 
107 | function applyTheme(theme, isSystemPreference = false) {
108 |     const root = document.documentElement;
109 |     if (isSystemPreference) {
110 |         // Don't set data-theme if using system preference, so CSS media query can work
111 |         root.removeAttribute('data-theme');
112 |     } else {
113 |         root.setAttribute('data-theme', theme);
114 |     }
115 |     updateThemeToggleIcon(theme);
116 | }
117 | 
118 | function updateThemeToggleIcon(theme) {
119 |     const toggle = document.getElementById('theme-toggle');
120 |     if (!toggle) return;
121 |     
122 |     const icon = toggle.querySelector('svg');
123 |     const text = document.getElementById('theme-toggle-text');
124 |     
125 |     // Update icon based on theme
126 |     if (theme === 'dark') {
127 |         // Sun icon for switching to light mode
128 |         if (icon) {
129 |             icon.innerHTML = '<path d="M12 2.25a.75.75 0 01.75.75v2.25a.75.75 0 01-1.5 0V3a.75.75 0 01.75-.75zM7.5 12a4.5 4.5 0 119 0 4.5 4.5 0 01-9 0zM18.894 6.166a.75.75 0 00-1.06-1.06l-1.591 1.59a.75.75 0 101.06 1.061l1.591-1.59zM21.75 12a.75.75 0 01-.75.75h-2.25a.75.75 0 010-1.5H21a.75.75 0 01.75.75zM17.834 18.894a.75.75 0 001.06-1.06l-1.59-1.591a.75.75 0 10-1.061 1.06l1.59 1.591zM12 18a.75.75 0 01.75.75V21a.75.75 0 01-1.5 0v-2.25A.75.75 0 0112 18zM7.758 17.303a.75.75 0 00-1.061-1.06l-1.591 1.59a.75.75 0 001.06 1.061l1.591-1.59zM6 12a.75.75 0 01-.75.75H3a.75.75 0 010-1.5h2.25A.75.75 0 016 12zM6.697 7.757a.75.75 0 001.06-1.06l-1.59-1.591a.75.75 0 00-1.061 1.06l1.59 1.591z"/>';
130 |         }
131 |         if (text) {
132 |             text.textContent = 'Light';
133 |         }
134 |     } else {
135 |         // Moon icon for switching to dark mode
136 |         if (icon) {
137 |             icon.innerHTML = '<path d="M9.528 1.718a.75.75 0 01.162.819A8.97 8.97 0 009 6a9 9 0 009 9 8.97 8.97 0 003.463-.69.75.75 0 01.981.98 10.503 10.503 0 01-9.694 6.46c-5.799 0-10.5-4.701-10.5-10.5 0-4.368 2.667-8.112 6.46-9.694a.75.75 0 01.818.162z"/>';
138 |         }
139 |         if (text) {
140 |             text.textContent = 'Dark';
141 |         }
142 |     }
143 | }
144 | 
145 | function toggleTheme() {
146 |     // Get current effective theme
147 |     let currentTheme = document.documentElement.getAttribute('data-theme');
148 |     if (!currentTheme) {
149 |         // No manual theme set, use system preference
150 |         currentTheme = getSystemTheme();
151 |     }
152 |     
153 |     const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
154 |     applyTheme(newTheme);
155 |     setStoredTheme(newTheme);
156 | }
157 | 
158 | // Initialize theme on page load
159 | document.addEventListener('DOMContentLoaded', function() {
160 |     const storedTheme = getStoredTheme();
161 |     if (storedTheme) {
162 |         // Use stored theme
163 |         applyTheme(storedTheme);
164 |     } else {
165 |         // Use system preference without setting data-theme
166 |         const systemTheme = getSystemTheme();
167 |         applyTheme(systemTheme, true);
168 |     }
169 |     
170 |     // Listen for system theme changes (only if no manual theme is set)
171 |     window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', function(e) {
172 |         if (!getStoredTheme()) {
173 |             applyTheme(e.matches ? 'dark' : 'light', true);
174 |         }
175 |     });
176 | });
177 | 
178 | 


--------------------------------------------------------------------------------
/internal/diagram/config.go:
--------------------------------------------------------------------------------
  1 | package diagram
  2 | 
  3 | import "fmt"
  4 | 
  5 | // Config holds configuration for diagram rendering.
  6 | // This replaces global variables and makes the rendering functions testable and thread-safe.
  7 | type Config struct {
  8 | 	// UseAscii determines whether to use ASCII characters (true) or Unicode box-drawing characters (false)
  9 | 	UseAscii bool
 10 | 
 11 | 	// ShowCoords displays coordinate debugging information (for development)
 12 | 	ShowCoords bool
 13 | 
 14 | 	// Verbose enables detailed logging
 15 | 	Verbose bool
 16 | 
 17 | 	// --- Graph-specific configuration ---
 18 | 
 19 | 	// BoxBorderPadding is the padding between text and border in graph nodes
 20 | 	BoxBorderPadding int
 21 | 
 22 | 	// PaddingBetweenX is the horizontal space between nodes in graphs
 23 | 	PaddingBetweenX int
 24 | 
 25 | 	// PaddingBetweenY is the vertical space between nodes in graphs
 26 | 	PaddingBetweenY int
 27 | 
 28 | 	// GraphDirection is the direction of graph layout ("LR" or "TD")
 29 | 	GraphDirection string
 30 | 
 31 | 	// StyleType determines output format for graph diagrams ("cli" or "html")
 32 | 	// This controls whether graphs use colored output (html) or plain text (cli)
 33 | 	StyleType string
 34 | 
 35 | 	// --- Sequence diagram-specific configuration ---
 36 | 
 37 | 	// SequenceParticipantSpacing is the horizontal space between participants
 38 | 	SequenceParticipantSpacing int
 39 | 
 40 | 	// SequenceMessageSpacing is the vertical space between messages (lifeline segments)
 41 | 	SequenceMessageSpacing int
 42 | 
 43 | 	// SequenceSelfMessageWidth is the width of self-message loops
 44 | 	SequenceSelfMessageWidth int
 45 | }
 46 | 
 47 | // DefaultConfig returns a Config with sensible defaults.
 48 | // The returned config is guaranteed to pass validation.
 49 | func DefaultConfig() *Config {
 50 | 	return &Config{
 51 | 		UseAscii:   false, // Use Unicode by default for better appearance
 52 | 		ShowCoords: false,
 53 | 		Verbose:    false,
 54 | 		// Graph defaults
 55 | 		BoxBorderPadding: 1,
 56 | 		PaddingBetweenX:  5,
 57 | 		PaddingBetweenY:  5,
 58 | 		GraphDirection:   "LR",
 59 | 		StyleType:        "cli",
 60 | 		// Sequence diagram defaults
 61 | 		SequenceParticipantSpacing: 5,
 62 | 		SequenceMessageSpacing:     1,
 63 | 		SequenceSelfMessageWidth:   4,
 64 | 	}
 65 | }
 66 | 
 67 | // NewConfig creates a new Config with the provided values and validates them.
 68 | // Returns an error if any values are invalid.
 69 | // For default values, use DefaultConfig() instead.
 70 | func NewConfig(useAscii bool, graphDirection, styleType string) (*Config, error) {
 71 | 	config := &Config{
 72 | 		UseAscii:                   useAscii,
 73 | 		ShowCoords:                 false,
 74 | 		Verbose:                    false,
 75 | 		BoxBorderPadding:           1,
 76 | 		PaddingBetweenX:            5,
 77 | 		PaddingBetweenY:            5,
 78 | 		GraphDirection:             graphDirection,
 79 | 		StyleType:                  styleType,
 80 | 		SequenceParticipantSpacing: 5,
 81 | 		SequenceMessageSpacing:     1,
 82 | 		SequenceSelfMessageWidth:   4,
 83 | 	}
 84 | 
 85 | 	if err := config.Validate(); err != nil {
 86 | 		return nil, err
 87 | 	}
 88 | 
 89 | 	return config, nil
 90 | }
 91 | 
 92 | func NewCLIConfig(useAscii, showCoords, verbose bool, boxBorderPadding, paddingX, paddingY int, graphDirection string) (*Config, error) {
 93 | 	defaults := DefaultConfig()
 94 | 	config := &Config{
 95 | 		UseAscii:                   useAscii,
 96 | 		ShowCoords:                 showCoords,
 97 | 		Verbose:                    verbose,
 98 | 		BoxBorderPadding:           boxBorderPadding,
 99 | 		PaddingBetweenX:            paddingX,
100 | 		PaddingBetweenY:            paddingY,
101 | 		GraphDirection:             graphDirection,
102 | 		StyleType:                  "cli",
103 | 		SequenceParticipantSpacing: defaults.SequenceParticipantSpacing,
104 | 		SequenceMessageSpacing:     defaults.SequenceMessageSpacing,
105 | 		SequenceSelfMessageWidth:   defaults.SequenceSelfMessageWidth,
106 | 	}
107 | 
108 | 	if err := config.Validate(); err != nil {
109 | 		return nil, err
110 | 	}
111 | 
112 | 	return config, nil
113 | }
114 | 
115 | func NewWebConfig(useAscii bool, boxBorderPadding, paddingX, paddingY int) (*Config, error) {
116 | 	defaults := DefaultConfig()
117 | 	config := &Config{
118 | 		UseAscii:                   useAscii,
119 | 		ShowCoords:                 false,
120 | 		Verbose:                    false,
121 | 		BoxBorderPadding:           boxBorderPadding,
122 | 		PaddingBetweenX:            paddingX,
123 | 		PaddingBetweenY:            paddingY,
124 | 		GraphDirection:             "LR",
125 | 		StyleType:                  "html",
126 | 		SequenceParticipantSpacing: defaults.SequenceParticipantSpacing,
127 | 		SequenceMessageSpacing:     defaults.SequenceMessageSpacing,
128 | 		SequenceSelfMessageWidth:   defaults.SequenceSelfMessageWidth,
129 | 	}
130 | 
131 | 	if err := config.Validate(); err != nil {
132 | 		return nil, err
133 | 	}
134 | 
135 | 	return config, nil
136 | }
137 | 
138 | // NewTestConfig creates a Config for testing with sensible defaults.
139 | // The styleType parameter determines output format ("cli" or "html").
140 | func NewTestConfig(useAscii bool, styleType string) *Config {
141 | 	config := DefaultConfig()
142 | 	config.UseAscii = useAscii
143 | 	config.StyleType = styleType
144 | 	return config
145 | }
146 | 
147 | // Validate checks if the configuration values are valid.
148 | // Returns an error if any values are invalid or would cause rendering issues.
149 | func (c *Config) Validate() error {
150 | 	// Validate graph configuration
151 | 	if c.BoxBorderPadding < 0 {
152 | 		return &ConfigError{Field: "BoxBorderPadding", Value: c.BoxBorderPadding, Message: "must be non-negative"}
153 | 	}
154 | 	if c.PaddingBetweenX < 0 {
155 | 		return &ConfigError{Field: "PaddingBetweenX", Value: c.PaddingBetweenX, Message: "must be non-negative"}
156 | 	}
157 | 	if c.PaddingBetweenY < 0 {
158 | 		return &ConfigError{Field: "PaddingBetweenY", Value: c.PaddingBetweenY, Message: "must be non-negative"}
159 | 	}
160 | 	if c.GraphDirection != "LR" && c.GraphDirection != "TD" {
161 | 		return &ConfigError{Field: "GraphDirection", Value: c.GraphDirection, Message: "must be \"LR\" or \"TD\""}
162 | 	}
163 | 	if c.StyleType != "cli" && c.StyleType != "html" {
164 | 		return &ConfigError{Field: "StyleType", Value: c.StyleType, Message: "must be \"cli\" or \"html\""}
165 | 	}
166 | 
167 | 	// Validate sequence diagram configuration
168 | 	if c.SequenceParticipantSpacing < 0 {
169 | 		return &ConfigError{Field: "SequenceParticipantSpacing", Value: c.SequenceParticipantSpacing, Message: "must be non-negative"}
170 | 	}
171 | 	if c.SequenceMessageSpacing < 0 {
172 | 		return &ConfigError{Field: "SequenceMessageSpacing", Value: c.SequenceMessageSpacing, Message: "must be non-negative"}
173 | 	}
174 | 	if c.SequenceSelfMessageWidth < 2 {
175 | 		return &ConfigError{Field: "SequenceSelfMessageWidth", Value: c.SequenceSelfMessageWidth, Message: "must be at least 2"}
176 | 	}
177 | 
178 | 	return nil
179 | }
180 | 
181 | // ConfigError represents an invalid configuration value.
182 | type ConfigError struct {
183 | 	Field   string
184 | 	Value   interface{}
185 | 	Message string
186 | }
187 | 
188 | func (e *ConfigError) Error() string {
189 | 	return fmt.Sprintf("invalid config: %s = %v (%s)", e.Field, e.Value, e.Message)
190 | }
191 | 


--------------------------------------------------------------------------------
/cmd/integration_test.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/sequence"
  5 | 	"strings"
  6 | 	"testing"
  7 | 
  8 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
  9 | )
 10 | 
 11 | // TestSequenceDiagramIntegration tests end-to-end rendering of sequence diagrams.
 12 | func TestSequenceDiagramIntegration(t *testing.T) {
 13 | 	tests := []struct {
 14 | 		name          string
 15 | 		input         string
 16 | 		wantSubstring []string // Substrings that must appear in output
 17 | 		wantNoError   bool
 18 | 	}{
 19 | 		{
 20 | 			name: "simple two participant diagram",
 21 | 			input: `sequenceDiagram
 22 |     Alice->>Bob: Hello
 23 |     Bob-->>Alice: Hi`,
 24 | 			wantSubstring: []string{"Alice", "Bob", "Hello", "Hi", "│"},
 25 | 			wantNoError:   true,
 26 | 		},
 27 | 		{
 28 | 			name: "self-message diagram",
 29 | 			input: `sequenceDiagram
 30 |     Alice->>Alice: Think`,
 31 | 			wantSubstring: []string{"Alice", "Think"},
 32 | 			wantNoError:   true,
 33 | 		},
 34 | 		{
 35 | 			name: "three participants",
 36 | 			input: `sequenceDiagram
 37 |     Alice->>Bob: Request
 38 |     Bob->>Charlie: Forward
 39 |     Charlie-->>Bob: Response
 40 |     Bob-->>Alice: Done`,
 41 | 			wantSubstring: []string{"Alice", "Bob", "Charlie", "Request", "Forward", "Response", "Done"},
 42 | 			wantNoError:   true,
 43 | 		},
 44 | 		{
 45 | 			name: "with explicit participants",
 46 | 			input: `sequenceDiagram
 47 |     participant A as Alice
 48 |     participant B as Bob
 49 |     A->>B: Test`,
 50 | 			wantSubstring: []string{"Alice", "Bob", "Test"},
 51 | 			wantNoError:   true,
 52 | 		},
 53 | 		{
 54 | 			name: "with comments",
 55 | 			input: `sequenceDiagram
 56 |     %% This is a comment
 57 |     Alice->>Bob: Hello
 58 |     %% Another comment`,
 59 | 			wantSubstring: []string{"Alice", "Bob", "Hello"},
 60 | 			wantNoError:   true,
 61 | 		},
 62 | 	}
 63 | 
 64 | 	for _, tt := range tests {
 65 | 		t.Run(tt.name, func(t *testing.T) {
 66 | 			config := diagram.NewTestConfig(false, "cli") // Unicode, CLI style
 67 | 
 68 | 			output, err := RenderDiagram(tt.input, config)
 69 | 
 70 | 			if tt.wantNoError && err != nil {
 71 | 				t.Errorf("Unexpected error: %v", err)
 72 | 				return
 73 | 			}
 74 | 
 75 | 			if !tt.wantNoError && err == nil {
 76 | 				t.Error("Expected error but got none")
 77 | 				return
 78 | 			}
 79 | 
 80 | 			// Check all expected substrings are present
 81 | 			for _, want := range tt.wantSubstring {
 82 | 				if !strings.Contains(output, want) {
 83 | 					t.Errorf("Output missing expected substring %q\nOutput:\n%s", want, output)
 84 | 				}
 85 | 			}
 86 | 
 87 | 			// Verify output is not empty
 88 | 			if tt.wantNoError && len(output) == 0 {
 89 | 				t.Error("Output is empty but expected content")
 90 | 			}
 91 | 		})
 92 | 	}
 93 | }
 94 | 
 95 | // TestSequenceDiagramIntegration_ASCII tests ASCII rendering mode.
 96 | func TestSequenceDiagramIntegration_ASCII(t *testing.T) {
 97 | 	input := `sequenceDiagram
 98 |     Alice->>Bob: Hello`
 99 | 
100 | 	config := diagram.NewTestConfig(true, "cli") // ASCII, CLI style
101 | 
102 | 	output, err := RenderDiagram(input, config)
103 | 	if err != nil {
104 | 		t.Fatalf("Unexpected error: %v", err)
105 | 	}
106 | 
107 | 	// ASCII mode should use + and | characters
108 | 	if !strings.Contains(output, "+") {
109 | 		t.Error("ASCII output should contain '+' characters")
110 | 	}
111 | 	if !strings.Contains(output, "|") {
112 | 		t.Error("ASCII output should contain '|' characters")
113 | 	}
114 | 	// Should not contain Unicode box-drawing characters
115 | 	if strings.Contains(output, "│") || strings.Contains(output, "┌") {
116 | 		t.Error("ASCII output should not contain Unicode box-drawing characters")
117 | 	}
118 | }
119 | 
120 | // TestSequenceDiagramIntegration_ErrorHandling tests error cases.
121 | func TestSequenceDiagramIntegration_ErrorHandling(t *testing.T) {
122 | 	tests := []struct {
123 | 		name        string
124 | 		input       string
125 | 		shouldError bool
126 | 	}{
127 | 		{
128 | 			name:        "empty input - defaults to graph, fails graph parsing",
129 | 			input:       "",
130 | 			shouldError: true,
131 | 		},
132 | 		{
133 | 			name:        "invalid syntax - defaults to graph, fails graph parsing",
134 | 			input:       "not a diagram",
135 | 			shouldError: true,
136 | 		},
137 | 		{
138 | 			name:        "sequence diagram with only comments",
139 | 			input:       "sequenceDiagram\n%% Only comments",
140 | 			shouldError: true,
141 | 		},
142 | 	}
143 | 
144 | 	for _, tt := range tests {
145 | 		t.Run(tt.name, func(t *testing.T) {
146 | 			config := diagram.NewTestConfig(false, "cli") // Unicode, CLI style
147 | 			_, err := RenderDiagram(tt.input, config)
148 | 
149 | 			if tt.shouldError && err == nil {
150 | 				t.Error("Expected error but got none")
151 | 			}
152 | 
153 | 			if !tt.shouldError && err != nil {
154 | 				t.Errorf("Unexpected error: %v", err)
155 | 			}
156 | 		})
157 | 	}
158 | }
159 | 
160 | // TestDiagramFactoryIntegration tests diagram type detection.
161 | func TestDiagramFactoryIntegration(t *testing.T) {
162 | 	tests := []struct {
163 | 		name         string
164 | 		input        string
165 | 		expectedType string
166 | 	}{
167 | 		{
168 | 			name: "sequence diagram",
169 | 			input: `sequenceDiagram
170 |     A->>B: Test`,
171 | 			expectedType: "sequence",
172 | 		},
173 | 		{
174 | 			name: "graph diagram",
175 | 			input: `graph LR
176 |     A-->B`,
177 | 			expectedType: "graph",
178 | 		},
179 | 	}
180 | 
181 | 	for _, tt := range tests {
182 | 		t.Run(tt.name, func(t *testing.T) {
183 | 			diag, err := DiagramFactory(tt.input)
184 | 			if err != nil {
185 | 				t.Fatalf("Factory error: %v", err)
186 | 			}
187 | 
188 | 			if diag.Type() != tt.expectedType {
189 | 				t.Errorf("Expected type %q, got %q", tt.expectedType, diag.Type())
190 | 			}
191 | 
192 | 			// Verify it can parse and render
193 | 			if err := diag.Parse(tt.input); err != nil {
194 | 				t.Errorf("Parse error: %v", err)
195 | 			}
196 | 
197 | 			config := diagram.NewTestConfig(false, "cli")
198 | 			output, err := diag.Render(config)
199 | 			if err != nil {
200 | 				t.Errorf("Render error: %v", err)
201 | 			}
202 | 
203 | 			if len(output) == 0 {
204 | 				t.Error("Render produced empty output")
205 | 			}
206 | 		})
207 | 	}
208 | }
209 | 
210 | // BenchmarkSequenceDiagramRendering benchmarks the rendering performance.
211 | func BenchmarkSequenceDiagramRendering(b *testing.B) {
212 | 	input := `sequenceDiagram
213 |     participant Alice
214 |     participant Bob
215 |     participant Charlie
216 |     Alice->>Bob: Message 1
217 |     Bob->>Charlie: Message 2
218 |     Charlie-->>Bob: Response 1
219 |     Bob-->>Alice: Response 2`
220 | 
221 | 	config := diagram.NewTestConfig(false, "cli")
222 | 
223 | 	b.ResetTimer()
224 | 	for i := 0; i < b.N; i++ {
225 | 		_, err := RenderDiagram(input, config)
226 | 		if err != nil {
227 | 			b.Fatalf("Render error: %v", err)
228 | 		}
229 | 	}
230 | }
231 | 
232 | // BenchmarkSequenceDiagramParsing benchmarks just the parsing performance.
233 | func BenchmarkSequenceDiagramParsing(b *testing.B) {
234 | 	input := `sequenceDiagram
235 |     participant Alice
236 |     participant Bob
237 |     Alice->>Bob: Test
238 |     Bob-->>Alice: Response`
239 | 
240 | 	b.ResetTimer()
241 | 	for i := 0; i < b.N; i++ {
242 | 		_, err := sequence.Parse(input)
243 | 		if err != nil {
244 | 			b.Fatalf("Parse error: %v", err)
245 | 		}
246 | 	}
247 | }
248 | 
249 | // TestRenderConfig_Defaults tests that default configuration works correctly.
250 | func TestRenderConfig_Defaults(t *testing.T) {
251 | 	config := diagram.DefaultConfig()
252 | 
253 | 	// Verify sensible defaults
254 | 	if config.UseAscii {
255 | 		t.Error("Default should be Unicode, not ASCII")
256 | 	}
257 | 	if config.SequenceParticipantSpacing <= 0 {
258 | 		t.Error("SequenceParticipantSpacing should have positive default")
259 | 	}
260 | 	if config.SequenceMessageSpacing < 0 {
261 | 		t.Error("SequenceMessageSpacing should be non-negative")
262 | 	}
263 | 
264 | 	// Test that defaults actually work for rendering
265 | 	input := `sequenceDiagram
266 |     A->>B: Test`
267 | 
268 | 	testConfig := diagram.NewTestConfig(false, "cli")
269 | 	output, err := RenderDiagram(input, testConfig)
270 | 	if err != nil {
271 | 		t.Errorf("Default config failed to render: %v", err)
272 | 	}
273 | 	if len(output) == 0 {
274 | 		t.Error("Default config produced empty output")
275 | 	}
276 | }
277 | 


--------------------------------------------------------------------------------
/internal/sequence/renderer.go:
--------------------------------------------------------------------------------
  1 | package sequence
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"strings"
  6 | 
  7 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
  8 | 	"github.com/mattn/go-runewidth"
  9 | )
 10 | 
 11 | const (
 12 | 	defaultSelfMessageWidth   = 4
 13 | 	defaultMessageSpacing     = 1
 14 | 	defaultParticipantSpacing = 5
 15 | 	boxPaddingLeftRight       = 2
 16 | 	minBoxWidth               = 3
 17 | 	boxBorderWidth            = 2
 18 | 	labelLeftMargin           = 2
 19 | 	labelBufferSpace          = 10
 20 | )
 21 | 
 22 | type diagramLayout struct {
 23 | 	participantWidths  []int
 24 | 	participantCenters []int
 25 | 	totalWidth         int
 26 | 	messageSpacing     int
 27 | 	selfMessageWidth   int
 28 | }
 29 | 
 30 | func calculateLayout(sd *SequenceDiagram, config *diagram.Config) *diagramLayout {
 31 | 	participantSpacing := config.SequenceParticipantSpacing
 32 | 	if participantSpacing <= 0 {
 33 | 		participantSpacing = defaultParticipantSpacing
 34 | 	}
 35 | 
 36 | 	widths := make([]int, len(sd.Participants))
 37 | 	for i, p := range sd.Participants {
 38 | 		w := runewidth.StringWidth(p.Label) + boxPaddingLeftRight
 39 | 		if w < minBoxWidth {
 40 | 			w = minBoxWidth
 41 | 		}
 42 | 		widths[i] = w
 43 | 	}
 44 | 
 45 | 	centers := make([]int, len(sd.Participants))
 46 | 	currentX := 0
 47 | 	for i := range sd.Participants {
 48 | 		boxWidth := widths[i] + boxBorderWidth
 49 | 		if i == 0 {
 50 | 			centers[i] = boxWidth / 2
 51 | 			currentX = boxWidth
 52 | 		} else {
 53 | 			currentX += participantSpacing
 54 | 			centers[i] = currentX + boxWidth/2
 55 | 			currentX += boxWidth
 56 | 		}
 57 | 	}
 58 | 
 59 | 	last := len(sd.Participants) - 1
 60 | 	totalWidth := centers[last] + (widths[last]+boxBorderWidth)/2
 61 | 
 62 | 	msgSpacing := config.SequenceMessageSpacing
 63 | 	if msgSpacing <= 0 {
 64 | 		msgSpacing = defaultMessageSpacing
 65 | 	}
 66 | 	selfWidth := config.SequenceSelfMessageWidth
 67 | 	if selfWidth <= 0 {
 68 | 		selfWidth = defaultSelfMessageWidth
 69 | 	}
 70 | 
 71 | 	return &diagramLayout{
 72 | 		participantWidths:  widths,
 73 | 		participantCenters: centers,
 74 | 		totalWidth:         totalWidth,
 75 | 		messageSpacing:     msgSpacing,
 76 | 		selfMessageWidth:   selfWidth,
 77 | 	}
 78 | }
 79 | 
 80 | func Render(sd *SequenceDiagram, config *diagram.Config) (string, error) {
 81 | 	if sd == nil || len(sd.Participants) == 0 {
 82 | 		return "", fmt.Errorf("no participants")
 83 | 	}
 84 | 	if config == nil {
 85 | 		config = diagram.DefaultConfig()
 86 | 	}
 87 | 
 88 | 	chars := Unicode
 89 | 	if config.UseAscii {
 90 | 		chars = ASCII
 91 | 	}
 92 | 
 93 | 	layout := calculateLayout(sd, config)
 94 | 	var lines []string
 95 | 
 96 | 	lines = append(lines, buildLine(sd.Participants, layout, func(i int) string {
 97 | 		return string(chars.TopLeft) + strings.Repeat(string(chars.Horizontal), layout.participantWidths[i]) + string(chars.TopRight)
 98 | 	}))
 99 | 
100 | 	lines = append(lines, buildLine(sd.Participants, layout, func(i int) string {
101 | 		w := layout.participantWidths[i]
102 | 		labelLen := runewidth.StringWidth(sd.Participants[i].Label)
103 | 		pad := (w - labelLen) / 2
104 | 		return string(chars.Vertical) + strings.Repeat(" ", pad) + sd.Participants[i].Label +
105 | 			strings.Repeat(" ", w-pad-labelLen) + string(chars.Vertical)
106 | 	}))
107 | 
108 | 	lines = append(lines, buildLine(sd.Participants, layout, func(i int) string {
109 | 		w := layout.participantWidths[i]
110 | 		return string(chars.BottomLeft) + strings.Repeat(string(chars.Horizontal), w/2) +
111 | 			string(chars.TeeDown) + strings.Repeat(string(chars.Horizontal), w-w/2-1) +
112 | 			string(chars.BottomRight)
113 | 	}))
114 | 
115 | 	for _, msg := range sd.Messages {
116 | 		for i := 0; i < layout.messageSpacing; i++ {
117 | 			lines = append(lines, buildLifeline(layout, chars))
118 | 		}
119 | 
120 | 		if msg.From == msg.To {
121 | 			lines = append(lines, renderSelfMessage(msg, layout, chars)...)
122 | 		} else {
123 | 			lines = append(lines, renderMessage(msg, layout, chars)...)
124 | 		}
125 | 	}
126 | 
127 | 	lines = append(lines, buildLifeline(layout, chars))
128 | 	return strings.Join(lines, "\n") + "\n", nil
129 | }
130 | 
131 | func buildLine(participants []*Participant, layout *diagramLayout, draw func(int) string) string {
132 | 	var sb strings.Builder
133 | 	for i := range participants {
134 | 		boxWidth := layout.participantWidths[i] + boxBorderWidth
135 | 		left := layout.participantCenters[i] - boxWidth/2
136 | 
137 | 		needed := left - runewidth.StringWidth(sb.String())
138 | 		if needed > 0 {
139 | 			sb.WriteString(strings.Repeat(" ", needed))
140 | 		}
141 | 		sb.WriteString(draw(i))
142 | 	}
143 | 	return sb.String()
144 | }
145 | 
146 | func buildLifeline(layout *diagramLayout, chars BoxChars) string {
147 | 	line := make([]rune, layout.totalWidth+1)
148 | 	for i := range line {
149 | 		line[i] = ' '
150 | 	}
151 | 	for _, c := range layout.participantCenters {
152 | 		if c < len(line) {
153 | 			line[c] = chars.Vertical
154 | 		}
155 | 	}
156 | 	return strings.TrimRight(string(line), " ")
157 | }
158 | 
159 | func renderMessage(msg *Message, layout *diagramLayout, chars BoxChars) []string {
160 | 	var lines []string
161 | 	from, to := layout.participantCenters[msg.From.Index], layout.participantCenters[msg.To.Index]
162 | 
163 | 	if msg.Label != "" {
164 | 		start := min(from, to) + labelLeftMargin
165 | 		labelWidth := runewidth.StringWidth(msg.Label)
166 | 		w := max(layout.totalWidth, start+labelWidth) + labelBufferSpace
167 | 		line := []rune(buildLifeline(layout, chars))
168 | 		if len(line) < w {
169 | 			padding := make([]rune, w-len(line))
170 | 			for k := range padding {
171 | 				padding[k] = ' '
172 | 			}
173 | 			line = append(line, padding...)
174 | 		}
175 | 
176 | 		col := start
177 | 		for _, r := range msg.Label {
178 | 			if col < len(line) {
179 | 				line[col] = r
180 | 				col++
181 | 			}
182 | 		}
183 | 		lines = append(lines, strings.TrimRight(string(line), " "))
184 | 	}
185 | 
186 | 	line := []rune(buildLifeline(layout, chars))
187 | 	style := chars.SolidLine
188 | 	if msg.ArrowType == DottedArrow {
189 | 		style = chars.DottedLine
190 | 	}
191 | 
192 | 	if from < to {
193 | 		line[from] = chars.TeeRight
194 | 		for i := from + 1; i < to; i++ {
195 | 			line[i] = style
196 | 		}
197 | 		line[to-1] = chars.ArrowRight
198 | 		line[to] = chars.Vertical
199 | 	} else {
200 | 		line[to] = chars.Vertical
201 | 		line[to+1] = chars.ArrowLeft
202 | 		for i := to + 2; i < from; i++ {
203 | 			line[i] = style
204 | 		}
205 | 		line[from] = chars.TeeLeft
206 | 	}
207 | 	lines = append(lines, strings.TrimRight(string(line), " "))
208 | 	return lines
209 | }
210 | 
211 | func renderSelfMessage(msg *Message, layout *diagramLayout, chars BoxChars) []string {
212 | 	var lines []string
213 | 	center := layout.participantCenters[msg.From.Index]
214 | 	width := layout.selfMessageWidth
215 | 
216 | 	ensureWidth := func(l string) []rune {
217 | 		target := layout.totalWidth + width + 1
218 | 		r := []rune(l)
219 | 		if len(r) < target {
220 | 			pad := make([]rune, target-len(r))
221 | 			for i := range pad {
222 | 				pad[i] = ' '
223 | 			}
224 | 			r = append(r, pad...)
225 | 		}
226 | 		return r
227 | 	}
228 | 
229 | 	if msg.Label != "" {
230 | 		line := ensureWidth(buildLifeline(layout, chars))
231 | 		start := center + labelLeftMargin
232 | 		labelWidth := runewidth.StringWidth(msg.Label)
233 | 		needed := start + labelWidth + labelBufferSpace
234 | 		if len(line) < needed {
235 | 			pad := make([]rune, needed-len(line))
236 | 			for i := range pad {
237 | 				pad[i] = ' '
238 | 			}
239 | 			line = append(line, pad...)
240 | 		}
241 | 		col := start
242 | 		for _, c := range msg.Label {
243 | 			if col < len(line) {
244 | 				line[col] = c
245 | 				col++
246 | 			}
247 | 		}
248 | 		lines = append(lines, strings.TrimRight(string(line), " "))
249 | 	}
250 | 
251 | 	l1 := ensureWidth(buildLifeline(layout, chars))
252 | 	l1[center] = chars.TeeRight
253 | 	for i := 1; i < width; i++ {
254 | 		l1[center+i] = chars.Horizontal
255 | 	}
256 | 	l1[center+width-1] = chars.SelfTopRight
257 | 	lines = append(lines, strings.TrimRight(string(l1), " "))
258 | 
259 | 	l2 := ensureWidth(buildLifeline(layout, chars))
260 | 	l2[center+width-1] = chars.Vertical
261 | 	lines = append(lines, strings.TrimRight(string(l2), " "))
262 | 
263 | 	l3 := ensureWidth(buildLifeline(layout, chars))
264 | 	l3[center] = chars.Vertical
265 | 	l3[center+1] = chars.ArrowLeft
266 | 	for i := 2; i < width-1; i++ {
267 | 		l3[center+i] = chars.Horizontal
268 | 	}
269 | 	l3[center+width-1] = chars.SelfBottom
270 | 	lines = append(lines, strings.TrimRight(string(l3), " "))
271 | 
272 | 	return lines
273 | }
274 | 


--------------------------------------------------------------------------------
/templates/index.tmpl:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Mermaid ASCII</title>
  7 |     <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap" rel="stylesheet">
  8 |     <link href="https://fonts.googleapis.com/css2?family=Roboto+Mono:wght@400;700&display=swap" rel="stylesheet">
  9 |     <link rel="stylesheet" href="/static/style.css">
 10 |     <script src="https://unpkg.com/htmx.org@1.7.0"></script>
 11 |     <script src="https://unpkg.com/hyperscript.org@0.9.12"></script>
 12 |     <script src="/static/script.js"></script>
 13 | </head>
 14 | <body>
 15 |     <div class="container">
 16 |         <header>
 17 |             <h1>Mermaid ASCII <small>v{{ .Version }}</small></h1>
 18 |             <div class="header-actions">
 19 |                 <button id="theme-toggle" class="theme-toggle" onclick="toggleTheme()" aria-label="Toggle theme">
 20 |                     <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
 21 |                         <path d="M9.528 1.718a.75.75 0 01.162.819A8.97 8.97 0 009 6a9 9 0 009 9 8.97 8.97 0 003.463-.69.75.75 0 01.981.98 10.503 10.503 0 01-9.694 6.46c-5.799 0-10.5-4.701-10.5-10.5 0-4.368 2.667-8.112 6.46-9.694a.75.75 0 01.818.162z"/>
 22 |                     </svg>
 23 |                     <span id="theme-toggle-text">Dark</span>
 24 |                 </button>
 25 |                 <a href="https://github.com/AlexanderGrooff/mermaid-ascii" class="github-link" target="_blank" rel="noopener noreferrer">
 26 |                     <img src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" alt="GitHub">
 27 |                     <span>AlexanderGrooff/mermaid-ascii</span>
 28 |                 </a>
 29 |             </div>
 30 |         </header>
 31 | 
 32 |         <div class="toolbar">
 33 |             <div class="toolbar-section">
 34 |                 <div class="toolbar-group">
 35 |                     <label for="xPadding">xPadding:</label>
 36 |                     <div class="slider-container">
 37 |                         <input
 38 |                             type="range" id="xPadding" name="xPadding" min="3" max="10" value="5"
 39 |                             form="mermaid-form"
 40 |                             hx-post="/"
 41 |                             hx-target="#result-code"
 42 |                             hx-swap="innerHTML"
 43 |                             hx-trigger="change delay:200ms"
 44 |                             hx-include="#mermaid-form, [form='mermaid-form']"
 45 |                         >
 46 |                         <span class="slider-value">5</span>
 47 |                     </div>
 48 |                 </div>
 49 | 
 50 |                 <div class="toolbar-group">
 51 |                     <label for="yPadding">yPadding:</label>
 52 |                     <div class="slider-container">
 53 |                         <input
 54 |                             type="range" id="yPadding" name="yPadding" min="3" max="10" value="3"
 55 |                             form="mermaid-form"
 56 |                             hx-post="/"
 57 |                             hx-target="#result-code"
 58 |                             hx-swap="innerHTML"
 59 |                             hx-trigger="change delay:200ms"
 60 |                             hx-include="#mermaid-form, [form='mermaid-form']"
 61 |                         >
 62 |                         <span class="slider-value">3</span>
 63 |                     </div>
 64 |                 </div>
 65 | 
 66 |                 <div class="toolbar-group">
 67 |                     <label for="useExtendedChars">Use extended characters:</label>
 68 |                     <input
 69 |                         type="checkbox" id="useExtendedChars" name="useExtendedChars" checked
 70 |                         form="mermaid-form"
 71 |                         hx-post="/"
 72 |                         hx-target="#result-code"
 73 |                         hx-swap="innerHTML"
 74 |                         hx-trigger="change"
 75 |                         hx-include="#mermaid-form, [form='mermaid-form']"
 76 |                     >
 77 |                 </div>
 78 |             </div>
 79 | 
 80 |             <div class="example-buttons">
 81 |                 <button type="button" class="example-button" style="background-color: #28a745; color: white;" onclick="setExample('graph LR\nsubgraph Frontend\n    UI --> API\nend\nsubgraph Backend\n    API --> Database\n    API --> Cache\nend')">Example 1: Nested Subgraphs</button>
 82 |                 <button type="button" class="example-button" style="background-color: #20c997; color: white;" onclick="setExample('graph TD\nA -->|labelled arrow| B\nA --> Example2')">Example 2: Labelled Arrow</button>
 83 |                 <button type="button" class="example-button" style="background-color: #007bff; color: white;" onclick="setExample('graph LR\nclassDef examplecolor color:#ff00ff\nA --> B\nA --> ColorText:::examplecolor\nB --> D\nColorText --> D')">Example 3: Styled Text</button>
 84 |                 <button type="button" class="example-button" style="background-color: #6f42c1; color: white;" onclick="setExample('sequenceDiagram\n    participant A\n    participant B\n    participant C\n    A->>B: First\n    B->>C: Second\n    A->>C: Direct')">Example 4: Sequence Diagram</button>
 85 |             </div>
 86 |         </div>
 87 | 
 88 |         <div class="main-content">
 89 |             <div class="editor-pane">
 90 |                 <div class="pane-header">
 91 |                     <h2 class="pane-title">Mermaid Code</h2>
 92 |                 </div>
 93 |                 <form id="mermaid-form" hx-post="/" hx-target="#result-code" hx-swap="innerHTML">
 94 |                     <textarea
 95 |                         name="mermaid"
 96 |                         placeholder="graph LR&#10;A --> B"
 97 |                         hx-post="/"
 98 |                         hx-target="#result-code"
 99 |                         hx-swap="innerHTML"
100 |                         hx-trigger="keyup changed delay:200ms, changed"
101 |                         hx-include="#mermaid-form, [form='mermaid-form']"
102 |                     ></textarea>
103 |                 </form>
104 |             </div>
105 | 
106 |             <div class="preview-pane">
107 |                 <div class="pane-header">
108 |                     <h2 class="pane-title">ASCII Output</h2>
109 |                     <button class="copy-button" _="on click
110 |                         writeText(my nextElementSibling.querySelector('code').innerText) on navigator.clipboard
111 |                         put 'Copied!' into me
112 |                         wait 2s
113 |                         put 'Copy' into me
114 |                     ">Copy</button>
115 |                 </div>
116 |                 <div class="result-container">
117 |                     <pre class="code-block"><code id="result-code"><!-- Result content goes here --></code></pre>
118 |                 </div>
119 |             </div>
120 |         </div>
121 | 
122 |         <div class="instructions-section">
123 |             <h2>Alternative Usage Methods</h2>
124 |             <p>There are alternative forms of generating mermaid graphs in ASCII using this same Git repository.</p>
125 | 
126 |             <div class="instruction-block">
127 |                 <h3>cURL Request</h3>
128 |                 <div class="code-example">
129 |                     <button class="copy-button" _="on click
130 |                         writeText(my nextElementSibling.innerText) on navigator.clipboard
131 |                         put 'Copied!' into me
132 |                         wait 2s
133 |                         put 'Copy' into me
134 |                     ">Copy</button>
135 |                     <pre><code>curl https://mermaid-ascii.art -d mermaid="graph LR\nABC --> DEF"</code></pre>
136 |                 </div>
137 |             </div>
138 | 
139 |             <div class="instruction-block">
140 |                 <h3>Run Golang in CLI</h3>
141 |                 <div class="code-example">
142 |                     <button class="copy-button" _="on click
143 |                         writeText(my nextElementSibling.innerText) on navigator.clipboard
144 |                         put 'Copied!' into me
145 |                         wait 2s
146 |                         put 'Copy' into me
147 |                     ">Copy</button>
148 |                     <pre><code>git clone https://github.com/AlexanderGrooff/mermaid-ascii
149 | cd mermaid-ascii
150 | go run main.go -f test.mermaid</code></pre>
151 |                 </div>
152 |             </div>
153 |         </div>
154 |     </div>
155 | </body>
156 | </html>
157 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
  1 | github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
  2 | github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
  3 | github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
  4 | github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
  5 | github.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=
  6 | github.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
  7 | github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
  8 | github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
  9 | github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
 10 | github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 11 | github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 12 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 13 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 14 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 15 | github.com/elliotchance/orderedmap/v2 v2.2.0 h1:7/2iwO98kYT4XkOjA9mBEIwvi4KpGB4cyHeOFOnj4Vk=
 16 | github.com/elliotchance/orderedmap/v2 v2.2.0/go.mod h1:85lZyVbpGaGvHvnKa7Qhx7zncAdBIBq6u56Hb1PRU5Q=
 17 | github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
 18 | github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
 19 | github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 20 | github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 21 | github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 22 | github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
 23 | github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 24 | github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 25 | github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 26 | github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 27 | github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 28 | github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
 29 | github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
 30 | github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
 31 | github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 32 | github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 33 | github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 34 | github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 35 | github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 36 | github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
 37 | github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
 38 | github.com/inconshreveable/mousetrap v1.0.1 h1:U3uMjPSQEBMNp1lFxmllqCPM6P5u/Xq7Pgzkat/bFNc=
 39 | github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 40 | github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 41 | github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 42 | github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 43 | github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
 44 | github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 45 | github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
 46 | github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 47 | github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
 48 | github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 49 | github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 50 | github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
 51 | github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 52 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 53 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 54 | github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 55 | github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 56 | github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 57 | github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 58 | github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 59 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 60 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 61 | github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 62 | github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
 63 | github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 64 | github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA=
 65 | github.com/spf13/cobra v1.6.1/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY=
 66 | github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 67 | github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 68 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 69 | github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 70 | github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 71 | github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 72 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 73 | github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 74 | github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 75 | github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 76 | github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 77 | github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 78 | github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 79 | github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 80 | github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 81 | github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 82 | github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 83 | github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 84 | github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHgvgickp1Yw510KJOqX7H24mg8=
 85 | github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
 86 | golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 87 | golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
 88 | golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 89 | golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
 90 | golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 91 | golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
 92 | golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 93 | golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 94 | golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 95 | golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 96 | golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
 97 | golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 98 | golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
 99 | golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
100 | google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
101 | google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
102 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
103 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
104 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
105 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
106 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
107 | nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
108 | rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
109 | 


--------------------------------------------------------------------------------
/cmd/arrow.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"container/heap"
  5 | 	"fmt"
  6 | 	"slices"
  7 | 
  8 | 	log "github.com/sirupsen/logrus"
  9 | )
 10 | 
 11 | type priorityQueueItem struct {
 12 | 	coord    gridCoord
 13 | 	priority int
 14 | 	index    int
 15 | }
 16 | 
 17 | type priorityQueue []*priorityQueueItem
 18 | 
 19 | func (pq priorityQueue) Len() int { return len(pq) }
 20 | 
 21 | func (pq priorityQueue) Less(i, j int) bool {
 22 | 	return pq[i].priority < pq[j].priority
 23 | }
 24 | 
 25 | func (pq priorityQueue) Swap(i, j int) {
 26 | 	pq[i], pq[j] = pq[j], pq[i]
 27 | 	pq[i].index = i
 28 | 	pq[j].index = j
 29 | }
 30 | 
 31 | func (pq *priorityQueue) Push(x interface{}) {
 32 | 	n := len(*pq)
 33 | 	item := x.(*priorityQueueItem)
 34 | 	item.index = n
 35 | 	*pq = append(*pq, item)
 36 | }
 37 | 
 38 | func (pq *priorityQueue) Pop() interface{} {
 39 | 	old := *pq
 40 | 	n := len(old)
 41 | 	item := old[n-1]
 42 | 	old[n-1] = nil
 43 | 	item.index = -1
 44 | 	*pq = old[0 : n-1]
 45 | 	return item
 46 | }
 47 | 
 48 | func heuristic(a, b gridCoord) int {
 49 | 	absX := Abs(a.x - b.x)
 50 | 	absY := Abs(a.y - b.y)
 51 | 	if absX == 0 || absY == 0 {
 52 | 		return absX + absY
 53 | 	} else {
 54 | 		// Punish for taking extra corner, we prefer straight (less complex) lines
 55 | 		return absX + absY + 1
 56 | 	}
 57 | }
 58 | 
 59 | func (g *graph) getPath(from gridCoord, to gridCoord) ([]gridCoord, error) {
 60 | 	pq := &priorityQueue{}
 61 | 	heap.Init(pq)
 62 | 	heap.Push(pq, &priorityQueueItem{coord: from, priority: 0})
 63 | 
 64 | 	costSoFar := map[gridCoord]int{from: 0}
 65 | 	cameFrom := map[gridCoord]*gridCoord{from: nil}
 66 | 
 67 | 	directions := []gridCoord{{1, 0}, {-1, 0}, {0, 1}, {0, -1}}
 68 | 
 69 | 	for pq.Len() > 0 {
 70 | 		current := heap.Pop(pq).(*priorityQueueItem).coord
 71 | 
 72 | 		if current.Equals(to) {
 73 | 			path := []gridCoord{}
 74 | 			for c := &current; c != nil; c = cameFrom[*c] {
 75 | 				path = append([]gridCoord{*c}, path...)
 76 | 			}
 77 | 			log.Debugf("Found it! path: %v", path)
 78 | 			return path, nil
 79 | 		}
 80 | 
 81 | 		for _, dir := range directions {
 82 | 			next := gridCoord{x: current.x + dir.x, y: current.y + dir.y}
 83 | 			if !g.isFreeInGrid(next) && !next.Equals(to) {
 84 | 				continue
 85 | 			}
 86 | 
 87 | 			newCost := costSoFar[current] + 1
 88 | 			if cost, ok := costSoFar[next]; !ok || newCost < cost {
 89 | 				costSoFar[next] = newCost
 90 | 				priority := newCost + heuristic(next, to)
 91 | 				heap.Push(pq, &priorityQueueItem{coord: next, priority: priority})
 92 | 				cameFrom[next] = &current
 93 | 			}
 94 | 		}
 95 | 	}
 96 | 
 97 | 	return nil, fmt.Errorf("no path found")
 98 | }
 99 | 
100 | func (g *graph) isFreeInGrid(c gridCoord) bool {
101 | 	// We'll fix it later if we overshoot the grid size
102 | 	if c.x < 0 || c.y < 0 {
103 | 		return false
104 | 	}
105 | 	return g.grid[c] == nil
106 | }
107 | 
108 | func (g *graph) drawArrow(from gridCoord, to gridCoord, e *edge) (*drawing, *drawing, *drawing, *drawing, *drawing) {
109 | 	if len(e.path) == 0 {
110 | 		return nil, nil, nil, nil, nil
111 | 	}
112 | 	log.Debugf("Drawing arrow from %v to %v with path %v", from, to, e.path)
113 | 	dLabel := g.drawArrowLabel(e)
114 | 	dPath, linesDrawn, lineDirs := g.drawPath(e.path)
115 | 	dBoxStart := g.drawBoxStart(e.path, linesDrawn[0])
116 | 	dArrowHead := g.drawArrowHead(linesDrawn[len(linesDrawn)-1], lineDirs[len(lineDirs)-1])
117 | 	dCorners := g.drawCorners(e.path)
118 | 	return dPath, dBoxStart, dArrowHead, dCorners, dLabel
119 | }
120 | 
121 | func mergePath(path []gridCoord) []gridCoord {
122 | 	// If two steps are in the same direction, merge them to one step.
123 | 	if len(path) <= 2 {
124 | 		return path
125 | 	}
126 | 	indexToRemove := []int{}
127 | 	step0 := path[0]
128 | 	step1 := path[1]
129 | 	for idx, step2 := range path[2:] {
130 | 		prevDir := determineDirection(genericCoord(step0), genericCoord(step1))
131 | 		dir := determineDirection(genericCoord(step1), genericCoord(step2))
132 | 		if prevDir == dir {
133 | 			indexToRemove = append(indexToRemove, idx+1) // +1 because we skip the initial step
134 | 		}
135 | 		step0 = step1
136 | 		step1 = step2
137 | 	}
138 | 	newPath := []gridCoord{}
139 | 	for idx, step := range path {
140 | 		if !slices.Contains(indexToRemove, idx) {
141 | 			newPath = append(newPath, step)
142 | 		}
143 | 	}
144 | 	log.Debugf("Reduced path from %v to %v", path, newPath)
145 | 	return newPath
146 | }
147 | 
148 | func (g *graph) drawPath(path []gridCoord) (*drawing, [][]drawingCoord, []direction) {
149 | 	d := copyCanvas(g.drawing)
150 | 	previousCoord := path[0]
151 | 	linesDrawn := make([][]drawingCoord, 0)
152 | 	lineDirs := make([]direction, 0)
153 | 	var previousDrawingCoord drawingCoord
154 | 	for _, nextCoord := range path[1:] {
155 | 		previousDrawingCoord = g.gridToDrawingCoord(previousCoord, nil)
156 | 		nextDrawingCoord := g.gridToDrawingCoord(nextCoord, nil)
157 | 		if previousDrawingCoord.Equals(nextDrawingCoord) {
158 | 			log.Debugf("Skipping drawing identical line on %v", nextCoord)
159 | 			continue
160 | 		}
161 | 		dir := determineDirection(genericCoord(previousCoord), genericCoord(nextCoord))
162 | 		s := g.drawLine(d, previousDrawingCoord, nextDrawingCoord, 1, -1)
163 | 		if len(s) == 0 {
164 | 			// drawLine may return no coords if offsets collapse the line. Use at least one point so arrow and junction logic
165 | 			// can still infer a direction.
166 | 			s = append(s, previousDrawingCoord)
167 | 		}
168 | 		linesDrawn = append(linesDrawn, s)
169 | 		lineDirs = append(lineDirs, dir)
170 | 		previousCoord = nextCoord
171 | 	}
172 | 	return d, linesDrawn, lineDirs
173 | }
174 | 
175 | func (g *graph) drawBoxStart(path []gridCoord, firstLine []drawingCoord) *drawing {
176 | 	d := *(copyCanvas(g.drawing))
177 | 	from := firstLine[0]
178 | 	dir := determineDirection(genericCoord(path[0]), genericCoord(path[1]))
179 | 	log.Debugf("Drawing box start at %v with direction %v for line %v", from, dir, path)
180 | 
181 | 	if g.useAscii {
182 | 		return &d
183 | 	}
184 | 
185 | 	switch dir {
186 | 	case Up:
187 | 		d[from.x][from.y+1] = "┴"
188 | 	case Down:
189 | 		d[from.x][from.y-1] = "┬"
190 | 	case Left:
191 | 		d[from.x+1][from.y] = "┤"
192 | 	case Right:
193 | 		d[from.x-1][from.y] = "├"
194 | 	}
195 | 	return &d
196 | }
197 | 
198 | func (g *graph) drawArrowHead(line []drawingCoord, fallback direction) *drawing {
199 | 	d := *(copyCanvas(g.drawing))
200 | 	if len(line) == 0 {
201 | 		return &d
202 | 	}
203 | 	from := line[0]
204 | 	lastPos := line[len(line)-1]
205 | 	dir := determineDirection(genericCoord(from), genericCoord(lastPos))
206 | 	if len(line) == 1 || dir == Middle {
207 | 		dir = fallback
208 | 	}
209 | 
210 | 	var char string
211 | 	if !g.useAscii {
212 | 		switch dir {
213 | 		case Up:
214 | 			char = "▲"
215 | 		case Down:
216 | 			char = "▼"
217 | 		case Left:
218 | 			char = "◄"
219 | 		case Right:
220 | 			char = "►"
221 | 		case UpperRight:
222 | 			char = "◥"
223 | 		case UpperLeft:
224 | 			char = "◤"
225 | 		case LowerRight:
226 | 			char = "◢"
227 | 		case LowerLeft:
228 | 			char = "◣"
229 | 		default:
230 | 			switch fallback {
231 | 			case Up:
232 | 				char = "▲"
233 | 			case Down:
234 | 				char = "▼"
235 | 			case Left:
236 | 				char = "◄"
237 | 			case Right:
238 | 				char = "►"
239 | 			case UpperRight:
240 | 				char = "◥"
241 | 			case UpperLeft:
242 | 				char = "◤"
243 | 			case LowerRight:
244 | 				char = "◢"
245 | 			case LowerLeft:
246 | 				char = "◣"
247 | 			default:
248 | 				char = "●"
249 | 			}
250 | 		}
251 | 	} else {
252 | 		switch dir {
253 | 		case Up:
254 | 			char = "^"
255 | 		case Down:
256 | 			char = "v"
257 | 		case Left:
258 | 			char = "<"
259 | 		case Right:
260 | 			char = ">"
261 | 		default:
262 | 			switch fallback {
263 | 			case Up:
264 | 				char = "^"
265 | 			case Down:
266 | 				char = "v"
267 | 			case Left:
268 | 				char = "<"
269 | 			case Right:
270 | 				char = ">"
271 | 			default:
272 | 				char = "*"
273 | 			}
274 | 		}
275 | 	}
276 | 
277 | 	d[lastPos.x][lastPos.y] = char
278 | 	return &d
279 | }
280 | 
281 | func (g *graph) drawCorners(path []gridCoord) *drawing {
282 | 	d := copyCanvas(g.drawing)
283 | 	for idx, coord := range path {
284 | 		// Skip the first and last step
285 | 		if idx == 0 || idx == len(path)-1 {
286 | 			continue
287 | 		}
288 | 		drawingCoord := g.gridToDrawingCoord(coord, nil)
289 | 
290 | 		prevDir := determineDirection(genericCoord(path[idx-1]), genericCoord(coord))
291 | 		nextDir := determineDirection(genericCoord(coord), genericCoord(path[idx+1]))
292 | 
293 | 		var corner string
294 | 		if !g.useAscii {
295 | 			switch {
296 | 			case (prevDir == Right && nextDir == Down) || (prevDir == Up && nextDir == Left):
297 | 				corner = "┐"
298 | 			case (prevDir == Right && nextDir == Up) || (prevDir == Down && nextDir == Left):
299 | 				corner = "┘"
300 | 			case (prevDir == Left && nextDir == Down) || (prevDir == Up && nextDir == Right):
301 | 				corner = "┌"
302 | 			case (prevDir == Left && nextDir == Up) || (prevDir == Down && nextDir == Right):
303 | 				corner = "└"
304 | 			default:
305 | 				corner = "+"
306 | 			}
307 | 		} else {
308 | 			corner = "+"
309 | 		}
310 | 
311 | 		(*d)[drawingCoord.x][drawingCoord.y] = corner
312 | 	}
313 | 	return d
314 | }
315 | 
316 | func (g *graph) drawArrowLabel(e *edge) *drawing {
317 | 	d := copyCanvas(g.drawing)
318 | 	lenLabel := len(e.text)
319 | 	if lenLabel == 0 {
320 | 		return d
321 | 	}
322 | 
323 | 	log.Debugf("Drawing text '%s' on gridline %v", e.text, e.labelLine)
324 | 	d.drawTextOnLine(g.lineToDrawing(e.labelLine), e.text)
325 | 	return d
326 | }
327 | 
328 | func (d *drawing) drawTextOnLine(line []drawingCoord, label string) {
329 | 	// Write text in middle of the line
330 | 	//  123456789
331 | 	// |---------|
332 | 	//     123
333 | 	log.Debugf("Drawing text '%s' on drawingline %v", label, line)
334 | 	var minX, maxX, minY, maxY int
335 | 	if line[0].x > line[1].x {
336 | 		minX = line[1].x
337 | 		maxX = line[0].x
338 | 	} else {
339 | 		minX = line[0].x
340 | 		maxX = line[1].x
341 | 	}
342 | 	if line[0].y > line[1].y {
343 | 		minY = line[1].y
344 | 		maxY = line[0].y
345 | 	} else {
346 | 		minY = line[0].y
347 | 		maxY = line[1].y
348 | 	}
349 | 	middleX := minX + (maxX-minX)/2
350 | 	middleY := minY + (maxY-minY)/2
351 | 	startLabelCoord := drawingCoord{x: middleX - len(label)/2, y: middleY}
352 | 	d.drawText(startLabelCoord, label)
353 | }
354 | 


--------------------------------------------------------------------------------
/static/style.css:
--------------------------------------------------------------------------------
  1 | :root {
  2 |     --bg-primary: #ffffff;
  3 |     --bg-secondary: #f8f9fa;
  4 |     --bg-tertiary: #e9ecef;
  5 |     --text-primary: #212529;
  6 |     --text-secondary: #6c757d;
  7 |     --border-color: #dee2e6;
  8 |     --accent-color: #007bff;
  9 |     --accent-hover: #0056b3;
 10 |     --shadow-sm: 0 2px 4px rgba(0, 0, 0, 0.1);
 11 |     --shadow-md: 0 4px 6px rgba(0, 0, 0, 0.1);
 12 |     --radius: 8px;
 13 |     --radius-sm: 4px;
 14 | }
 15 | 
 16 | /* Dark mode variables */
 17 | :root[data-theme="dark"] {
 18 |     --bg-primary: #1a1a1a;
 19 |     --bg-secondary: #2d2d2d;
 20 |     --bg-tertiary: #3a3a3a;
 21 |     --text-primary: #e9ecef;
 22 |     --text-secondary: #adb5bd;
 23 |     --border-color: #495057;
 24 |     --accent-color: #4dabf7;
 25 |     --accent-hover: #339af0;
 26 |     --shadow-sm: 0 2px 4px rgba(0, 0, 0, 0.3);
 27 |     --shadow-md: 0 4px 6px rgba(0, 0, 0, 0.3);
 28 | }
 29 | 
 30 | /* System preference (only applies if no manual theme is set) */
 31 | @media (prefers-color-scheme: dark) {
 32 |     :root:not([data-theme]) {
 33 |         --bg-primary: #1a1a1a;
 34 |         --bg-secondary: #2d2d2d;
 35 |         --bg-tertiary: #3a3a3a;
 36 |         --text-primary: #e9ecef;
 37 |         --text-secondary: #adb5bd;
 38 |         --border-color: #495057;
 39 |         --accent-color: #4dabf7;
 40 |         --accent-hover: #339af0;
 41 |         --shadow-sm: 0 2px 4px rgba(0, 0, 0, 0.3);
 42 |         --shadow-md: 0 4px 6px rgba(0, 0, 0, 0.3);
 43 |     }
 44 | }
 45 | 
 46 | * {
 47 |     box-sizing: border-box;
 48 | }
 49 | 
 50 | body {
 51 |     font-family: 'Roboto', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
 52 |     margin: 0;
 53 |     padding: 0;
 54 |     background-color: var(--bg-secondary);
 55 |     color: var(--text-primary);
 56 |     line-height: 1.6;
 57 |     min-height: 100vh;
 58 | }
 59 | 
 60 | .container {
 61 |     max-width: 1400px;
 62 |     margin: 0 auto;
 63 |     padding: 20px;
 64 | }
 65 | 
 66 | header {
 67 |     display: flex;
 68 |     justify-content: space-between;
 69 |     align-items: center;
 70 |     margin-bottom: 30px;
 71 |     padding-bottom: 20px;
 72 |     border-bottom: 2px solid var(--border-color);
 73 | }
 74 | 
 75 | .header-actions {
 76 |     display: flex;
 77 |     align-items: center;
 78 |     gap: 12px;
 79 | }
 80 | 
 81 | h1 {
 82 |     margin: 0;
 83 |     font-size: 2rem;
 84 |     font-weight: 700;
 85 | }
 86 | 
 87 | h1 small {
 88 |     font-size: 0.5em;
 89 |     color: var(--text-secondary);
 90 |     font-weight: 400;
 91 | }
 92 | 
 93 | .github-link {
 94 |     display: flex;
 95 |     align-items: center;
 96 |     gap: 8px;
 97 |     text-decoration: none;
 98 |     color: var(--text-primary);
 99 |     padding: 8px 12px;
100 |     border-radius: var(--radius-sm);
101 |     transition: background-color 0.2s;
102 | }
103 | 
104 | .github-link:hover {
105 |     background-color: var(--bg-tertiary);
106 | }
107 | 
108 | .github-link img {
109 |     width: 24px;
110 |     height: 24px;
111 | }
112 | 
113 | .toolbar {
114 |     background-color: var(--bg-primary);
115 |     padding: 20px;
116 |     border-radius: var(--radius);
117 |     box-shadow: var(--shadow-sm);
118 |     margin-bottom: 20px;
119 | }
120 | 
121 | .toolbar-section {
122 |     display: flex;
123 |     flex-wrap: wrap;
124 |     gap: 20px;
125 |     align-items: center;
126 | }
127 | 
128 | .toolbar-group {
129 |     display: flex;
130 |     align-items: center;
131 |     gap: 10px;
132 | }
133 | 
134 | .toolbar-group label {
135 |     font-weight: 500;
136 |     color: var(--text-primary);
137 |     white-space: nowrap;
138 | }
139 | 
140 | .slider-container {
141 |     display: flex;
142 |     align-items: center;
143 |     gap: 10px;
144 | }
145 | 
146 | .slider-value {
147 |     background-color: var(--bg-secondary);
148 |     padding: 4px 10px;
149 |     border: 1px solid var(--border-color);
150 |     border-radius: var(--radius-sm);
151 |     font-family: 'Roboto Mono', monospace;
152 |     font-size: 0.9rem;
153 |     min-width: 40px;
154 |     text-align: center;
155 | }
156 | 
157 | input[type="range"] {
158 |     width: 150px;
159 |     cursor: pointer;
160 | }
161 | 
162 | input[type="checkbox"] {
163 |     width: 18px;
164 |     height: 18px;
165 |     cursor: pointer;
166 | }
167 | 
168 | .example-buttons {
169 |     display: flex;
170 |     flex-wrap: wrap;
171 |     gap: 10px;
172 |     margin-top: 15px;
173 | }
174 | 
175 | .example-button {
176 |     padding: 8px 16px;
177 |     border: none;
178 |     border-radius: var(--radius-sm);
179 |     cursor: pointer;
180 |     font-family: 'Roboto', sans-serif;
181 |     font-size: 0.9rem;
182 |     transition: transform 0.2s, box-shadow 0.2s;
183 | }
184 | 
185 | .example-button:hover {
186 |     transform: translateY(-2px);
187 |     box-shadow: var(--shadow-md);
188 | }
189 | 
190 | .main-content {
191 |     display: grid;
192 |     grid-template-columns: 1fr 1fr;
193 |     gap: 20px;
194 |     margin-bottom: 30px;
195 | }
196 | 
197 | @media (max-width: 1024px) {
198 |     .main-content {
199 |         grid-template-columns: 1fr;
200 |     }
201 | }
202 | 
203 | .editor-pane,
204 | .preview-pane {
205 |     background-color: var(--bg-primary);
206 |     border-radius: var(--radius);
207 |     box-shadow: var(--shadow-sm);
208 |     padding: 20px;
209 |     display: flex;
210 |     flex-direction: column;
211 | }
212 | 
213 | .pane-header {
214 |     display: flex;
215 |     justify-content: space-between;
216 |     align-items: center;
217 |     margin-bottom: 15px;
218 |     padding-bottom: 10px;
219 |     border-bottom: 1px solid var(--border-color);
220 |     position: relative;
221 | }
222 | 
223 | .pane-title {
224 |     font-weight: 600;
225 |     font-size: 1.1rem;
226 |     margin: 0;
227 |     color: var(--text-primary);
228 | }
229 | 
230 | textarea {
231 |     width: 100%;
232 |     flex: 1;
233 |     min-height: 400px;
234 |     padding: 15px;
235 |     border: 2px solid var(--border-color);
236 |     border-radius: var(--radius-sm);
237 |     background-color: var(--bg-primary);
238 |     color: var(--text-primary);
239 |     font-family: 'Roboto Mono', monospace;
240 |     font-size: 0.95rem;
241 |     resize: vertical;
242 |     transition: border-color 0.2s, box-shadow 0.2s;
243 |     cursor: text;
244 | }
245 | 
246 | textarea:focus {
247 |     outline: none;
248 |     border-color: var(--accent-color);
249 |     box-shadow: 0 0 0 3px rgba(0, 123, 255, 0.1);
250 | }
251 | 
252 | textarea::placeholder {
253 |     color: var(--text-secondary);
254 | }
255 | 
256 | textarea::placeholder {
257 |     color: var(--text-secondary);
258 | }
259 | 
260 | .result-container {
261 |     position: relative;
262 |     flex: 1;
263 |     min-height: 400px;
264 | }
265 | 
266 | .code-block {
267 |     width: 100%;
268 |     height: 100%;
269 |     padding: 15px;
270 |     background-color: var(--bg-tertiary);
271 |     border: 2px solid var(--border-color);
272 |     border-radius: var(--radius-sm);
273 |     font-family: 'Roboto Mono', monospace;
274 |     font-size: 0.9rem;
275 |     white-space: pre;
276 |     line-height: 1;
277 |     overflow: auto;
278 |     color: var(--text-primary);
279 |     cursor: default;
280 |     user-select: text;
281 | }
282 | 
283 | .copy-button {
284 |     position: absolute;
285 |     top: 10px;
286 |     right: 10px;
287 |     padding: 6px 12px;
288 |     border: none;
289 |     border-radius: var(--radius-sm);
290 |     background-color: var(--accent-color);
291 |     color: white;
292 |     cursor: pointer;
293 |     font-family: 'Roboto', sans-serif;
294 |     font-size: 0.85rem;
295 |     transition: background-color 0.2s;
296 |     z-index: 10;
297 | }
298 | 
299 | .copy-button:hover {
300 |     background-color: var(--accent-hover);
301 | }
302 | 
303 | button {
304 |     padding: 10px 20px;
305 |     border: none;
306 |     border-radius: var(--radius-sm);
307 |     background-color: var(--accent-color);
308 |     color: white;
309 |     cursor: pointer;
310 |     font-family: 'Roboto', sans-serif;
311 |     font-size: 1rem;
312 |     transition: background-color 0.2s;
313 | }
314 | 
315 | button:hover {
316 |     background-color: var(--accent-hover);
317 | }
318 | 
319 | button:disabled {
320 |     opacity: 0.6;
321 |     cursor: not-allowed;
322 | }
323 | 
324 | .instructions-section {
325 |     background-color: var(--bg-primary);
326 |     padding: 30px;
327 |     border-radius: var(--radius);
328 |     box-shadow: var(--shadow-sm);
329 |     margin-top: 30px;
330 | }
331 | 
332 | .instructions-section h2 {
333 |     margin-top: 0;
334 |     color: var(--text-primary);
335 |     font-size: 1.5rem;
336 | }
337 | 
338 | .instructions-section p {
339 |     color: var(--text-secondary);
340 |     margin-bottom: 20px;
341 | }
342 | 
343 | .instruction-block {
344 |     margin-bottom: 25px;
345 | }
346 | 
347 | .instruction-block h3 {
348 |     margin-top: 0;
349 |     margin-bottom: 15px;
350 |     color: var(--text-primary);
351 |     font-size: 1.2rem;
352 | }
353 | 
354 | .code-example {
355 |     position: relative;
356 |     background-color: var(--bg-secondary);
357 |     border: 1px solid var(--border-color);
358 |     border-radius: var(--radius-sm);
359 |     padding: 15px;
360 |     margin-top: 10px;
361 | }
362 | 
363 | .code-example pre {
364 |     margin: 0;
365 |     font-family: 'Roboto Mono', monospace;
366 |     font-size: 0.9rem;
367 |     color: var(--text-primary);
368 |     overflow-x: auto;
369 | }
370 | 
371 | .code-example code {
372 |     font-family: 'Roboto Mono', monospace;
373 | }
374 | 
375 | hr {
376 |     border: none;
377 |     border-top: 1px solid var(--border-color);
378 |     margin: 30px 0;
379 | }
380 | 
381 | .loading {
382 |     opacity: 0.6;
383 |     pointer-events: none;
384 | }
385 | 
386 | .theme-toggle {
387 |     display: flex;
388 |     align-items: center;
389 |     gap: 8px;
390 |     padding: 6px 12px;
391 |     border: 1px solid var(--border-color);
392 |     border-radius: var(--radius-sm);
393 |     background-color: var(--bg-secondary);
394 |     color: var(--text-primary);
395 |     cursor: pointer;
396 |     font-family: 'Roboto', sans-serif;
397 |     font-size: 0.9rem;
398 |     transition: background-color 0.2s, border-color 0.2s;
399 | }
400 | 
401 | .theme-toggle:hover {
402 |     background-color: var(--bg-tertiary);
403 |     border-color: var(--accent-color);
404 | }
405 | 
406 | .theme-toggle svg {
407 |     width: 18px;
408 |     height: 18px;
409 |     fill: currentColor;
410 | }
411 | 
412 | 


--------------------------------------------------------------------------------
/cmd/parse.go:
--------------------------------------------------------------------------------
  1 | package cmd
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"fmt"
  6 | 	"regexp"
  7 | 	"strconv"
  8 | 	"strings"
  9 | 
 10 | 	"github.com/elliotchance/orderedmap/v2"
 11 | 	log "github.com/sirupsen/logrus"
 12 | )
 13 | 
 14 | type graphProperties struct {
 15 | 	data           *orderedmap.OrderedMap[string, []textEdge]
 16 | 	styleClasses   *map[string]styleClass
 17 | 	graphDirection string
 18 | 	styleType      string
 19 | 	paddingX       int
 20 | 	paddingY       int
 21 | 	subgraphs      []*textSubgraph
 22 | 	useAscii       bool
 23 | }
 24 | 
 25 | type textNode struct {
 26 | 	name       string
 27 | 	styleClass string
 28 | }
 29 | 
 30 | type textEdge struct {
 31 | 	parent textNode
 32 | 	child  textNode
 33 | 	label  string
 34 | }
 35 | 
 36 | type textSubgraph struct {
 37 | 	name     string
 38 | 	nodes    []string
 39 | 	parent   *textSubgraph
 40 | 	children []*textSubgraph
 41 | }
 42 | 
 43 | func parseNode(line string) textNode {
 44 | 	// Trim any whitespace from the line that might be left after comment removal
 45 | 	trimmedLine := strings.TrimSpace(line)
 46 | 
 47 | 	nodeWithClass, _ := regexp.Compile(`^(.+):::(.+)$`)
 48 | 
 49 | 	if match := nodeWithClass.FindStringSubmatch(trimmedLine); match != nil {
 50 | 		return textNode{strings.TrimSpace(match[1]), strings.TrimSpace(match[2])}
 51 | 	} else {
 52 | 		return textNode{trimmedLine, ""}
 53 | 	}
 54 | }
 55 | 
 56 | func parseStyleClass(matchedLine []string) styleClass {
 57 | 	className := matchedLine[0]
 58 | 	styles := matchedLine[1]
 59 | 	// Styles are comma separated and key-values are separated by colon
 60 | 	// Example: fill:#f9f,stroke:#333,stroke-width:4px
 61 | 	styleMap := make(map[string]string)
 62 | 	for _, style := range strings.Split(styles, ",") {
 63 | 		kv := strings.Split(style, ":")
 64 | 		styleMap[kv[0]] = kv[1]
 65 | 	}
 66 | 	return styleClass{className, styleMap}
 67 | }
 68 | 
 69 | func setArrowWithLabel(lhs, rhs []textNode, label string, data *orderedmap.OrderedMap[string, []textEdge]) []textNode {
 70 | 	log.Debug("Setting arrow from ", lhs, " to ", rhs, " with label ", label)
 71 | 	for _, l := range lhs {
 72 | 		for _, r := range rhs {
 73 | 			setData(l, textEdge{l, r, label}, data)
 74 | 		}
 75 | 	}
 76 | 	return rhs
 77 | }
 78 | 
 79 | func setArrow(lhs, rhs []textNode, data *orderedmap.OrderedMap[string, []textEdge]) []textNode {
 80 | 	return setArrowWithLabel(lhs, rhs, "", data)
 81 | }
 82 | 
 83 | func addNode(node textNode, data *orderedmap.OrderedMap[string, []textEdge]) {
 84 | 	if _, ok := data.Get(node.name); !ok {
 85 | 		data.Set(node.name, []textEdge{})
 86 | 	}
 87 | }
 88 | 
 89 | func setData(parent textNode, edge textEdge, data *orderedmap.OrderedMap[string, []textEdge]) {
 90 | 	// Check if the parent is in the map
 91 | 	if children, ok := data.Get(parent.name); ok {
 92 | 		// If it is, append the child to the list of children
 93 | 		data.Set(parent.name, append(children, edge))
 94 | 	} else {
 95 | 		// If it isn't, add it to the map
 96 | 		data.Set(parent.name, []textEdge{edge})
 97 | 	}
 98 | 	// Check if the child is in the map
 99 | 	if _, ok := data.Get(edge.child.name); ok {
100 | 		// If it is, do nothing
101 | 	} else {
102 | 		// If it isn't, add it to the map
103 | 		data.Set(edge.child.name, []textEdge{})
104 | 	}
105 | }
106 | 
107 | func (gp *graphProperties) parseString(line string) ([]textNode, error) {
108 | 	log.Debugf("Parsing line: %v", line)
109 | 	var lhs, rhs []textNode
110 | 	var err error
111 | 	// Patterns are matched in order
112 | 	patterns := []struct {
113 | 		regex   *regexp.Regexp
114 | 		handler func([]string) ([]textNode, error)
115 | 	}{
116 | 		{
117 | 			regex: regexp.MustCompile(`^\s*$`),
118 | 			handler: func(match []string) ([]textNode, error) {
119 | 				// Ignore empty lines
120 | 				return []textNode{}, nil
121 | 			},
122 | 		},
123 | 		{
124 | 			regex: regexp.MustCompile(`^(.+)\s+-->\s+(.+)$`),
125 | 			handler: func(match []string) ([]textNode, error) {
126 | 				if lhs, err = gp.parseString(match[0]); err != nil {
127 | 					lhs = []textNode{parseNode(match[0])}
128 | 				}
129 | 				if rhs, err = gp.parseString(match[1]); err != nil {
130 | 					rhs = []textNode{parseNode(match[1])}
131 | 				}
132 | 				return setArrow(lhs, rhs, gp.data), nil
133 | 			},
134 | 		},
135 | 		{
136 | 			regex: regexp.MustCompile(`^(.+)\s+-->\|(.+)\|\s+(.+)$`),
137 | 			handler: func(match []string) ([]textNode, error) {
138 | 				if lhs, err = gp.parseString(match[0]); err != nil {
139 | 					lhs = []textNode{parseNode(match[0])}
140 | 				}
141 | 				if rhs, err = gp.parseString(match[2]); err != nil {
142 | 					rhs = []textNode{parseNode(match[2])}
143 | 				}
144 | 				return setArrowWithLabel(lhs, rhs, match[1], gp.data), nil
145 | 			},
146 | 		},
147 | 		{
148 | 			regex: regexp.MustCompile(`^classDef\s+(.+)\s+(.+)$`),
149 | 			handler: func(match []string) ([]textNode, error) {
150 | 				s := parseStyleClass(match)
151 | 				(*gp.styleClasses)[s.name] = s
152 | 				return []textNode{}, nil
153 | 			},
154 | 		},
155 | 		{
156 | 			regex: regexp.MustCompile(`^(.+) & (.+)$`),
157 | 			handler: func(match []string) ([]textNode, error) {
158 | 				log.Debugf("Found & pattern node %v to %v", match[0], match[1])
159 | 				var node textNode
160 | 				if lhs, err = gp.parseString(match[0]); err != nil {
161 | 					node = parseNode(match[0])
162 | 					lhs = []textNode{node}
163 | 				}
164 | 				if rhs, err = gp.parseString(match[1]); err != nil {
165 | 					node = parseNode(match[1])
166 | 					rhs = []textNode{node}
167 | 				}
168 | 				return append(lhs, rhs...), nil
169 | 			},
170 | 		},
171 | 	}
172 | 	for _, pattern := range patterns {
173 | 		if match := pattern.regex.FindStringSubmatch(line); match != nil {
174 | 			nodes, err := pattern.handler(match[1:])
175 | 			if err == nil {
176 | 				return nodes, nil
177 | 			}
178 | 		}
179 | 	}
180 | 	return []textNode{}, errors.New("Could not parse line: " + line)
181 | }
182 | 
183 | func mermaidFileToMap(mermaid, styleType string) (*graphProperties, error) {
184 | 	// Allow split on both \n and the actual string "\n" for curl compatibility
185 | 	newlinePattern := regexp.MustCompile(`\n|\\n`)
186 | 	rawLines := newlinePattern.Split(string(mermaid), -1)
187 | 
188 | 	// Process lines to remove comments
189 | 	lines := []string{}
190 | 	for _, line := range rawLines {
191 | 		// Stop processing at "---" separator (used in test files)
192 | 		if line == "---" {
193 | 			break
194 | 		}
195 | 
196 | 		// Skip lines that start with %% (comment lines)
197 | 		if strings.HasPrefix(strings.TrimSpace(line), "%%") {
198 | 			continue
199 | 		}
200 | 
201 | 		// Remove inline comments (anything after %%) and trim resulting whitespace
202 | 		if idx := strings.Index(line, "%%"); idx != -1 {
203 | 			line = strings.TrimSpace(line[:idx])
204 | 		}
205 | 
206 | 		// Skip empty lines after comment removal
207 | 		if len(strings.TrimSpace(line)) > 0 {
208 | 			lines = append(lines, line)
209 | 		}
210 | 	}
211 | 
212 | 	data := orderedmap.NewOrderedMap[string, []textEdge]()
213 | 	styleClasses := make(map[string]styleClass)
214 | 	properties := graphProperties{
215 | 		data:           data,
216 | 		styleClasses:   &styleClasses,
217 | 		graphDirection: "",
218 | 		styleType:      styleType,
219 | 		paddingX:       paddingBetweenX,
220 | 		paddingY:       paddingBetweenY,
221 | 		subgraphs:      []*textSubgraph{},
222 | 	}
223 | 
224 | 	// Pick up optional padding directives before the graph definition
225 | 	paddingRegex := regexp.MustCompile(`^(?i)padding([xy])\s*=\s*(\d+)$`)
226 | 	for len(lines) > 0 {
227 | 		trimmed := strings.TrimSpace(lines[0])
228 | 		if trimmed == "" {
229 | 			lines = lines[1:]
230 | 			continue
231 | 		}
232 | 		if match := paddingRegex.FindStringSubmatch(trimmed); match != nil {
233 | 			paddingValue, err := strconv.Atoi(match[2])
234 | 			if err != nil {
235 | 				return &properties, err
236 | 			}
237 | 			if strings.EqualFold(match[1], "x") {
238 | 				properties.paddingX = paddingValue
239 | 			} else {
240 | 				properties.paddingY = paddingValue
241 | 			}
242 | 			lines = lines[1:]
243 | 			continue
244 | 		}
245 | 		break
246 | 	}
247 | 
248 | 	if len(lines) == 0 {
249 | 		return &properties, errors.New("missing graph definition")
250 | 	}
251 | 
252 | 	// First line should either say "graph TD" or "graph LR"
253 | 	switch lines[0] {
254 | 	case "graph LR", "flowchart LR":
255 | 		graphDirection = "LR"
256 | 	case "graph TD", "flowchart TD", "graph TB", "flowchart TB":
257 | 		graphDirection = "TD"
258 | 	default:
259 | 		return &properties, fmt.Errorf("unsupported graph type '%s'. Supported types: graph TD, graph TB, graph LR, flowchart TD, flowchart TB, flowchart LR", lines[0])
260 | 	}
261 | 	lines = lines[1:]
262 | 
263 | 	// Track subgraph context using a stack
264 | 	subgraphStack := []*textSubgraph{}
265 | 	subgraphRegex := regexp.MustCompile(`^\s*subgraph\s+(.+)$`)
266 | 	endRegex := regexp.MustCompile(`^\s*end\s*$`)
267 | 
268 | 	// Iterate over the lines
269 | 	for _, line := range lines {
270 | 		trimmedLine := strings.TrimSpace(line)
271 | 
272 | 		// Check for subgraph start
273 | 		if match := subgraphRegex.FindStringSubmatch(trimmedLine); match != nil {
274 | 			subgraphName := strings.TrimSpace(match[1])
275 | 			newSubgraph := &textSubgraph{
276 | 				name:     subgraphName,
277 | 				nodes:    []string{},
278 | 				children: []*textSubgraph{},
279 | 			}
280 | 
281 | 			// Set parent relationship if we're nested
282 | 			if len(subgraphStack) > 0 {
283 | 				parent := subgraphStack[len(subgraphStack)-1]
284 | 				newSubgraph.parent = parent
285 | 				parent.children = append(parent.children, newSubgraph)
286 | 			}
287 | 
288 | 			subgraphStack = append(subgraphStack, newSubgraph)
289 | 			properties.subgraphs = append(properties.subgraphs, newSubgraph)
290 | 			log.Debugf("Started subgraph %s", subgraphName)
291 | 			continue
292 | 		}
293 | 
294 | 		// Check for subgraph end
295 | 		if endRegex.MatchString(trimmedLine) {
296 | 			if len(subgraphStack) > 0 {
297 | 				closedSubgraph := subgraphStack[len(subgraphStack)-1]
298 | 				subgraphStack = subgraphStack[:len(subgraphStack)-1]
299 | 				log.Debugf("Ended subgraph %s", closedSubgraph.name)
300 | 			}
301 | 			continue
302 | 		}
303 | 
304 | 		// Remember nodes before parsing this line
305 | 		existingNodes := make(map[string]bool)
306 | 		for el := data.Front(); el != nil; el = el.Next() {
307 | 			existingNodes[el.Key] = true
308 | 		}
309 | 
310 | 		// Parse nodes and edges normally
311 | 		nodes, err := properties.parseString(line)
312 | 		if err != nil {
313 | 			log.Debugf("Parsing remaining text to node %v", line)
314 | 			node := parseNode(line)
315 | 			addNode(node, properties.data)
316 | 		} else {
317 | 			// Ensure all returned nodes are in the map
318 | 			for _, node := range nodes {
319 | 				addNode(node, properties.data)
320 | 			}
321 | 		}
322 | 
323 | 		// Add all new nodes to current subgraph(s)
324 | 		if len(subgraphStack) > 0 {
325 | 			for el := data.Front(); el != nil; el = el.Next() {
326 | 				nodeName := el.Key
327 | 				// If this is a new node (wasn't in existingNodes), add it to subgraph
328 | 				if !existingNodes[nodeName] {
329 | 					for _, sg := range subgraphStack {
330 | 						// Check if node is not already in the subgraph
331 | 						found := false
332 | 						for _, n := range sg.nodes {
333 | 							if n == nodeName {
334 | 								found = true
335 | 								break
336 | 							}
337 | 						}
338 | 						if !found {
339 | 							sg.nodes = append(sg.nodes, nodeName)
340 | 							log.Debugf("Added node %s to subgraph %s", nodeName, sg.name)
341 | 						}
342 | 					}
343 | 				}
344 | 			}
345 | 		}
346 | 	}
347 | 	return &properties, nil
348 | }
349 | 


--------------------------------------------------------------------------------
/internal/sequence/sequence_test.go:
--------------------------------------------------------------------------------
  1 | package sequence
  2 | 
  3 | import (
  4 | 	"strings"
  5 | 	"testing"
  6 | 	"unicode/utf8"
  7 | 
  8 | 	"github.com/AlexanderGrooff/mermaid-ascii/internal/diagram"
  9 | )
 10 | 
 11 | func TestParse(t *testing.T) {
 12 | 	tests := []struct {
 13 | 		name             string
 14 | 		input            string
 15 | 		wantParticipants int
 16 | 		wantMessages     int
 17 | 		wantErr          string
 18 | 	}{
 19 | 		{"empty input", "", 0, 0, "empty input"},
 20 | 		{"missing sequenceDiagram keyword", "A->>B: Hello", 0, 0, "expected \"sequenceDiagram\" keyword"},
 21 | 		{"only comments", "sequenceDiagram\n%% This is a comment\n%% Another comment", 0, 0, "no participants found"},
 22 | 		{"no participants", "sequenceDiagram", 0, 0, "no participants found"},
 23 | 		{"duplicate participant ID", "sequenceDiagram\nparticipant Alice\nparticipant Alice\nAlice->>Bob: Hi", 0, 0, "duplicate participant"},
 24 | 		{"minimal diagram", "sequenceDiagram\nA->>B: Hello", 2, 1, ""},
 25 | 		{"explicit participants", "sequenceDiagram\nparticipant Alice\nparticipant Bob\nAlice->>Bob: Hi", 2, 1, ""},
 26 | 		{"dotted arrow", "sequenceDiagram\nA-->>B: Response", 2, 1, ""},
 27 | 		{"self message", "sequenceDiagram\nA->>A: Self", 1, 1, ""},
 28 | 		{"multiple messages", "sequenceDiagram\nA->>B: 1\nB->>C: 2\nC-->>A: 3", 3, 3, ""},
 29 | 		{"with comments", "sequenceDiagram\n%% Comment\nA->>B: Hi %% inline comment", 2, 1, ""},
 30 | 	}
 31 | 
 32 | 	for _, tt := range tests {
 33 | 		t.Run(tt.name, func(t *testing.T) {
 34 | 			sd, err := Parse(tt.input)
 35 | 			if tt.wantErr != "" {
 36 | 				if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
 37 | 					t.Errorf("Expected error containing %q, got %v", tt.wantErr, err)
 38 | 				}
 39 | 				return
 40 | 			}
 41 | 			if err != nil {
 42 | 				t.Fatalf("Unexpected error: %v", err)
 43 | 			}
 44 | 			if len(sd.Participants) != tt.wantParticipants {
 45 | 				t.Errorf("Expected %d participants, got %d", tt.wantParticipants, len(sd.Participants))
 46 | 			}
 47 | 			if len(sd.Messages) != tt.wantMessages {
 48 | 				t.Errorf("Expected %d messages, got %d", tt.wantMessages, len(sd.Messages))
 49 | 			}
 50 | 		})
 51 | 	}
 52 | }
 53 | 
 54 | func TestIsSequenceDiagram(t *testing.T) {
 55 | 	tests := []struct {
 56 | 		input string
 57 | 		want  bool
 58 | 	}{
 59 | 		{"sequenceDiagram\nA->>B: Hello", true},
 60 | 		{"graph LR\nA-->B", false},
 61 | 		{"graph TD\nA-->B", false},
 62 | 		{"", false},
 63 | 		{"%% Just a comment", false},
 64 | 	}
 65 | 
 66 | 	for _, tt := range tests {
 67 | 		if got := IsSequenceDiagram(tt.input); got != tt.want {
 68 | 			t.Errorf("IsSequenceDiagram(%q) = %v, want %v", tt.input, got, tt.want)
 69 | 		}
 70 | 	}
 71 | }
 72 | 
 73 | func TestParticipantAlias(t *testing.T) {
 74 | 	tests := []struct {
 75 | 		name      string
 76 | 		input     string
 77 | 		wantID    string
 78 | 		wantLabel string
 79 | 	}{
 80 | 		{"simple alias", "sequenceDiagram\nparticipant A as Alice\nA->>A: Hello", "A", "Alice"},
 81 | 		{"no alias defaults to id", "sequenceDiagram\nparticipant Alice\nAlice->>Alice: Hi", "Alice", "Alice"},
 82 | 	}
 83 | 
 84 | 	for _, tt := range tests {
 85 | 		t.Run(tt.name, func(t *testing.T) {
 86 | 			d, err := Parse(tt.input)
 87 | 			if err != nil {
 88 | 				t.Fatalf("unexpected error: %v", err)
 89 | 			}
 90 | 			if len(d.Participants) == 0 {
 91 | 				t.Fatal("expected at least one participant")
 92 | 			}
 93 | 			p := d.Participants[0]
 94 | 			if p.ID != tt.wantID {
 95 | 				t.Errorf("ID = %q, want %q", p.ID, tt.wantID)
 96 | 			}
 97 | 			if p.Label != tt.wantLabel {
 98 | 				t.Errorf("Label = %q, want %q", p.Label, tt.wantLabel)
 99 | 			}
100 | 			config := diagram.DefaultConfig()
101 | 			output, err := Render(d, config)
102 | 			if err != nil {
103 | 				t.Fatalf("render error: %v", err)
104 | 			}
105 | 			if !strings.Contains(output, tt.wantLabel) {
106 | 				t.Errorf("output should contain label %q", tt.wantLabel)
107 | 			}
108 | 		})
109 | 	}
110 | }
111 | 
112 | func TestMessageRegex(t *testing.T) {
113 | 	tests := []struct {
114 | 		input     string
115 | 		wantFrom  string
116 | 		wantArrow string
117 | 		wantTo    string
118 | 		wantLabel string
119 | 		wantMatch bool
120 | 	}{
121 | 		{"A->>B: Hello", "A", "->>", "B", "Hello", true},
122 | 		{"A-->>B: Response", "A", "-->>", "B", "Response", true},
123 | 		{`"My Service"->>B: Test`, "My Service", "->>", "B", "Test", true},
124 | 		{"A->>B: ", "A", "->>", "B", "", true},
125 | 		{"A->B: Test", "", "", "", "", false},
126 | 		{"A->>B", "", "", "", "", false},
127 | 	}
128 | 
129 | 	for _, tt := range tests {
130 | 		match := messageRegex.FindStringSubmatch(tt.input)
131 | 		if !tt.wantMatch {
132 | 			if match != nil {
133 | 				t.Errorf("messageRegex should not match %q", tt.input)
134 | 			}
135 | 			continue
136 | 		}
137 | 		if match == nil {
138 | 			t.Fatalf("messageRegex failed to match: %q", tt.input)
139 | 		}
140 | 		gotFrom := match[2]
141 | 		if match[1] != "" {
142 | 			gotFrom = match[1]
143 | 		}
144 | 		gotArrow := match[3]
145 | 		gotTo := match[5]
146 | 		if match[4] != "" {
147 | 			gotTo = match[4]
148 | 		}
149 | 		gotLabel := match[6]
150 | 
151 | 		if gotFrom != tt.wantFrom || gotArrow != tt.wantArrow || gotTo != tt.wantTo || gotLabel != tt.wantLabel {
152 | 			t.Errorf("messageRegex(%q) = (%q, %q, %q, %q), want (%q, %q, %q, %q)",
153 | 				tt.input, gotFrom, gotArrow, gotTo, gotLabel, tt.wantFrom, tt.wantArrow, tt.wantTo, tt.wantLabel)
154 | 		}
155 | 	}
156 | }
157 | 
158 | func TestParticipantRegex(t *testing.T) {
159 | 	tests := []struct {
160 | 		input     string
161 | 		wantID    string
162 | 		wantAlias string
163 | 	}{
164 | 		{"participant Alice", "Alice", ""},
165 | 		{"participant Alice as A", "Alice", "A"},
166 | 		{`participant "My Service"`, "My Service", ""},
167 | 		{`participant "My Service" as Service`, "My Service", "Service"},
168 | 	}
169 | 
170 | 	for _, tt := range tests {
171 | 		match := participantRegex.FindStringSubmatch(tt.input)
172 | 		if match == nil {
173 | 			t.Fatalf("participantRegex failed to match: %q", tt.input)
174 | 		}
175 | 		gotID := match[2]
176 | 		if match[1] != "" {
177 | 			gotID = match[1]
178 | 		}
179 | 		gotAlias := match[3]
180 | 
181 | 		if gotID != tt.wantID || gotAlias != tt.wantAlias {
182 | 			t.Errorf("participantRegex(%q) = (%q, %q), want (%q, %q)",
183 | 				tt.input, gotID, gotAlias, tt.wantID, tt.wantAlias)
184 | 		}
185 | 	}
186 | }
187 | 
188 | func TestSplitLines(t *testing.T) {
189 | 	tests := []struct {
190 | 		input    string
191 | 		expected []string
192 | 	}{
193 | 		{"A->>B: Hello", []string{"A->>B: Hello"}},
194 | 		{"line1\nline2\nline3", []string{"line1", "line2", "line3"}},
195 | 		{"line1\\nline2\\nline3", []string{"line1", "line2", "line3"}},
196 | 		{"", []string{""}},
197 | 	}
198 | 
199 | 	for _, tt := range tests {
200 | 		result := diagram.SplitLines(tt.input)
201 | 		if len(result) != len(tt.expected) {
202 | 			t.Errorf("SplitLines(%q) len = %d, want %d", tt.input, len(result), len(tt.expected))
203 | 		}
204 | 	}
205 | }
206 | 
207 | func TestRemoveComments(t *testing.T) {
208 | 	tests := []struct {
209 | 		input    []string
210 | 		expected []string
211 | 	}{
212 | 		{[]string{"A->>B: Hello", "B-->>A: Hi"}, []string{"A->>B: Hello", "B-->>A: Hi"}},
213 | 		{[]string{"%% This is a comment", "A->>B: Hello"}, []string{"A->>B: Hello"}},
214 | 		{[]string{"A->>B: Hello %% inline comment", "B-->>A: Hi"}, []string{"A->>B: Hello", "B-->>A: Hi"}},
215 | 	}
216 | 
217 | 	for _, tt := range tests {
218 | 		result := diagram.RemoveComments(tt.input)
219 | 		if len(result) != len(tt.expected) {
220 | 			t.Errorf("RemoveComments() len = %d, want %d", len(result), len(tt.expected))
221 | 		}
222 | 	}
223 | }
224 | 
225 | func TestArrowTypeString(t *testing.T) {
226 | 	if SolidArrow.String() != "solid" {
227 | 		t.Errorf("SolidArrow.String() = %q, want \"solid\"", SolidArrow.String())
228 | 	}
229 | 	if DottedArrow.String() != "dotted" {
230 | 		t.Errorf("DottedArrow.String() = %q, want \"dotted\"", DottedArrow.String())
231 | 	}
232 | }
233 | 
234 | func FuzzParseSequenceDiagram(f *testing.F) {
235 | 	f.Add("sequenceDiagram\nA->>B: Hello")
236 | 	f.Add("sequenceDiagram\nparticipant Alice\nAlice->>Bob: Hi")
237 | 	f.Add("sequenceDiagram\nA-->>B: Response")
238 | 	f.Add("sequenceDiagram\nA->>A: Self")
239 | 
240 | 	f.Fuzz(func(t *testing.T, input string) {
241 | 		sd, err := Parse(input)
242 | 		if err != nil {
243 | 			return
244 | 		}
245 | 
246 | 		for i, p := range sd.Participants {
247 | 			if p.Index != i {
248 | 				t.Errorf("Participant %q has incorrect index: got %d, expected %d", p.ID, p.Index, i)
249 | 			}
250 | 			if p.ID == "" {
251 | 				t.Errorf("Participant at index %d has empty ID", i)
252 | 			}
253 | 			if p.Label == "" {
254 | 				t.Errorf("Participant %q has empty label", p.ID)
255 | 			}
256 | 		}
257 | 
258 | 		for i, msg := range sd.Messages {
259 | 			if msg.From == nil || msg.To == nil {
260 | 				t.Errorf("Message %d has nil participant", i)
261 | 			}
262 | 		}
263 | 
264 | 		seen := make(map[string]bool)
265 | 		for _, p := range sd.Participants {
266 | 			if seen[p.ID] {
267 | 				t.Errorf("Duplicate participant ID: %q", p.ID)
268 | 			}
269 | 			seen[p.ID] = true
270 | 		}
271 | 
272 | 		config := diagram.DefaultConfig()
273 | 		_, _ = Render(sd, config)
274 | 	})
275 | }
276 | 
277 | func FuzzRenderSequenceDiagram(f *testing.F) {
278 | 	seeds := []string{
279 | 		"sequenceDiagram\nA->>B: Test",
280 | 		"sequenceDiagram\nA->>A: Self",
281 | 		"sequenceDiagram\nA->>B: 1\nB->>C: 2\nC->>A: 3",
282 | 	}
283 | 
284 | 	for _, seed := range seeds {
285 | 		f.Add(seed)
286 | 	}
287 | 
288 | 	f.Fuzz(func(t *testing.T, input string) {
289 | 		sd, err := Parse(input)
290 | 		if err != nil {
291 | 			return
292 | 		}
293 | 
294 | 		for _, useAscii := range []bool{true, false} {
295 | 			config := diagram.DefaultConfig()
296 | 			config.UseAscii = useAscii
297 | 
298 | 			output, err := Render(sd, config)
299 | 			if err != nil {
300 | 				return
301 | 			}
302 | 
303 | 			if strings.TrimSpace(output) == "" {
304 | 				t.Error("Renderer produced empty output for valid diagram")
305 | 			}
306 | 
307 | 			for _, p := range sd.Participants {
308 | 				if !strings.Contains(output, p.Label) {
309 | 					t.Errorf("Rendered output missing participant label: %q", p.Label)
310 | 				}
311 | 			}
312 | 
313 | 			if !utf8.ValidString(output) {
314 | 				t.Error("Rendered output contains invalid UTF-8")
315 | 			}
316 | 		}
317 | 	})
318 | }
319 | 
320 | func BenchmarkParse(b *testing.B) {
321 | 	tests := []struct {
322 | 		name         string
323 | 		participants int
324 | 		messages     int
325 | 	}{
326 | 		{"small_2p_5m", 2, 5},
327 | 		{"medium_5p_20m", 5, 20},
328 | 		{"large_10p_50m", 10, 50},
329 | 	}
330 | 
331 | 	for _, tt := range tests {
332 | 		b.Run(tt.name, func(b *testing.B) {
333 | 			input := generateDiagram(tt.participants, tt.messages)
334 | 			b.ResetTimer()
335 | 			for i := 0; i < b.N; i++ {
336 | 				_, err := Parse(input)
337 | 				if err != nil {
338 | 					b.Fatalf("parse failed: %v", err)
339 | 				}
340 | 			}
341 | 		})
342 | 	}
343 | }
344 | 
345 | func BenchmarkRender(b *testing.B) {
346 | 	tests := []struct {
347 | 		name         string
348 | 		participants int
349 | 		messages     int
350 | 	}{
351 | 		{"small_2p_5m", 2, 5},
352 | 		{"medium_5p_20m", 5, 20},
353 | 	}
354 | 
355 | 	for _, tt := range tests {
356 | 		b.Run(tt.name, func(b *testing.B) {
357 | 			input := generateDiagram(tt.participants, tt.messages)
358 | 			sd, err := Parse(input)
359 | 			if err != nil {
360 | 				b.Fatalf("parse failed: %v", err)
361 | 			}
362 | 			config := diagram.DefaultConfig()
363 | 			b.ResetTimer()
364 | 			for i := 0; i < b.N; i++ {
365 | 				_, renderErr := Render(sd, config)
366 | 				if renderErr != nil {
367 | 					b.Fatalf("render error: %v", renderErr)
368 | 				}
369 | 			}
370 | 		})
371 | 	}
372 | }
373 | 
374 | func generateDiagram(numParticipants, numMessages int) string {
375 | 	var sb strings.Builder
376 | 	sb.WriteString("sequenceDiagram\n")
377 | 	for i := 0; i < numParticipants; i++ {
378 | 		sb.WriteString("    participant P")
379 | 		sb.WriteString(string(rune('0' + i)))
380 | 		sb.WriteString("\n")
381 | 	}
382 | 	for i := 0; i < numMessages; i++ {
383 | 		from := i % numParticipants
384 | 		to := (i + 1) % numParticipants
385 | 		arrow := "-"
386 | 		if i%2 == 0 {
387 | 			arrow = "--"
388 | 		}
389 | 		sb.WriteString("    P")
390 | 		sb.WriteString(string(rune('0' + from)))
391 | 		sb.WriteString(arrow)
392 | 		sb.WriteString(">>P")
393 | 		sb.WriteString(string(rune('0' + to)))
394 | 		sb.WriteString(": Message\n")
395 | 	}
396 | 	return sb.String()
397 | }
398 | 


--------------------------------------------------------------------------------