English | 日本語 | Русский | 中文 | 한국어 | Français
El paquete markdown es un constructor de markdown simple en Golang. El paquete markdown ensambla Markdown usando encadenamiento de métodos, no utiliza un motor de plantillas como html/template. La sintaxis de Markdown sigue GitHub Markdown.
El paquete markdown fue inicialmente desarrollado para guardar resultados de pruebas en nao1215/spectest. Por lo tanto, el paquete markdown implementa las características requeridas por spectest. Por ejemplo, el paquete markdown soporta diagramas de secuencia mermaid (diagrama de relación de entidad, diagrama de secuencia, diagrama de recorrido del usuario, diagrama git graph, diagrama de mapa mental, diagrama de requisitos, gráfico XY, diagrama Packet, diagrama Block, diagrama Kanban, diagrama de flujo, gráfico circular, gráfico de cuadrantes, diagrama de estado, diagrama de clases, diagrama de Gantt, diagrama de arquitectura), que era una característica necesaria en spectest.
Además, no se añadirá código complejo que aumente la complejidad de la biblioteca, como generar listas anidadas. Quiero mantener esta biblioteca lo más simple posible.
- SO: Linux, macOS, Windows
- Go: 1.21 o posterior
- Encabezados; H1, H2, H3, H4, H5, H6
- Citas de bloque
- Lista de viñetas
- Lista ordenada
- Lista de casillas de verificación
- Bloques de código
- Regla horizontal
- Tabla
- Formato de texto; negrita, cursiva, código, tachado, negrita cursiva
- Texto con enlace
- Texto con imagen
- Texto plano
- Detalles
- Alertas; NOTE, TIP, IMPORTANT, CAUTION, WARNING
- diagrama de secuencia mermaid
- diagrama de recorrido del usuario mermaid
- diagrama git graph mermaid
- diagrama de mapa mental mermaid
- diagrama de requisitos mermaid
- gráfico XY mermaid
- diagrama Packet mermaid
- diagrama Block mermaid
- diagrama Kanban mermaid
- diagrama de relación de entidad mermaid
- diagrama de flujo mermaid
- gráfico circular mermaid
- gráfico de cuadrantes mermaid
- diagrama de estado mermaid
- diagrama de clases mermaid
- diagrama de Gantt mermaid
- diagrama de arquitectura mermaid (característica beta)
- Generar insignias; RedBadge(), YellowBadge(), GreenBadge().
- Generar un índice para un directorio lleno de archivos markdown; GenerateIndex()
package main
import (
"os"
md "github.com/nao1215/markdown"
)
func main() {
md.NewMarkdown(os.Stdout).
H1("This is H1").
PlainText("This is plain text").
H2f("This is %s with text format", "H2").
PlainTextf("Text formatting, such as %s and %s, %s styles.",
md.Bold("bold"), md.Italic("italic"), md.Code("code")).
H2("Code Block").
CodeBlocks(md.SyntaxHighlightGo,
`package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}`).
H2("List").
BulletList("Bullet Item 1", "Bullet Item 2", "Bullet Item 3").
OrderedList("Ordered Item 1", "Ordered Item 2", "Ordered Item 3").
H2("CheckBox").
CheckBox([]md.CheckBoxSet{
{Checked: false, Text: md.Code("sample code")},
{Checked: true, Text: md.Link("Go", "https://golang.org")},
{Checked: false, Text: md.Strikethrough("strikethrough")},
}).
H2("Blockquote").
Blockquote("If you can dream it, you can do it.").
H3("Horizontal Rule").
HorizontalRule().
H2("Table").
Table(md.TableSet{
Header: []string{"Name", "Age", "Country"},
Rows: [][]string{
{"David", "23", "USA"},
{"John", "30", "UK"},
{"Bob", "25", "Canada"},
},
}).
H2("Image").
PlainTextf(md.Image("sample_image", "./sample.png")).
Build()
}Salida:
# This is H1
This is plain text
## This is H2 with text format
Text formatting, such as **bold** and *italic*, `code` styles.
## Code Block
```go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
```
## List
- Bullet Item 1
- Bullet Item 2
- Bullet Item 3
1. Ordered Item 1
2. Ordered Item 2
3. Ordered Item 3
## CheckBox
- [ ] `sample code`
- [x] [Go](https://golang.org)
- [ ] ~~strikethrough~~
## Blockquote
> If you can dream it, you can do it.
### Horizontal Rule
---
## Table
| NAME | AGE | COUNTRY |
|-------|-----|---------|
| David | 23 | USA |
| John | 30 | UK |
| Bob | 25 | Canada |
## Image
Si quieres ver cómo se ve en Markdown, por favor consulta el siguiente enlace.
Puedes generar Markdown usando go generate. Por favor define código para generar Markdown primero. Luego, ejecuta "go generate ./..." para generar Markdown.
package main
import (
"os"
md "github.com/nao1215/markdown"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
md.NewMarkdown(f).
H1("go generate example").
PlainText("This markdown is generated by `go generate`").
Build()
}Ejecuta el comando de abajo:
go generate ./...# go generate example
This markdown is generated by `go generate`
El paquete markdown puede crear alertas. Las alertas son útiles para mostrar información importante en Markdown. Esta sintaxis es soportada por GitHub. Ejemplo de código:
md.NewMarkdown(f).
H1("Alert example").
Note("This is note").LF().
Tip("This is tip").LF().
Important("This is important").LF().
Warning("This is warning").LF().
Caution("This is caution").LF().
Build()# Alert example
> [!NOTE]
> This is note
> [!TIP]
> This is tip
> [!IMPORTANT]
> This is important
> [!WARNING]
> This is warning
> [!CAUTION]
> This is caution
Tu alerta se verá así;
Note
This is note
Tip
This is tip
Important
This is important
Warning
This is warning
Caution
This is caution
El paquete markdown puede crear insignias de estado rojas, amarillas y verdes. Ejemplo de código:
md.NewMarkdown(os.Stdout).
H1("badge example").
RedBadge("red_badge").
YellowBadge("yellow_badge").
GreenBadge("green_badge").
BlueBadge("blue_badge").
Build()# badge example
Tu insignia se verá así;
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/sequence"
)
//go:generate go run main.go
func main() {
diagram := sequence.NewDiagram(io.Discard).
Participant("Sophia").
Participant("David").
Participant("Subaru").
LF().
SyncRequest("Sophia", "David", "Please wake up Subaru").
SyncResponse("David", "Sophia", "OK").
LF().
LoopStart("until Subaru wake up").
SyncRequest("David", "Subaru", "Wake up!").
SyncResponse("Subaru", "David", "zzz").
SyncRequest("David", "Subaru", "Hey!!!").
BreakStart("if Subaru wake up").
SyncResponse("Subaru", "David", "......").
BreakEnd().
LoopEnd().
LF().
SyncResponse("David", "Sophia", "wake up, wake up").
String()
markdown.NewMarkdown(os.Stdout).
H2("Sequence Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build()
}Salida de texto plano: markdown está aquí
## Sequence Diagram
```mermaid
sequenceDiagram
participant Sophia
participant David
participant Subaru
Sophia->>David: Please wake up Subaru
David-->>Sophia: OK
loop until Subaru wake up
David->>Subaru: Wake up!
Subaru-->>David: zzz
David->>Subaru: Hey!!!
break if Subaru wake up
Subaru-->>David: ......
end
end
David-->>Sophia: wake up, wake up
```
Salida Mermaid:
sequenceDiagram
participant Sophia
participant David
participant Subaru
Sophia->>David: Please wake up Subaru
David-->>Sophia: OK
loop until Subaru wake up
David->>Subaru: Wake up!
Subaru-->>David: zzz
David->>Subaru: Hey!!!
break if Subaru wake up
Subaru-->>David: ......
end
end
David-->>Sophia: wake up, wake up
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/userjourney"
)
//go:generate go run main.go
func main() {
diagram := userjourney.NewDiagram(
io.Discard,
userjourney.WithTitle("Checkout Journey"),
).
Section("Discover").
Task("Browse products", userjourney.ScoreVerySatisfied, "Customer").
Task("Add item to cart", userjourney.ScoreSatisfied, "Customer").
LF().
Section("Checkout").
Task("Enter shipping details", userjourney.ScoreNeutral, "Customer").
Task("Complete payment", userjourney.ScoreSatisfied, "Customer", "Payment Service").
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("User Journey Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## User Journey Diagram
```mermaid
journey
title Checkout Journey
section Discover
Browse products: 5: Customer
Add item to cart: 4: Customer
section Checkout
Enter shipping details: 3: Customer
Complete payment: 4: Customer, Payment Service
```
Salida Mermaid:
journey
title Checkout Journey
section Discover
Browse products: 5: Customer
Add item to cart: 4: Customer
section Checkout
Enter shipping details: 3: Customer
Complete payment: 4: Customer, Payment Service
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/gitgraph"
)
//go:generate go run main.go
func main() {
diagram := gitgraph.NewDiagram(
io.Discard,
gitgraph.WithTitle("Release Flow"),
).
Commit(gitgraph.WithCommitID("init"), gitgraph.WithCommitTag("v0.1.0")).
Branch("develop", gitgraph.WithBranchOrder(2)).
Checkout("develop").
Commit(gitgraph.WithCommitType(gitgraph.CommitTypeHighlight)).
Checkout("main").
Merge("develop", gitgraph.WithCommitTag("v1.0.0")).
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("Git Graph").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Git Graph
```mermaid
---
title: Release Flow
---
gitGraph
commit id: "init" tag: "v0.1.0"
branch develop order: 2
checkout develop
commit type: HIGHLIGHT
checkout main
merge develop tag: "v1.0.0"
```
Salida Mermaid:
---
title: Release Flow
---
gitGraph
commit id: "init" tag: "v0.1.0"
branch develop order: 2
checkout develop
commit type: HIGHLIGHT
checkout main
merge develop tag: "v1.0.0"
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/mindmap"
)
//go:generate go run main.go
func main() {
diagram := mindmap.NewDiagram(
io.Discard,
mindmap.WithTitle("Product Strategy Mindmap"),
).
Root("Product Strategy").
Child("Market").
Child("SMB").
Sibling("Enterprise").
Parent().
Sibling("Execution").
Child("Q1").
Sibling("Q2").
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("Mindmap").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Mindmap
```mermaid
---
title: Product Strategy Mindmap
---
mindmap
Product Strategy
Market
SMB
Enterprise
Execution
Q1
Q2
```
Salida Mermaid:
---
title: Product Strategy Mindmap
---
mindmap
Product Strategy
Market
SMB
Enterprise
Execution
Q1
Q2
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/requirement"
)
//go:generate go run main.go
func main() {
diagram := requirement.NewDiagram(
io.Discard,
requirement.WithTitle("Checkout Requirements"),
).
SetDirection(requirement.DirectionTB).
Requirement(
"Login",
requirement.WithID("REQ-1"),
requirement.WithText("The system shall support login."),
requirement.WithRisk(requirement.RiskHigh),
requirement.WithVerifyMethod(requirement.VerifyMethodTest),
requirement.WithRequirementClasses("critical"),
).
FunctionalRequirement(
"RememberSession",
requirement.WithID("REQ-2"),
requirement.WithText("The system shall remember the user."),
requirement.WithRisk(requirement.RiskMedium),
requirement.WithVerifyMethod(requirement.VerifyMethodInspection),
).
Element(
"AuthService",
requirement.WithElementType("system"),
requirement.WithDocRef("docs/auth.md"),
requirement.WithElementClasses("service"),
).
From("AuthService").
Satisfies("Login").
From("RememberSession").
Verifies("Login").
ClassDefs(
requirement.Def("critical", "fill:#f96,stroke:#333,stroke-width:2px"),
requirement.Def("service", "fill:#9cf,stroke:#333,stroke-width:1px"),
).
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("Requirement Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Requirement Diagram
```mermaid
---
title: Checkout Requirements
---
requirementDiagram
direction TB
requirement Login:::critical {
id: "REQ-1"
text: "The system shall support login."
risk: High
verifymethod: Test
}
functionalRequirement RememberSession {
id: "REQ-2"
text: "The system shall remember the user."
risk: Medium
verifymethod: Inspection
}
element AuthService:::service {
type: "system"
docRef: "docs/auth.md"
}
AuthService - satisfies -> Login
RememberSession - verifies -> Login
classDef critical fill:#f96,stroke:#333,stroke-width:2px
classDef service fill:#9cf,stroke:#333,stroke-width:1px
```
Salida Mermaid:
---
title: Checkout Requirements
---
requirementDiagram
direction TB
requirement Login:::critical {
id: "REQ-1"
text: "The system shall support login."
risk: High
verifymethod: Test
}
functionalRequirement RememberSession {
id: "REQ-2"
text: "The system shall remember the user."
risk: Medium
verifymethod: Inspection
}
element AuthService:::service {
type: "system"
docRef: "docs/auth.md"
}
AuthService - satisfies -> Login
RememberSession - verifies -> Login
classDef critical fill:#f96,stroke:#333,stroke-width:2px
classDef service fill:#9cf,stroke:#333,stroke-width:1px
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/xychart"
)
//go:generate go run main.go
func main() {
diagram := xychart.NewDiagram(
io.Discard,
xychart.WithTitle("Sales Revenue"),
).
XAxisLabels("Jan", "Feb", "Mar", "Apr", "May", "Jun").
YAxisRangeWithTitle("Revenue (k$)", 0, 100).
Bar(25, 40, 60, 80, 70, 90).
Line(30, 50, 70, 85, 75, 95).
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("XY Chart").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## XY Chart
```mermaid
xychart
title "Sales Revenue"
x-axis [Jan, Feb, Mar, Apr, May, Jun]
y-axis "Revenue (k$)" 0 --> 100
bar [25, 40, 60, 80, 70, 90]
line [30, 50, 70, 85, 75, 95]
```
Salida Mermaid:
xychart
title "Sales Revenue"
x-axis [Jan, Feb, Mar, Apr, May, Jun]
y-axis "Revenue (k$)" 0 --> 100
bar [25, 40, 60, 80, 70, 90]
line [30, 50, 70, 85, 75, 95]
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/packet"
)
//go:generate go run main.go
func main() {
diagram := packet.NewDiagram(
io.Discard,
packet.WithTitle("UDP Packet"),
).
Next(16, "Source Port").
Next(16, "Destination Port").
Field(32, 47, "Length").
Field(48, 63, "Checksum").
Field(64, 95, "Data (variable length)").
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("Packet").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Packet
```mermaid
packet
title UDP Packet
+16: "Source Port"
+16: "Destination Port"
32-47: "Length"
48-63: "Checksum"
64-95: "Data (variable length)"
```
Salida Mermaid:
packet
title UDP Packet
+16: "Source Port"
+16: "Destination Port"
32-47: "Length"
48-63: "Checksum"
64-95: "Data (variable length)"
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/block"
)
//go:generate go run main.go
func main() {
diagram := block.NewDiagram(
io.Discard,
block.WithTitle("Checkout Architecture"),
).
Columns(3).
Row(
block.Node("Frontend"),
block.ArrowRight("toBackend", block.WithArrowLabel("calls")),
block.Node("Backend"),
).
Row(
block.Space(2),
block.ArrowDown("toDB"),
).
Row(
block.Node("Database", block.WithNodeLabel("Primary DB"), block.WithNodeShape(block.ShapeCylinder)),
block.Space(),
block.Node("Cache", block.WithNodeLabel("Cache"), block.WithNodeShape(block.ShapeRound)),
).
Link("Backend", "Database").
LinkWithLabel("Backend", "reads from", "Cache").
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("Block Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Block Diagram
```mermaid
block
title Checkout Architecture
columns 3
Frontend toBackend<["calls"]>(right) Backend
space:2 toDB<[" "]>(down)
Database[("Primary DB")] space Cache("Cache")
Backend --> Database
Backend -- "reads from" --> Cache
```
Salida Mermaid:
block
title Checkout Architecture
columns 3
Frontend toBackend<["calls"]>(right) Backend
space:2 toDB<[" "]>(down)
Database[("Primary DB")] space Cache("Cache")
Backend --> Database
Backend -- "reads from" --> Cache
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/kanban"
)
//go:generate go run main.go
func main() {
diagram := kanban.NewDiagram(
io.Discard,
kanban.WithTitle("Sprint Board"),
kanban.WithTicketBaseURL("https://example.com/tickets/"),
).
Column("Todo").
Task("Define scope").
Task(
"Create login page",
kanban.WithTaskTicket("MB-101"),
kanban.WithTaskAssigned("Alice"),
kanban.WithTaskPriority(kanban.PriorityHigh),
).
Column("In Progress").
Task("Review API", kanban.WithTaskPriority(kanban.PriorityVeryHigh)).
String()
if err := markdown.NewMarkdown(os.Stdout).
H2("Kanban Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build(); err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Kanban Diagram
```mermaid
---
title: Sprint Board
config:
kanban:
ticketBaseUrl: 'https://example.com/tickets/'
---
kanban
[Todo]
[Define scope]
[Create login page]@{ ticket: 'MB-101', assigned: 'Alice', priority: 'High' }
[In Progress]
[Review API]@{ priority: 'Very High' }
```
Salida Mermaid:
---
title: Sprint Board
config:
kanban:
ticketBaseUrl: 'https://example.com/tickets/'
---
kanban
[Todo]
[Define scope]
[Create login page]@{ ticket: 'MB-101', assigned: 'Alice', priority: 'High' }
[In Progress]
[Review API]@{ priority: 'Very High' }
package main
import (
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/er"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
teachers := er.NewEntity(
"teachers",
[]*er.Attribute{
{
Type: "int",
Name: "id",
IsPrimaryKey: true,
IsForeignKey: false,
IsUniqueKey: true,
Comment: "Teacher ID",
},
{
Type: "string",
Name: "name",
IsPrimaryKey: false,
IsForeignKey: false,
IsUniqueKey: false,
Comment: "Teacher Name",
},
},
)
students := er.NewEntity(
"students",
[]*er.Attribute{
{
Type: "int",
Name: "id",
IsPrimaryKey: true,
IsForeignKey: false,
IsUniqueKey: true,
Comment: "Student ID",
},
{
Type: "string",
Name: "name",
IsPrimaryKey: false,
IsForeignKey: false,
IsUniqueKey: false,
Comment: "Student Name",
},
{
Type: "int",
Name: "teacher_id",
IsPrimaryKey: false,
IsForeignKey: true,
IsUniqueKey: true,
Comment: "Teacher ID",
},
},
)
schools := er.NewEntity(
"schools",
[]*er.Attribute{
{
Type: "int",
Name: "id",
IsPrimaryKey: true,
IsForeignKey: false,
IsUniqueKey: true,
Comment: "School ID",
},
{
Type: "string",
Name: "name",
IsPrimaryKey: false,
IsForeignKey: false,
IsUniqueKey: false,
Comment: "School Name",
},
{
Type: "int",
Name: "teacher_id",
IsPrimaryKey: false,
IsForeignKey: true,
IsUniqueKey: true,
Comment: "Teacher ID",
},
},
)
erString := er.NewDiagram(f).
Relationship(
teachers,
students,
er.ExactlyOneRelationship, // "||"
er.ZeroToMoreRelationship, // "}o"
er.Identifying, // "--"
"Teacher has many students",
).
Relationship(
teachers,
schools,
er.OneToMoreRelationship, // "|}"
er.ExactlyOneRelationship, // "||"
er.NonIdentifying, // ".."
"School has many teachers",
).
String()
err = markdown.NewMarkdown(f).
H2("Entity Relationship Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, erString).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Entity Relationship Diagram
```mermaid
erDiagram
teachers ||--o{ students : "Teacher has many students"
teachers }|..|| schools : "School has many teachers"
schools {
int id PK,UK "School ID"
string name "School Name"
int teacher_id FK,UK "Teacher ID"
}
students {
int id PK,UK "Student ID"
string name "Student Name"
int teacher_id FK,UK "Teacher ID"
}
teachers {
int id PK,UK "Teacher ID"
string name "Teacher Name"
}
```
Salida Mermaid:
erDiagram
teachers ||--o{ students : "Teacher has many students"
teachers }|..|| schools : "School has many teachers"
schools {
int id PK,UK "School ID"
string name "School Name"
int teacher_id FK,UK "Teacher ID"
}
students {
int id PK,UK "Student ID"
string name "Student Name"
int teacher_id FK,UK "Teacher ID"
}
teachers {
int id PK,UK "Teacher ID"
string name "Teacher Name"
}
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/flowchart"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
fc := flowchart.NewFlowchart(
io.Discard,
flowchart.WithTitle("mermaid flowchart builder"),
flowchart.WithOrientalTopToBottom(),
).
NodeWithText("A", "Node A").
StadiumNode("B", "Node B").
SubroutineNode("C", "Node C").
DatabaseNode("D", "Database").
LinkWithArrowHead("A", "B").
LinkWithArrowHeadAndText("B", "D", "send original data").
LinkWithArrowHead("B", "C").
DottedLinkWithText("C", "D", "send filtered data").
String()
err = markdown.NewMarkdown(f).
H2("Flowchart").
CodeBlocks(markdown.SyntaxHighlightMermaid, fc).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Flowchart
```mermaid
---
title: mermaid flowchart builder
---
flowchart TB
A["Node A"]
B(["Node B"])
C[["Node C"]]
D[("Database")]
A-->B
B-->|"send original data"|D
B-->C
C-. "send filtered data" .-> D
```
Salida Mermaid:
flowchart TB
A["Node A"]
B(["Node B"])
C[["Node C"]]
D[("Database")]
A-->B
B-->|"send original data"|D
B-->C
C-. "send filtered data" .-> D
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/piechart"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
chart := piechart.NewPieChart(
io.Discard,
piechart.WithTitle("mermaid pie chart builder"),
piechart.WithShowData(true),
).
LabelAndIntValue("A", 10).
LabelAndFloatValue("B", 20.1).
LabelAndIntValue("C", 30).
String()
err = markdown.NewMarkdown(f).
H2("Pie Chart").
CodeBlocks(markdown.SyntaxHighlightMermaid, chart).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Pie Chart
```mermaid
%%{init: {"pie": {"textPosition": 0.75}, "themeVariables": {"pieOuterStrokeWidth": "5px"}} }%%
pie showData
title mermaid pie chart builder
"A" : 10
"B" : 20.100000
"C" : 30
```
Salida Mermaid:
%%{init: {"pie": {"textPosition": 0.75}, "themeVariables": {"pieOuterStrokeWidth": "5px"}} }%%
pie showData
title mermaid pie chart builder
"A" : 10
"B" : 20.100000
"C" : 30
El mermaid proporciona una característica para visualizar la arquitectura de infraestructura como una versión beta, y esa característica ha sido introducida.
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/arch"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
diagram := arch.NewArchitecture(io.Discard).
Service("left_disk", arch.IconDisk, "Disk").
Service("top_disk", arch.IconDisk, "Disk").
Service("bottom_disk", arch.IconDisk, "Disk").
Service("top_gateway", arch.IconInternet, "Gateway").
Service("bottom_gateway", arch.IconInternet, "Gateway").
Junction("junctionCenter").
Junction("junctionRight").
LF().
Edges(
arch.Edge{
ServiceID: "left_disk",
Position: arch.PositionRight,
Arrow: arch.ArrowNone,
},
arch.Edge{
ServiceID: "junctionCenter",
Position: arch.PositionLeft,
Arrow: arch.ArrowNone,
}).
Edges(
arch.Edge{
ServiceID: "top_disk",
Position: arch.PositionBottom,
Arrow: arch.ArrowNone,
},
arch.Edge{
ServiceID: "junctionCenter",
Position: arch.PositionTop,
Arrow: arch.ArrowNone,
}).
Edges(
arch.Edge{
ServiceID: "bottom_disk",
Position: arch.PositionTop,
Arrow: arch.ArrowNone,
},
arch.Edge{
ServiceID: "junctionCenter",
Position: arch.PositionBottom,
Arrow: arch.ArrowNone,
}).
Edges(
arch.Edge{
ServiceID: "junctionCenter",
Position: arch.PositionRight,
Arrow: arch.ArrowNone,
},
arch.Edge{
ServiceID: "junctionRight",
Position: arch.PositionLeft,
Arrow: arch.ArrowNone,
}).
Edges(
arch.Edge{
ServiceID: "top_gateway",
Position: arch.PositionBottom,
Arrow: arch.ArrowNone,
},
arch.Edge{
ServiceID: "junctionRight",
Position: arch.PositionTop,
Arrow: arch.ArrowNone,
}).
Edges(
arch.Edge{
ServiceID: "bottom_gateway",
Position: arch.PositionTop,
Arrow: arch.ArrowNone,
},
arch.Edge{
ServiceID: "junctionRight",
Position: arch.PositionBottom,
Arrow: arch.ArrowNone,
}).String() //nolint
err = markdown.NewMarkdown(f).
H2("Architecture Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build()
if err != nil {
panic(err)
}Salida de texto plano: markdown está aquí
## Architecture Diagram
```mermaid
architecture-beta
service left_disk(disk)[Disk]
service top_disk(disk)[Disk]
service bottom_disk(disk)[Disk]
service top_gateway(internet)[Gateway]
service bottom_gateway(internet)[Gateway]
junction junctionCenter
junction junctionRight
left_disk:R -- L:junctionCenter
top_disk:B -- T:junctionCenter
bottom_disk:T -- B:junctionCenter
junctionCenter:R -- L:junctionRight
top_gateway:B -- T:junctionRight
bottom_gateway:T -- B:junctionRight
```
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/state"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
diagram := state.NewDiagram(io.Discard, state.WithTitle("Order State Machine")).
StartTransition("Pending").
State("Pending", "Order received").
State("Processing", "Preparing order").
State("Shipped", "Order in transit").
State("Delivered", "Order completed").
LF().
TransitionWithNote("Pending", "Processing", "payment confirmed").
TransitionWithNote("Processing", "Shipped", "items packed").
TransitionWithNote("Shipped", "Delivered", "customer received").
LF().
NoteRight("Pending", "Waiting for payment").
NoteRight("Processing", "Preparing items").
LF().
EndTransition("Delivered").
String()
err = markdown.NewMarkdown(f).
H2("State Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagram).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## State Diagram
```mermaid
---
title: Order State Machine
---
stateDiagram-v2
[*] --> Pending
Pending : Order received
Processing : Preparing order
Shipped : Order in transit
Delivered : Order completed
Pending --> Processing : payment confirmed
Processing --> Shipped : items packed
Shipped --> Delivered : customer received
note right of Pending : Waiting for payment
note right of Processing : Preparing items
Delivered --> [*]
```
Salida Mermaid:
---
title: Order State Machine
---
stateDiagram-v2
[*] --> Pending
Pending : Order received
Processing : Preparing order
Shipped : Order in transit
Delivered : Order completed
Pending --> Processing : payment confirmed
Processing --> Shipped : items packed
Shipped --> Delivered : customer received
note right of Pending : Waiting for payment
note right of Processing : Preparing items
Delivered --> [*]
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/class"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
diagram := class.NewDiagram(
io.Discard,
class.WithTitle("Checkout Domain"),
).
SetDirection(class.DirectionLR).
Class(
"Order",
class.WithPublicField("string", "id"),
class.WithPublicMethod("Create", "error", "items []LineItem"),
class.WithPublicMethod("Pay", "error"),
).
Class(
"LineItem",
class.WithPublicField("string", "sku"),
class.WithPublicField("int", "quantity"),
class.WithPublicMethod("Subtotal", "int"),
).
Interface("PaymentGateway")
diagram.From("Order").
Composition("LineItem", class.WithOneToMany(), class.WithRelationLabel("contains")).
Association("PaymentGateway", class.WithRelationLabel("uses"))
diagramString := diagram.
NoteFor("Order", "Aggregate Root").
String()
err = markdown.NewMarkdown(f).
H2("Class Diagram").
CodeBlocks(markdown.SyntaxHighlightMermaid, diagramString).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Class Diagram
```mermaid
---
title: Checkout Domain
---
classDiagram
direction LR
class Order {
+string id
+Create(items []LineItem) error
+Pay() error
}
class LineItem {
+string sku
+int quantity
+Subtotal() int
}
class PaymentGateway
<<Interface>> PaymentGateway
Order "1" *-- "many" LineItem : contains
Order --> PaymentGateway : uses
note for Order "Aggregate Root"
```
Salida Mermaid:
---
title: Checkout Domain
---
classDiagram
direction LR
class Order {
+string id
+Create(items []LineItem) error
+Pay() error
}
class LineItem {
+string sku
+int quantity
+Subtotal() int
}
class PaymentGateway
<<Interface>> PaymentGateway
Order "1" *-- "many" LineItem : contains
Order --> PaymentGateway : uses
note for Order "Aggregate Root"
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/quadrant"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
chart := quadrant.NewChart(io.Discard, quadrant.WithTitle("Product Prioritization")).
XAxis("Low Effort", "High Effort").
YAxis("Low Value", "High Value").
LF().
Quadrant1("Quick Wins").
Quadrant2("Major Projects").
Quadrant3("Fill Ins").
Quadrant4("Thankless Tasks").
LF().
Point("Feature A", 0.9, 0.85).
Point("Feature B", 0.25, 0.75).
Point("Feature C", 0.15, 0.20).
Point("Feature D", 0.80, 0.15).
String()
err = markdown.NewMarkdown(f).
H2("Quadrant Chart").
CodeBlocks(markdown.SyntaxHighlightMermaid, chart).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Quadrant Chart
```mermaid
quadrantChart
title Product Prioritization
x-axis Low Effort --> High Effort
y-axis Low Value --> High Value
quadrant-1 Quick Wins
quadrant-2 Major Projects
quadrant-3 Fill Ins
quadrant-4 Thankless Tasks
Feature A: [0.90, 0.85]
Feature B: [0.25, 0.75]
Feature C: [0.15, 0.20]
Feature D: [0.80, 0.15]
```
Salida Mermaid:
quadrantChart
title Product Prioritization
x-axis Low Effort --> High Effort
y-axis Low Value --> High Value
quadrant-1 Quick Wins
quadrant-2 Major Projects
quadrant-3 Fill Ins
quadrant-4 Thankless Tasks
Feature A: [0.90, 0.85]
Feature B: [0.25, 0.75]
Feature C: [0.15, 0.20]
Feature D: [0.80, 0.15]
package main
import (
"io"
"os"
"github.com/nao1215/markdown"
"github.com/nao1215/markdown/mermaid/gantt"
)
//go:generate go run main.go
func main() {
f, err := os.Create("generated.md")
if err != nil {
panic(err)
}
defer f.Close()
chart := gantt.NewChart(
io.Discard,
gantt.WithTitle("Project Schedule"),
gantt.WithDateFormat("YYYY-MM-DD"),
).
Section("Planning").
DoneTaskWithID("Requirements", "req", "2024-01-01", "5d").
DoneTaskWithID("Design", "design", "2024-01-08", "3d").
Section("Development").
CriticalActiveTaskWithID("Coding", "code", "2024-01-12", "10d").
TaskAfterWithID("Review", "review", "code", "2d").
Section("Release").
MilestoneWithID("Launch", "launch", "2024-01-26").
String()
err = markdown.NewMarkdown(f).
H2("Gantt Chart").
CodeBlocks(markdown.SyntaxHighlightMermaid, chart).
Build()
if err != nil {
panic(err)
}
}Salida de texto plano: markdown está aquí
## Gantt Chart
```mermaid
gantt
title Project Schedule
dateFormat YYYY-MM-DD
section Planning
Requirements :done, req, 2024-01-01, 5d
Design :done, design, 2024-01-08, 3d
section Development
Coding :crit, active, code, 2024-01-12, 10d
Review :review, after code, 2d
section Release
Launch :milestone, launch, 2024-01-26, 0d
```
Salida Mermaid:
gantt
title Project Schedule
dateFormat YYYY-MM-DD
section Planning
Requirements :done, req, 2024-01-01, 5d
Design :done, design, 2024-01-08, 3d
section Development
Coding :crit, active, code, 2024-01-12, 10d
Review :review, after code, 2d
section Release
Launch :milestone, launch, 2024-01-26, 0d
El paquete markdown puede crear un índice para archivos Markdown dentro del directorio especificado. Esta característica fue añadida para generar índices para documentos Markdown producidos por nao1215/spectest.
Por ejemplo, considera la siguiente estructura de directorio:
testdata
├── abc
│ ├── dummy.txt
│ ├── jkl
│ │ └── text.md
│ └── test.md
├── def
│ ├── test.md
│ └── test2.md
├── expected
│ └── index.md
├── ghi
└── test.mdEn la siguiente implementación, crea un archivo markdown índice que contiene enlaces a todos los archivos markdown ubicados dentro del directorio testdata.
if err := GenerateIndex(
"testdata", // directorio objetivo que contiene archivos markdown
WithTitle("Test Title"), // título del markdown índice
WithDescription([]string{"Test Description", "Next Description"}), // descripción del markdown índice
); err != nil {
panic(err)
}El archivo Markdown índice se crea bajo "directorio objetivo/index.md" por defecto. Si quieres cambiar esta ruta, por favor usa la opción WithWriter(). Los nombres de los enlaces en el archivo serán la primera ocurrencia de H1 o H2 en el Markdown objetivo. Si ni H1 ni H2 están presentes, el nombre del enlace será el nombre del archivo del destino.
## Test Title
Test Description
Next Description
### testdata
- [test.md](test.md)
### abc
- [h2 is here](abc/test.md)
### jkl
- [text.md](abc/jkl/text.md)
### def
- [h2 is first, not h1](def/test.md)
- [h1 is here](def/test2.md)
### expected
- [Test Title](expected/index.md)Primero que todo, ¡gracias por tomarte el tiempo para contribuir! Ve CONTRIBUTING.md para más información. Las contribuciones no están solo relacionadas con el desarrollo. Por ejemplo, ¡GitHub Star me motiva a desarrollar! Por favor siéntete libre de contribuir a este proyecto.
Gracias a estas personas maravillosas (clave de emoji):
 CHIKAMATSU Naohiro 💻 |
 Karthik Sundari 💻 |
 Avihuc 💻 |
 Clarance Liberiste Ntwari 💻 |
 Amitai Frey 💻 |
||
Add your contributions
|
||||||
Este proyecto sigue la especificación all-contributors. ¡Las contribuciones de cualquier tipo son bienvenidas!