Table of Contents

Acknowledgments

Thanks for providing very useful CLI for cloud storage tree output🤩🎉

⭐orangekame3/stree

⭐owlinux1000/gcstree

gtree packeage has been utilized for other tools as well🚀

Web

$gtree web

CLI

Installation

etc

Usage

$gtree --helpNAME:   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 85520a1COMMANDS:   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 commandGLOBAL OPTIONS:   --help, -h     show help   --version, -v  print the version

Output subcommand

$gtree output --helpNAME:   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

Try it!

$gtree template- gtree        - cmd                - gtree                        - main.go        - testdata                - sample1.md                - sample2.md        - Makefile        - tree.go$gtree template| gtree outputgtree├── cmd│   └── gtree│       └── main.go├── testdata│   ├── sample1.md│   └── sample2.md├── Makefile└── tree.go

├── gtree output -f testdata/sample1.md├── cat testdata/sample1.md | gtree output -f -└── cat testdata/sample1.md | gtree output

Usage other than representing a directory.

$cat testdata/sample2.md| gtree outputk8s_resources├── (Tier3)│   └── (Tier2)│       └── (Tier1)│           └── (Tier0)├── Deployment│   └── ReplicaSet│       └── Pod│           └── container(s)├── CronJob│   └── Job│       └── Pod│           └── container(s)└── (empty)    ├── DaemonSet    │   └── Pod    │       └── container(s)    └── StatefulSet        └── Pod            └── container(s)

Multiple roots

$cat testdata/sample6.md| gtree outputArtiodactyla├── Artiofabula│   ├── Cetruminantia│   │   ├── Whippomorpha│   │   │   ├── Hippopotamidae│   │   │   └── Cetacea│   │   └── Ruminantia│   └── Suina└── TylopodaCarnivora├── Feliformia└── Caniformia    ├── Canidae    └── Arctoidea        ├── Ursidae        └── x            ├── Pinnipedia            └── Musteloidea                ├── Ailuridae                └── x                    ├── Mephitidae                    └── x                        ├── Procyonidae                        └── Mustelidae

Output JSON

$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    }  ]}

Output YAML

$cat testdata/sample5.md| gtree output --format yamlvalue: achildren:- value: i  children:  - value: u    children:    - value: k      children: []    - value: kk      children: []  - value: t    children: []- value: e  children:  - value: o    children: []- value: g  children: []

Output TOML

$cat testdata/sample5.md| gtree output --format tomlvalue = '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 = []

Mkdir subcommand

$gtree mkdir --helpNAME:   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

Try it!

$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.go8 directories, 0 files

make directories and 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.go3 directories, 5 files

dry run

$gtree template| gtree mkdir --dry-run -e .go -e .md -e Makefilegtree├── cmd│   └── gtree│       └── main.go├── testdata│   ├── sample1.md│   └── sample2.md├── Makefile└── tree.go4 directories, 5 files

$gtree mkdir --dry-run<<EOS- root  - aa  - bb    - b/bEOSinvalid node name: b/b

$gtree mkdir --dry-run<<EOS- /root  - aa  - bb    - bbEOSinvalid node name: /root

Verify subcommand

$gtree verify --helpNAME:   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

Try it!

$tree exampleexample├── 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.go6 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 --strictExtra paths exist:        example/noexist        example/noexist/xxxRequired paths does not exist:        example/like_cli/kkk

Library - Markdown to tree structure

Installation

$go get github.com/ddddddO/gtree

Usage

Output func

package mainimport ("bytes""fmt""os""strings""github.com/ddddddO/gtree")funcmain() {r1:=bytes.NewBufferString(strings.TrimSpace(`- root- dddd- kkkkkkk- lllll- ffff- LLL- WWWWW- ZZZZZ- ppppp- KKK- 1111111- AAAAAAA- eee`))iferr:=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// └── eeer2:=bytes.NewBufferString(strings.TrimSpace(`- a  - i    - u      - k      - kk    - t  - e    - o  - g`))// You can customize branch format.iferr:=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}

You can also output JSON/YAML/TOML.

Mkdir func

gtree.Mkdir func makes directories.

Verify func

gtree.Verify func verifies directories.

Walk func

Library - Programmable tree structure

Note

Thegonew command can be used to set up sample project using gtree library.
Seehere for details.

Installation

$go get github.com/ddddddO/gtree

Usage

OutputProgrammably func

package mainimport ("fmt""os""github.com/ddddddO/gtree")funcmain() {varroot*gtree.Node=gtree.NewRoot("root")root.Add("child 1").Add("child 2").Add("child 3")varchild4*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.iferr:=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 8primate:=preparePrimate()// default branch format.iferr:=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}funcpreparePrimate()*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")returnprimate}

The program below converts the result offind into a tree.

package mainimport ("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. >>funcmain() {var (root*gtree.Nodenode*gtree.Node)scanner:=bufio.NewScanner(os.Stdin)forscanner.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]fori,s:=rangesplited {ifroot==nil {root=gtree.NewRoot(s)// s := "."node=rootcontinue}ifi==0 {continue}tmp:=node.Add(s)node=tmp}node=root}iferr:=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// ...}

MkdirProgrammably func

package mainimport ("fmt""github.com/ddddddO/gtree")funcmain() {primate:=preparePrimate()iferr:=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}

Make directories and files with specific extensions.

package mainimport ("fmt""github.com/ddddddO/gtree")funcmain() {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.iferr:=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}

VerifyProgrammably func

WalkProgrammably func

package mainimport ("fmt""os""github.com/ddddddO/gtree")funcmain() {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())returnnil}iferr:=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 5callback2:=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())returnnil}iferr:=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}

Process

Note

This process is for the Massive Roots mode.

e.g.gtree/pipeline_tree.go

Performance

Warning

Depends on the environment.

Documents

English

Japanese

Test coverage

Stargazers over time