Using either Markdown or Programmatically to generate directory trees🌳 and directories🗂, and to verify directories🔍. Provide CLI, Golang library and Web.
- Acknowledgments
- Features
- Web
- CLI
- Library - Markdown to tree structure
- Library - Programmable tree structure
- Recommended for developers!👍
- Documents
- Process
- Performance
- Test coverage
Everyone is encouraged to use them!
CLI for Amazon S3 tree output.
aws s3 command does not do what tree command does, but stree command can display tree!
CLI for Google Cloud Storage tree output.
gcloud storage command does not do what tree command does, but gcstree command can display tree!
I hope you will use these tools as well!
https://ddddddo.github.io/gtree/
This page is that converts from Markdown to tree!
This page calls a function that outputs tree. This function is a Go package compiled as WebAssembly.
The symbols that can be used in Markdown are *, -, +, and #.
Indentation represents hierarchy. The indentation can be whatever you specify, but use the same pattern.
You can change the branches like in the image below.
Also, once loaded, you can enjoy offline!
You can open it in your browser with
$ gtree webGo (requires 1.18 or later) $ go install github.com/ddddddO/gtree/cmd/gtree@latest Homebrew $ brew install ddddddO/tap/gtree Scoop $ scoop bucket add ddddddO https://github.com/ddddddO/scoop-bucket.git $ scoop install ddddddO/gtree deb $ export GTREE_VERSION=X.X.X $ curl -o gtree.deb -L https://github.com/ddddddO/gtree/releases/download/v$GTREE_VERSION/gtree_$GTREE_VERSION-1_amd64.deb $ dpkg -i gtree.deb rpm $ export GTREE_VERSION=X.X.X $ yum install https://github.com/ddddddO/gtree/releases/download/v$GTREE_VERSION/gtree_$GTREE_VERSION-1_amd64.rpm apk $ export GTREE_VERSION=X.X.X $ curl -o gtree.apk -L https://github.com/ddddddO/gtree/releases/download/v$GTREE_VERSION/gtree_$GTREE_VERSION-1_amd64.apk $ apk add --allow-untrusted gtree.apkAUR$ wip... Nix $ nix-env -i gtree or $ nix-shell -p gtree MacPorts $ port install gtree aqua $ aqua g -i ddddddO/gtree Docker $ docker pull ghcr.io/ddddddo/gtree:latest $ docker run ghcr.io/ddddddo/gtree:latest template | docker run -i ghcr.io/ddddddo/gtree:latest output gtree ├── cmd │ └── gtree │ └── main.go ├── testdata │ ├── sample1.md │ └── sample2.md ├── Makefile └── tree.go
download binary from here.
$ gtree --help
NAME:
gtree - This CLI uses Markdown to generate directory trees and directories itself, and also verifies directories.
The symbols that can be used in Markdown are '-', '+', '*', and '#'.
Within Markdown, indentation represents hierarchy. The indentation can be whatever you specify, but use the same pattern.
USAGE:
gtree [global options] command [command options] [arguments...]
VERSION:
1.10.2 / revision 85520a1
COMMANDS:
output, o, out Outputs tree from markdown.
Let's try 'gtree template | gtree output'.
mkdir, m Makes directories and files from markdown. It is possible to dry run.
Let's try 'gtree template | gtree mkdir -e .go -e .md -e Makefile'.
verify, vf Verifies tree structure represented in markdown by comparing it with existing directories.
Let's try 'gtree template | gtree verify'.
template, t, tmpl Outputs markdown template. Use it to try out gtree CLI.
web, w, www Opens "Tree Maker" in your browser and shows the URL in terminal.
version, v Prints the version.
help, h Shows a list of commands or help for one command
GLOBAL OPTIONS:
--help, -h show help
--version, -v print the version$ gtree output --help
NAME:
gtree output - Outputs tree from markdown.
Let's try 'gtree template | gtree output'.
USAGE:
gtree output [command options] [arguments...]
OPTIONS:
--file value, -f value specify the path to markdown file. (default: stdin)
--massive, -m set this option when there are very many blocks of markdown. (default: false)
--massive-timeout value, --mt value set this option if you want to set a timeout. (default: 0s)
--format value set this option when specifying output format. "json", "yaml", "toml"
--watch, -w follow changes in markdown file. (default: false)
--help, -h show help$ gtree template
- gtree
- cmd
- gtree
- main.go
- testdata
- sample1.md
- sample2.md
- Makefile
- tree.go
$ gtree template | gtree output
gtree
├── cmd
│ └── gtree
│ └── main.go
├── testdata
│ ├── sample1.md
│ └── sample2.md
├── Makefile
└── tree.goOther pattern.
├── gtree output -f testdata/sample1.md
├── cat testdata/sample1.md | gtree output -f -
└── cat testdata/sample1.md | gtree output
$ cat testdata/sample2.md | gtree output
k8s_resources
├── (Tier3)
│ └── (Tier2)
│ └── (Tier1)
│ └── (Tier0)
├── Deployment
│ └── ReplicaSet
│ └── Pod
│ └── container(s)
├── CronJob
│ └── Job
│ └── Pod
│ └── container(s)
└── (empty)
├── DaemonSet
│ └── Pod
│ └── container(s)
└── StatefulSet
└── Pod
└── container(s)$ cat testdata/sample6.md | gtree output
Artiodactyla
├── Artiofabula
│ ├── Cetruminantia
│ │ ├── Whippomorpha
│ │ │ ├── Hippopotamidae
│ │ │ └── Cetacea
│ │ └── Ruminantia
│ └── Suina
└── Tylopoda
Carnivora
├── Feliformia
└── Caniformia
├── Canidae
└── Arctoidea
├── Ursidae
└── x
├── Pinnipedia
└── Musteloidea
├── Ailuridae
└── x
├── Mephitidae
└── x
├── Procyonidae
└── Mustelidae$ cat testdata/sample5.md | gtree output --format json | jq
{
"value": "a",
"children": [
{
"value": "i",
"children": [
{
"value": "u",
"children": [
{
"value": "k",
"children": null
},
{
"value": "kk",
"children": null
}
]
},
{
"value": "t",
"children": null
}
]
},
{
"value": "e",
"children": [
{
"value": "o",
"children": null
}
]
},
{
"value": "g",
"children": null
}
]
}$ cat testdata/sample5.md | gtree output --format yaml
value: a
children:
- value: i
children:
- value: u
children:
- value: k
children: []
- value: kk
children: []
- value: t
children: []
- value: e
children:
- value: o
children: []
- value: g
children: []$ cat testdata/sample5.md | gtree output --format toml
value = 'a'
[[children]]
value = 'i'
[[children.children]]
value = 'u'
[[children.children.children]]
value = 'k'
children = []
[[children.children.children]]
value = 'kk'
children = []
[[children.children]]
value = 't'
children = []
[[children]]
value = 'e'
[[children.children]]
value = 'o'
children = []
[[children]]
value = 'g'
children = []
$ gtree mkdir --help
NAME:
gtree mkdir - Makes directories and files from markdown. It is possible to dry run.
Let's try 'gtree template | gtree mkdir -e .go -e .md -e Makefile'.
USAGE:
gtree mkdir [command options] [arguments...]
OPTIONS:
--file value, -f value specify the path to markdown file. (default: stdin)
--dry-run, -d dry run. detects node that is invalid for directory generation. the order of the output and made directories does not always match. (default: false)
--extension value, -e value [ --extension value, -e value ] set this option if you want to create file instead of directory. for example, if you want to generate files with ".go" extension: "-e .go"
--target-dir value set this option if you want to specify the directory you want to make directory. (default: current directory)
--help, -h show help$ gtree template
- gtree
- cmd
- gtree
- main.go
- testdata
- sample1.md
- sample2.md
- Makefile
- tree.go
$ gtree template | gtree mkdir
$ tree gtree/
gtree/
├── cmd
│ └── gtree
│ └── main.go
├── Makefile
├── testdata
│ ├── sample1.md
│ └── sample2.md
└── tree.go
8 directories, 0 files$ gtree template
- gtree
- cmd
- gtree
- main.go
- testdata
- sample1.md
- sample2.md
- Makefile
- tree.go
$ gtree template | gtree mkdir -e .go -e .md -e Makefile
$ tree gtree/
gtree/
├── cmd
│ └── gtree
│ └── main.go
├── Makefile
├── testdata
│ ├── sample1.md
│ └── sample2.md
└── tree.go
3 directories, 5 filesDoes not create a file and directory.
$ gtree template | gtree mkdir --dry-run -e .go -e .md -e Makefile
gtree
├── cmd
│ └── gtree
│ └── main.go
├── testdata
│ ├── sample1.md
│ └── sample2.md
├── Makefile
└── tree.go
4 directories, 5 files
Any invalid file or directory name will result in an error.
$ gtree mkdir --dry-run <<EOS
- root
- aa
- bb
- b/b
EOS
invalid node name: b/b$ gtree mkdir --dry-run <<EOS
- /root
- aa
- bb
- bb
EOS
invalid node name: /root$ gtree verify --help
NAME:
gtree verify - Verifies tree structure represented in markdown by comparing it with existing directories.
Let's try 'gtree template | gtree verify'.
USAGE:
gtree verify [command options] [arguments...]
OPTIONS:
--file value, -f value specify the path to markdown file. (default: stdin)
--target-dir value set this option if you want to specify the directory you want to verify. (default: current directory)
--strict set this option if you want strict directory match validation. (default: non strict)
--help, -h show help$ tree example
example
├── README.md
├── find_pipe_programmable-gtree
│ ├── README.md
│ ├── go.mod
│ ├── go.sum
│ └── main.go
├── go-list_pipe_programmable-gtree
│ ├── README.md
│ ├── go.mod
│ ├── go.sum
│ └── main.go
├── like_cli
│ ├── adapter
│ │ ├── executor.go
│ │ └── indentation.go
│ └── main.go
├── noexist
│ └── xxx
└── programmable
└── main.go
6 directories, 14 files
$ cat testdata/sample9.md
- example
- README.md
- find_pipe_programmable-gtree
- README.md
- go.mod
- go.sum
- main.go
- go-list_pipe_programmable-gtree
- README.md
- go.mod
- go.sum
- main.go
- like_cli
- adapter
- executor.go
- indentation.go
- main.go
- kkk
- programmable
- main.go
$ cat testdata/sample9.md | gtree verify --strict
Extra paths exist:
example/noexist
example/noexist/xxx
Required paths does not exist:
example/like_cli/kkkinspired by mactat/framed !
Go version requires 1.18 or later.
$ go get github.com/ddddddO/gtreeThe symbols that can be used in Markdown are *, -, +, and #.
| Function | Description | Available optional functions |
|---|---|---|
| Output | can output trees | WithBranchFormatIntermedialNode WithBranchFormatLastNode WithEncodeJSON WithEncodeTOML WithEncodeYAML WithMassive |
| Mkdir | can create directories | WithTargetDir WithFileExtensions WithDryRun WithMassive |
| Verify | can output the difference between markdown and directories | WithTargetDir WithStrictVerify WithMassive |
| Walk | can execute user-defined function while traversing tree structure recursively | WithBranchFormatIntermedialNode WithBranchFormatLastNode WithMassive |
package main
import (
"bytes"
"fmt"
"os"
"strings"
"github.com/ddddddO/gtree"
)
func main() {
r1 := bytes.NewBufferString(strings.TrimSpace(`
- root
- dddd
- kkkkkkk
- lllll
- ffff
- LLL
- WWWWW
- ZZZZZ
- ppppp
- KKK
- 1111111
- AAAAAAA
- eee`))
if err := gtree.Output(os.Stdout, r1); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// root
// ├── dddd
// │ └── kkkkkkk
// │ └── lllll
// │ ├── ffff
// │ ├── LLL
// │ │ └── WWWWW
// │ │ └── ZZZZZ
// │ └── ppppp
// │ └── KKK
// │ └── 1111111
// │ └── AAAAAAA
// └── eee
r2 := bytes.NewBufferString(strings.TrimSpace(`
- a
- i
- u
- k
- kk
- t
- e
- o
- g`))
// You can customize branch format.
if err := gtree.Output(os.Stdout, r2,
gtree.WithBranchFormatIntermedialNode("+->", ": "),
gtree.WithBranchFormatLastNode("+->", " "),
); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// a
// +-> i
// : +-> u
// : : +-> k
// : : +-> kk
// : +-> t
// +-> e
// : +-> o
// +-> g
}gtree.WithEncodeJSON()gtree.WithEncodeTOML()gtree.WithEncodeYAML()
You can use gtree.WithFileExtensions func to make specified extensions as file.
You can use gtree.WithTargetDir func / gtree.WithStrictVerify func.
See sample program
package main
import (
"fmt"
"os"
"strings"
"github.com/ddddddO/gtree"
)
func main() {
src := strings.TrimSpace(`
- a
- i
- u
- k
- kk
- t
- e
- o
- g`)
callback := func(wn *gtree.WalkerNode) error {
fmt.Println(wn.Row())
return nil
}
if err := gtree.Walk(strings.NewReader(src), callback); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// a
// ├── i
// │ └── u
// │ └── k
// └── kk
// └── t
// e
// └── o
// └── g
callback2 := func(wn *gtree.WalkerNode) error {
fmt.Println("WalkerNode's methods called...")
fmt.Printf("\tName : %s\n", wn.Name())
fmt.Printf("\tBranch : %s\n", wn.Branch())
fmt.Printf("\tRow : %s\n", wn.Row())
fmt.Printf("\tLevel : %d\n", wn.Level())
fmt.Printf("\tPath : %s\n", wn.Path())
fmt.Printf("\tHasChild : %t\n", wn.HasChild())
return nil
}
if err := gtree.Walk(strings.NewReader(src), callback2); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// WalkerNode's methods called...
// Name : a
// Branch :
// Row : a
// Level : 1
// Path : a
// HasChild : true
// WalkerNode's methods called...
// Name : i
// Branch : ├──
// Row : ├── i
// Level : 2
// Path : a/i
// HasChild : true
// WalkerNode's methods called...
// Name : u
// Branch : │ └──
// Row : │ └── u
// Level : 3
// Path : a/i/u
// HasChild : true
// WalkerNode's methods called...
// Name : k
// Branch : │ └──
// Row : │ └── k
// Level : 4
// Path : a/i/u/k
// HasChild : false
// WalkerNode's methods called...
// Name : kk
// Branch : └──
// Row : └── kk
// Level : 2
// Path : a/kk
// HasChild : true
// WalkerNode's methods called...
// Name : t
// Branch : └──
// Row : └── t
// Level : 3
// Path : a/kk/t
// HasChild : false
// WalkerNode's methods called...
// Name : e
// Branch :
// Row : e
// Level : 1
// Path : e
// HasChild : true
// WalkerNode's methods called...
// Name : o
// Branch : └──
// Row : └── o
// Level : 2
// Path : e/o
// HasChild : true
// WalkerNode's methods called...
// Name : g
// Branch : └──
// Row : └── g
// Level : 3
// Path : e/o/g
// HasChild : false
}inspired by xlab/treeprint !
Note
The gonew command can be used to set up sample project using gtree library.
See here for details.
Go version requires 1.18 or later.
$ go get github.com/ddddddO/gtree| Function | Description | Available optional functions |
|---|---|---|
| OutputProgrammably | can output tree | WithBranchFormatIntermedialNode WithBranchFormatLastNode WithEncodeJSON WithEncodeTOML WithEncodeYAML |
| MkdirProgrammably | can create directories | WithTargetDir WithFileExtensions WithDryRun |
| VerifyProgrammably | can output the difference between tree you composed and directories | WithTargetDir WithStrictVerify |
| WalkProgrammably | can execute user-defined function while traversing tree structure recursively | WithBranchFormatIntermedialNode WithBranchFormatLastNode |
package main
import (
"fmt"
"os"
"github.com/ddddddO/gtree"
)
func main() {
var root *gtree.Node = gtree.NewRoot("root")
root.Add("child 1").Add("child 2").Add("child 3")
var child4 *gtree.Node = root.Add("child 1").Add("child 2").Add("child 4")
child4.Add("child 5")
child4.Add("child 6").Add("child 7")
root.Add("child 8")
// you can customize branch format.
if err := gtree.OutputProgrammably(os.Stdout, root,
gtree.WithBranchFormatIntermedialNode("+--", ": "),
gtree.WithBranchFormatLastNode("+--", " "),
); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// root
// +-- child 1
// : +-- child 2
// : +-- child 3
// : +-- child 4
// : +-- child 5
// : +-- child 6
// : +-- child 7
// +-- child 8
primate := preparePrimate()
// default branch format.
if err := gtree.OutputProgrammably(os.Stdout, primate); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// Primate
// ├── Strepsirrhini
// │ ├── Lemuriformes
// │ │ ├── Lemuroidea
// │ │ │ ├── Cheirogaleidae
// │ │ │ ├── Indriidae
// │ │ │ ├── Lemuridae
// │ │ │ └── Lepilemuridae
// │ │ └── Daubentonioidea
// │ │ └── Daubentoniidae
// │ └── Lorisiformes
// │ ├── Galagidae
// │ └── Lorisidae
// └── Haplorrhini
// ├── Tarsiiformes
// │ └── Tarsiidae
// └── Simiiformes
// ├── Platyrrhini
// │ ├── Ceboidea
// │ │ ├── Atelidae
// │ │ └── Cebidae
// │ └── Pithecioidea
// │ └── Pitheciidae
// └── Catarrhini
// ├── Cercopithecoidea
// │ └── Cercopithecidae
// └── Hominoidea
// ├── Hylobatidae
// └── Hominidae
}
func preparePrimate() *gtree.Node {
primate := gtree.NewRoot("Primate")
strepsirrhini := primate.Add("Strepsirrhini")
haplorrhini := primate.Add("Haplorrhini")
lemuriformes := strepsirrhini.Add("Lemuriformes")
lorisiformes := strepsirrhini.Add("Lorisiformes")
lemuroidea := lemuriformes.Add("Lemuroidea")
lemuroidea.Add("Cheirogaleidae")
lemuroidea.Add("Indriidae")
lemuroidea.Add("Lemuridae")
lemuroidea.Add("Lepilemuridae")
lemuriformes.Add("Daubentonioidea").Add("Daubentoniidae")
lorisiformes.Add("Galagidae")
lorisiformes.Add("Lorisidae")
haplorrhini.Add("Tarsiiformes").Add("Tarsiidae")
simiiformes := haplorrhini.Add("Simiiformes")
platyrrhini := haplorrhini.Add("Platyrrhini")
ceboidea := platyrrhini.Add("Ceboidea")
ceboidea.Add("Atelidae")
ceboidea.Add("Cebidae")
platyrrhini.Add("Pithecioidea").Add("Pitheciidae")
catarrhini := simiiformes.Add("Catarrhini")
catarrhini.Add("Cercopithecoidea").Add("Cercopithecidae")
hominoidea := catarrhini.Add("Hominoidea")
hominoidea.Add("Hylobatidae")
hominoidea.Add("Hominidae")
return primate
}package main
import (
"bufio"
"fmt"
"os"
"strings"
"github.com/ddddddO/gtree"
)
// Example:
// $ cd github.com/ddddddO/gtree
// $ find . -type d -name .git -prune -o -type f -print
// ./config.go
// ./node_generator_test.go
// ./example/like_cli/adapter/indentation.go
// ./example/like_cli/adapter/executor.go
// ./example/like_cli/main.go
// ./example/find_pipe_programmable-gtree/main.go
// ...
// $ find . -type d -name .git -prune -o -type f -print | go run example/find_pipe_programmable-gtree/main.go
// << See "Output:" below. >>
func main() {
var (
root *gtree.Node
node *gtree.Node
)
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
line := scanner.Text() // e.g.) "./example/find_pipe_programmable-gtree/main.go"
splited := strings.Split(line, "/") // e.g.) [. example find_pipe_programmable-gtree main.go]
for i, s := range splited {
if root == nil {
root = gtree.NewRoot(s) // s := "."
node = root
continue
}
if i == 0 {
continue
}
tmp := node.Add(s)
node = tmp
}
node = root
}
if err := gtree.OutputProgrammably(os.Stdout, root); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// .
// ├── config.go
// ├── node_generator_test.go
// ├── example
// │ ├── like_cli
// │ │ ├── adapter
// │ │ │ ├── indentation.go
// │ │ │ └── executor.go
// │ │ └── main.go
// │ ├── find_pipe_programmable-gtree
// │ │ └── main.go
// │ ├── go-list_pipe_programmable-gtree
// │ │ └── main.go
// │ └── programmable
// │ └── main.go
// ├── file_considerer.go
// ├── node.go
// ├── node_generator.go
// ├── .gitignore
// ...
}package main
import (
"fmt"
"github.com/ddddddO/gtree"
)
func main() {
primate := preparePrimate()
if err := gtree.MkdirProgrammably(primate); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output(using Linux 'tree' command):
// 22:20:43 > tree Primate/
// Primate/
// ├── Haplorrhini
// │ ├── Simiiformes
// │ │ ├── Catarrhini
// │ │ │ ├── Cercopithecoidea
// │ │ │ │ └── Cercopithecidae
// │ │ │ └── Hominoidea
// │ │ │ ├── Hominidae
// │ │ │ └── Hylobatidae
// │ │ └── Platyrrhini
// │ │ ├── Ceboidea
// │ │ │ ├── Atelidae
// │ │ │ └── Cebidae
// │ │ └── Pithecioidea
// │ │ └── Pitheciidae
// │ └── Tarsiiformes
// │ └── Tarsiidae
// └── Strepsirrhini
// ├── Lemuriformes
// │ ├── Daubentonioidea
// │ │ └── Daubentoniidae
// │ └── Lemuroidea
// │ ├── Cheirogaleidae
// │ ├── Indriidae
// │ ├── Lemuridae
// │ └── Lepilemuridae
// └── Lorisiformes
// ├── Galagidae
// └── Lorisidae
//
// 28 directories, 0 files
}package main
import (
"fmt"
"github.com/ddddddO/gtree"
)
func main() {
gtreeDir := gtree.NewRoot("gtree")
gtreeDir.Add("cmd").Add("gtree").Add("main.go")
gtreeDir.Add("Makefile")
testdataDir := gtreeDir.Add("testdata")
testdataDir.Add("sample1.md")
testdataDir.Add("sample2.md")
gtreeDir.Add("tree.go")
// make directories and files with specific extensions.
if err := gtree.MkdirProgrammably(
gtreeDir,
gtree.WithFileExtensions([]string{".go", ".md", "Makefile"}),
); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output(using Linux 'tree' command):
// 09:44:50 > tree gtree/
// gtree/
// ├── cmd
// │ └── gtree
// │ └── main.go
// ├── Makefile
// ├── testdata
// │ ├── sample1.md
// │ └── sample2.md
// └── tree.go
//
// 3 directories, 5 files
}You can use gtree.WithTargetDir func / gtree.WithStrictVerify func.
package main
import (
"fmt"
"os"
"github.com/ddddddO/gtree"
)
func main() {
root := gtree.NewRoot("root")
root.Add("child 1").Add("child 2").Add("child 3")
root.Add("child 5")
root.Add("child 1").Add("child 2").Add("child 4")
callback := func(wn *gtree.WalkerNode) error {
fmt.Println(wn.Row())
return nil
}
if err := gtree.WalkProgrammably(root, callback); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// root
// ├── child 1
// │ └── child 2
// │ ├── child 3
// │ └── child 4
// └── child 5
callback2 := func(wn *gtree.WalkerNode) error {
fmt.Println("WalkerNode's methods called...")
fmt.Printf("\tName : %s\n", wn.Name())
fmt.Printf("\tBranch : %s\n", wn.Branch())
fmt.Printf("\tRow : %s\n", wn.Row())
fmt.Printf("\tLevel : %d\n", wn.Level())
fmt.Printf("\tPath : %s\n", wn.Path())
fmt.Printf("\tHasChild : %t\n", wn.HasChild())
return nil
}
if err := gtree.WalkProgrammably(root, callback2); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
// Output:
// WalkerNode's methods called...
// Name : root
// Branch :
// Row : root
// Level : 1
// Path : root
// HasChild : true
// WalkerNode's methods called...
// Name : child 1
// Branch : ├──
// Row : ├── child 1
// Level : 2
// Path : root/child 1
// HasChild : true
// WalkerNode's methods called...
// Name : child 2
// Branch : │ └──
// Row : │ └── child 2
// Level : 3
// Path : root/child 1/child 2
// HasChild : true
// WalkerNode's methods called...
// Name : child 3
// Branch : │ ├──
// Row : │ ├── child 3
// Level : 4
// Path : root/child 1/child 2/child 3
// HasChild : false
// WalkerNode's methods called...
// Name : child 4
// Branch : │ └──
// Row : │ └── child 4
// Level : 4
// Path : root/child 1/child 2/child 4
// HasChild : false
// WalkerNode's methods called...
// Name : child 5
// Branch : └──
// Row : └── child 5
// Level : 2
// Path : root/child 5
// HasChild : false
}Note
This process is for the Massive Roots mode.
Warning
Depends on the environment.
- Comparison simple implementation and pipeline implementation.
- In the case of few Roots, simple implementation is faster in execution!
- Use this one by default.
- However, for multiple Roots, pipeline implementation execution speed tends to be faster💪✨
- In the CLI, it is available by specifying
--massive. - In the Go program, it is available by specifying
WithMassivefunc.
- In the CLI, it is available by specifying
Benchmark log
11:19:22 > go test -benchmem -bench Benchmark -benchtime 100x benchmark_simple_test.go
goos: linux
goarch: amd64
cpu: Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz
BenchmarkOutput_singleRoot-4 100 35375 ns/op 13856 B/op 171 allocs/op
BenchmarkOutput_tenRoots-4 100 200540 ns/op 72920 B/op 1597 allocs/op
BenchmarkOutput_fiftyRoots-4 100 730156 ns/op 569851 B/op 7919 allocs/op
BenchmarkOutput_hundredRoots-4 100 1706493 ns/op 1714260 B/op 15820 allocs/op
BenchmarkOutput_fiveHundredsRoots-4 100 16412090 ns/op 32245140 B/op 79022 allocs/op
BenchmarkOutput_thousandRoots-4 100 55142492 ns/op 120929674 B/op 158025 allocs/op
BenchmarkOutput_3000Roots-4 100 489121246 ns/op 1035617527 B/op 474029 allocs/op
BenchmarkOutput_6000Roots-4 100 1613641261 ns/op 4087694372 B/op 948033 allocs/op
BenchmarkOutput_10000Roots-4 100 3913090646 ns/op 11293191221 B/op 1580035 allocs/op
PASS
ok command-line-arguments 614.944s11:29:43 > go test -benchmem -bench Benchmark -benchtime 100x benchmark_pipeline_test.go
goos: linux
goarch: amd64
cpu: Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz
BenchmarkOutput_pipeline_singleRoot-4 100 188706 ns/op 24236 B/op 300 allocs/op
BenchmarkOutput_pipeline_tenRoots-4 100 367758 ns/op 115970 B/op 2186 allocs/op
BenchmarkOutput_pipeline_fiftyRoots-4 100 947879 ns/op 542188 B/op 10592 allocs/op
BenchmarkOutput_pipeline_hundredRoots-4 100 1711537 ns/op 1099636 B/op 21094 allocs/op
BenchmarkOutput_pipeline_fiveHundredsRoots-4 100 6892261 ns/op 5524905 B/op 105107 allocs/op
BenchmarkOutput_pipeline_thousandRoots-4 100 13100335 ns/op 11225942 B/op 210115 allocs/op
BenchmarkOutput_pipeline_3000Roots-4 100 40694497 ns/op 33399766 B/op 630142 allocs/op
BenchmarkOutput_pipeline_6000Roots-4 100 85807944 ns/op 66974524 B/op 1260171 allocs/op
BenchmarkOutput_pipeline_10000Roots-4 100 151486713 ns/op 113908462 B/op 2100208 allocs/op
PASS
ok command-line-arguments 30.670s- Want to output a tree in Go?
- Generate directory trees🌳 and the directories itself📁 using Markdown or Programmatically.
- Goでtreeを表現する
- Markdown形式の入力からtreeを出力するCLI/Web
- Markdown形式の入力からファイル/ディレクトリを生成するCLI/Goパッケージ
- 盆栽 (節目の記事)
- 感想
...generated by nikolaydubina/go-cover-treemap !
Footnotes
-
Gopher retrieved from egonelbre/gophers ! ↩
![@dependabot[bot]](https://avatars.githubusercontent.com/in/29110?s=64&v=4){kind=small}
![@github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=64&v=4){kind=small}
