ddddddo / gtree

Using either Markdown or Programmatically to generate trees🌳 and directories📁, and to verify directories🔍. Provide CLI, Golang library and Web.

¹

Using either Markdown or Programmatically to generate directory trees🌳 and directories🗂, and to verify directories🔍. Provide CLI, Golang library and Web.

Table of Contents

• Acknowledgments
• Features
  • Web
  • CLI
  • Library - Markdown to tree structure
  • Library - Programmable tree structure
    • Recommended for developers!👍
• Documents
• Process
• Performance
• Test coverage

Acknowledgments

Thanks for providing very useful CLI for cloud storage tree output🤩🎉
Everyone is encouraged to use them!

⭐orangekame3/stree

CLI for Amazon S3 tree output.
aws s3 command does not do what tree command does, but stree command can display tree!

⭐owlinux1000/gcstree

CLI for Google Cloud Storage tree output.
gcloud storage command does not do what tree command does, but gcstree command can display tree!

Web

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 web

source code

CLI

Installation

Go (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.apk

AUR
$ 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

etc

download binary from here.

Usage

$ 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

Output subcommand

$ 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

Try it!

$ 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.go

Other pattern.

├── 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 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)

Multiple roots

$ 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

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 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: []

Output TOML

$ 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 = []

Mkdir subcommand

$ 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

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.go

8 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.go

3 directories, 5 files

dry run

Does 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

Verify subcommand

$ 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

Try it!

$ 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/kkk

inspired by mactat/framed !

Library - Markdown to tree structure

Installation

Go version requires 1.18 or later.

$ go get github.com/ddddddO/gtree

Usage

The 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

Output func

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
}

You can also output JSON/YAML/TOML.

• gtree.WithEncodeJSON()
• gtree.WithEncodeTOML()
• gtree.WithEncodeYAML()

Mkdir func

gtree.Mkdir func makes directories.

You can use gtree.WithFileExtensions func to make specified extensions as file.

Verify func

gtree.Verify func verifies directories.

You can use gtree.WithTargetDir func / gtree.WithStrictVerify func.

Walk 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 !

Library - Programmable tree structure

Note

The gonew command can be used to set up sample project using gtree library.
See here for details.

Installation

Go version requires 1.18 or later.

$ go get github.com/ddddddO/gtree

Usage

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

OutputProgrammably func

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
}

The program below converts the result of find into a tree.

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
	// ...
}

MkdirProgrammably func

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
}

details

Make directories and files with specific extensions.

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
}

VerifyProgrammably func

You can use gtree.WithTargetDir func / gtree.WithStrictVerify func.

WalkProgrammably 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
}

Process

Note

This process is for the Massive Roots mode.

e.g. gtree/pipeline_tree.go

Performance

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 WithMassive func.

Benchmark log

Simple implementation

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.944s

Pipeline implementation

11: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

Documents

• GoDoc

English

• Want to output a tree in Go?
• Generate directory trees🌳 and the directories itself📁 using Markdown or Programmatically.

Japanese

• Goでtreeを表現する
• Markdown形式の入力からtreeを出力するCLI/Web
• Markdown形式の入力からファイル/ディレクトリを生成するCLI/Goパッケージ
• 盆栽 (節目の記事)
• 感想

Test coverage

...generated by nikolaydubina/go-cover-treemap !

Star History

Footnotes

1. Gopher retrieved from egonelbre/gophers ! ↩

gtree's Issues

呼び出して安全でないメソッドがチラホラあるので改善する

どこでエラーが起きたのかわからない

エラーにその行を含める

コードから呼び出してもらうディレクトリ生成関数のdry run

• command

  • これは、--dry-run指定でダメなnode名を検知（ディレクトリの作成は一切しない） & ダメでなければtree出力の実装でよい（ディレクトリの作成は一切しない）

• package

  • Mkdir func
    • commandと同じでいい
  • MkdirProgrammably func
    • デフォルトでダメなnode名検知でエラー（ディレクトリの作成は一切しない）
    • WithDryRun funcが与えられたらtreeを出力する（ディレクトリの作成は一切しない）

---

メモ

• WithDryRunってプログラムで扱うのは微妙な気がする。安全にディレクトリ生成するまでに2回MkdirProgrammably呼び出すということだから、いっそMkdirProgrammablyでデフォルトでバリデーションしたほうが良さそう
• cliが使ってるパッケージも外部に公開してるからそうした方がいいのかも、、

textarea内でtab使えるようにしたい

幅は2で。
https://freefielder.jp/sp/2020/05/input-custon-sized-tab-in-textarea.html

awesome-markdownに載せられないか

https://github.com/BubuAnabelas/awesome-markdown#converters

出力をLinux treeだけにしたくない

インスパイア：https://github.com/birchb1024/frangipanni

上のリポジトリはCLIとして提供している。
ExecuteProgrammablyで、出力のフォーマットを選択できるようにしたい。jsonとか。
grow/expandをインタフェースとして定義して、Linux tree / json などのフォーマットで出力できるような実装を書く。

時間がたぶんかなりかかりそうなのでメモだけ。

gtree.Executeは戻り値に文字列を返すではなく、引数にio.Writer型を取るようにして呼び出し元が柔軟な使い方ができるようにする

計算量を出す

不味いんだろうなとは思ってる

出力結果に色をつけたい

空行はエラーでなくスキップするようにする

それだけでも結構使いやすくなりそう

localの/mnt/cから~/へ主要リポジトリを移動する

• 以下リポジトリを移動した
  calma
  database
  gdag
  grpc-example
  gtree
  homebrew-tap
  kafun
  memo
  profile
  programs
  qoo
  sensor-pi
  sip
  work
  ddddddO
  godash
  dologger
  9cc
  zo
  wordcloud
  extxt
  gwc
  goree

nodejsからも呼び出せるようにする

以下にヒントが書いてある

• https://zenn.dev/sosukesuzuki/articles/da220d4796ca94
• https://zenn.dev/sosukesuzuki/articles/af1f9afdc7275e

npmパッケージとして公開したい

• https://nodachisoft.com/common/jp/article/jp000110/
• https://tech.012grp.co.jp/entry/2021/07/29/172744
  • こちら参考に、このリポジトリで公開可能か試してからやってみた方が手戻り無さそう
  • package.jsonについて
    • いけそう

  If the package.json for your package is not in the root directory (for example if it is part of a monorepo),
  you can specify the directory in which it lives:

npm CLI toolとして公開したい

• https://numb86-tech.hatenablog.com/entry/2020/06/03/203722

ユーザーがファイルとして扱いたいものを判別する機能が横断的関心事となってるので共通化したい

Web siteのdescriptionが検索結果に反映されない

site:https://ddddddo.github.io/gtree/ でググると、以下のdescriptionが表示される。
textareaの一部の内容が表示されているため、以下の文字数内で検索にヒットしやすいキーワードをtextareaに入れてみる。

Primate - Strepsirrhini - Lemuriformes - Lemuroidea - Cheirogaleidae - Indriidae - Lemuridae - Lepilemuridae - Daubentonioidea - Daubentoniidae ...

↓

Output tree from Markdown. - 手作業で枝を組み立てるのは面倒、 - 楽にツリー(treeコマンド(Linux/Windows)結果のようなテキスト) - を作りたい時に役に立ちます。 - 枝を変えられます。

パッケージを切りたい

• Node structが、publicでかつコードのあちこちで使われてるので、そこを何とかする必要がある。
  • このgtreeパッケージを使う人に公開したいものはルートディレクトリ直下に置いておいていい
  • このgtree内部でのみNodeを使っているところはinterface越しに呼び出すようにしたい
• 関連
  • #58

programableにする

github.com/pkg/errorsをやめて別のを使う

メソッドチェーンの方が良さそうに思えてきた

WithXxxxの関数を以下な感じで呼び出したい

• かっこいい
• package名いちいち書かなくて済む
  • エディタで続けてメソッドの候補として出してくれる
• 今の実装と後方互換性がない
  • 既存の関数はdeprecatedとマークして一定期間残す
  • 新関数は命名変えて定義

	err := gtree.OutputProgrammably(os.Stdout, root).
		WithBranchFormatIntermedialNode("+--", ":   ").
		WithBranchFormatLastNode("+--", "    ").
		Do()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

ユーザーがMarkdownを定義してtemplateサブコマンドなどで出力できるようにしたい

案

• ①ホームディレクトリ以下にconfigファイルを置いて、gtree template xxxのように実行すると定義されたMarkdownを出力する

雑にmarkdown食わせても出力できた方がいいのではないか？

マークダウンパーサを一応作ったので、対応してない行がきたら、それとわかるエラー返して、呼び出し元でスキップさせていいんでないか

複数rootに対応したい

根

各testのnameに含まれる連番をやめたい

descriptionが分かりづらい

とコメントをもらった。
https://www.reddit.com/r/programming/comments/sa1uw1/comment/htrxvqf/?utm_source=share&utm_medium=web2x&context=3
場合によっては、関数名・メソッド名も合わせて変えた方がいいかも。

あと、このツール（パッケージ）の利点・ユースケースはなにかをdescriptionに記載した方がいいかもしれない。

dryrunとnodeのvalidationの概念がごっちゃになってコードに現れてる

ファイル作成機能

何らかのファイル形式(json,tomlなど)からツリーを生成するのはメリットあるか考える

textareaにMarkdownを貼り付けた場合によしなにMarkdownをフォーマットしてくれるようにしたい

tree! ボタン押下時に、tree出力する関数に入力を渡す前に、いい感じにフォーマットできる何かを導入したい

dry-runしたとき、どれがファイル・ディレクトリかわかるように色を付けたい

• ファイル出力時に色の文字列はいらないか -> 入ってしまう

/mnt/c/DEV/workspace/GO/src/github.com/ddddddO/work/go/color
11:20:36 > go run main.go > tmp

でtmpの中身

�[30mHello, world!�[0m
�[31mHello, world!�[0m
�[32mHello, world!�[0m
�[33mHello, world!�[0m
�[34mHello, world!�[0m
�[35mHello, world!�[0m
�[36mHello, world!�[0m
�[37mHello, world!�[0m

• os毎に実装変えないといけなかったりするか？
• コードから呼び出す関数の場合はどうするか？

ドキュメント更新

使える記号が増えたこと
空行はエラーでなくスキップすること

Markdownパーサーを作りたい

• 入力として対応しているのがMarkdownの - のみなので、他の記法も対応したい
• 構文解析器を作りたい

type Node structのpublicフィールドをやめたい

json/toml/yamlにエンコードするときにフィールドがpublicでないとダメなので今はそうしているが、それをやめたい。
json/toml/yaml用のNode用structを定義して、そのフィールドをpublicにしてNodeを詰め替えれば可能そう。
ただ、Nodeが自己参照型のstructなため、面倒。

tree様の入力からMarkdown形式の出力が欲しい

--decodeオプション

treeコマンドの結果からMarkdownな形式のアウトが出力されるのは、割と需要ありそうな気もする。

ディレクトリ生成機能

• document更新
  • README
    • 各種README
    • v1.2.4から非互換であることを明記
    • dry-runで出力されるツリーと実際に作成されるディレクトリではソートの有無があることを明記
  • godoc
    • 公開メソッド・フィールドにコメントつける
  • zenn
  • awesome-goにPR投げる
  • github上のabout
• ディレクトリ生成機能追加
• [Only programable]各Node毎にユーザー定義関数を実行できるようにする どこで実行させるかでてこなかった
  • Nodeメソッドの公開・あると良さそうなメソッド追加
• コマンドラインフラグが複雑になってきてるからgithub.com/urfave/cli/v2使う
  • tree出力モード
    • stdout or yaml or toml ro json
  • ディレクトリ生成モード
    • dry run
    • 生成
  • helpを充実させるのと、入力になるMarkdownのテンプレート出力するのもいいかも
  • フラグのデフォルト値を設定する。helpで出力したとき、何がデフォルトかわからない、例えばmarkdownのデフォルトがtabであるとか
• リファクタ
  • option func のプレフィックスにWithつける
  • コメント全部英語にする
  • 不適当なネーミングなど
• テスト

エラー処理を追加する

Node structを関心の分離させてみる

以下のイメージ

• tree_grow.go: Nodeをそのまま使う
• tree_spread.go: Node -> SpreadNodeなstructに変換したものを使う
• tree_mkdir.go: Node -> MkdirNodeなstructに変換したものを使う

cmd/gtreeを実行するDockerfileを用意する

t/o

リファクタ

• ファイル名が動詞で終わっているものにはerをつける
• initializeTreeではなく、newTreeでいい
  • grow,spread,mkdir用のabstract factory関数作ってnewTreeで呼び出すようにする、かも。冗長感ある。
• grow,spread,mkdir用interfaceはtree.goに移動した方がいいかなぁと思ってきた。

main.goをファイル分けたい

mkdirサブコマンド実行時とdryrunフラグ付き実行時とで結果が異なる

• 同じ親の下に同じ名前のnodeが同じ階層にいるのが原因。どうしよう。標準出力以外問題はないけど直せるなら直したい。

19:46:02 > cat testdata/sample2.md | gtree mkdir --dry-run
k8s_resources
├── (Tier3)
│   └── (Tier2)        
│       └── (Tier1)    
│           └── (Tier0)
├── Deployment
│   └── ReplicaSet     
│       └── Pod        
│           └── container(s)
├── CronJob
│   └── Job
│       └── Pod
│           └── container(s)
├── (empty)
│   └── DaemonSet
│       └── Pod
│           └── container(s)
└── (empty)
    └── StatefulSet
        └── Pod
            └── container(s)

21 directories, 0 files

19:46:10 > cat testdata/sample2.md | gtree mkdir
/mnt/c/DEV/workspace/GO/src/github.com/ddddddO/gtree
19:50:39 > tree k8s_resources/
k8s_resources/
├── (Tier3)
│   └── (Tier2)
│       └── (Tier1)
│           └── (Tier0)
├── (empty)
│   ├── DaemonSet
│   │   └── Pod
│   │       └── container(s)
│   └── StatefulSet
│       └── Pod
│           └── container(s)
├── CronJob
│   └── Job
│       └── Pod
│           └── container(s)
└── Deployment
    └── ReplicaSet
        └── Pod
            └── container(s)

19 directories, 0 files

cmd/gtree直下のflagの値のvalidationにビット演算を検討する

シンプルな実装になりそう

やっぱりparserぽいparserを作りたい

関連 #98

redditのwebdevへ宣伝する

• title: Tree Maker __ Convert markdown to tree!
• tags: OC, ShowoffSaturday
• image&video: web_example.gif

↓
以下をコメントで投稿

The link to this website is https://ddddddo.github.io/gtree/

Usage is as follows.
- The symbols that can be used in Markdown are *, -, +, and #.
- Use every two spaces to represent a hierarchy.

This website features.
- The function to generate tree is written in Go and compiled to WebAssembly.
- It uses ServiceWorker, so you can load it once and then enjoy it offline!

I provide not only website, but also CLI tool and Go package. These also have the ability to generate directories from markdown!
The repository is https://github.com/ddddddO/gtree
I'd love it if you'd star it!

mkdirサブコマンド実行時に既存のルートディレクトリがあればエラーを返す

• 実行時にエラー
• --dry-runモード実行時にエラー

node_generate_strategy.goの各メソッドが複雑

11:13:26 > gocognito --over=10 .
/mnt/c/DEV/workspace/GO/src/github.com/ddddddO/gtree/node_generate_strategy.go:40:1: func (*tabStrategy).generate cognitive complexity: 15
/mnt/c/DEV/workspace/GO/src/github.com/ddddddO/gtree/node_generate_strategy.go:89:1: func (*twoSpacesStrategy).generate cognitive complexity: 15
/mnt/c/DEV/workspace/GO/src/github.com/ddddddO/gtree/node_generate_strategy.go:136:1: func (*fourSpacesStrategy).generate cognitive complexity: 15

• 各generateメソッドで、行ごとに最後の文字までチェックしてhierarchyとtextを計算しているが、もっと簡素にできないか
  • hierarchyまで計算できれば、あとはrow[startText: len(row)]でtextとして処理を分割できそうな気がした。
  • node_generate_strategy_test.go にテストを追加しつつ変更する

encode MessagePack

• https://github.com/vmihailenco/msgpack
• https://github.com/nokute78/msgpack-microscope/blob/master/cmd/msgpack2json/README.md

---

19:39:13 > go install github.com/nokute78/msgpack-microscope/cmd/msgpack2json@latest
19:40:53 > cat testdata/sample1.md | go run cmd/gtree/main.go -m | msgpack2json
{"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a161a86368696c6472656e9482a576616c7565a3767676a86368696c6472656e9182a576616c7565a36a6a6aa86368696c6472656ec082a576616c7565a46b676767a86368696c6472656e9282a576616c7565a46b6b6464a86368696c6472656ec082a576616c7565a474676767a86368696c6472656ec082a576616c7565a56564646464a86368696c6472656e9182a576616c7565a46f727272a86368696c6472656ec082a576616c7565a467676767a86368696c6472656ec0", "value":
    [
        {"key":
            {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
         "value":
            {"format":"fixstr", "header":"0xa1", "raw":"0xa161", "value":"a"}
        },
        {"key":
            {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
         "value":
            {"format":"fixarray", "header":"0x94", "length":4, "raw":"0x9482a576616c7565a3767676a86368696c6472656e9182a576616c7565a36a6a6aa86368696c6472656ec082a576616c7565a46b676767a86368696c6472656e9282a576616c7565a46b6b6464a86368696c6472656ec082a576616c7565a474676767a86368696c6472656ec082a576616c7565a56564646464a86368696c6472656e9182a576616c7565a46f727272a86368696c6472656ec082a576616c7565a467676767a86368696c6472656ec0", "value":
                [
                    {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a3767676a86368696c6472656e9182a576616c7565a36a6a6aa86368696c6472656ec0", "value":
                        [
                            {"key":
                                {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                             "value":
                                {"format":"fixstr", "header":"0xa3", "raw":"0xa3767676", "value":"vvv"}
                            },
                            {"key":
                                {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                             "value":
                                {"format":"fixarray", "header":"0x91", "length":1, "raw":"0x9182a576616c7565a36a6a6aa86368696c6472656ec0", "value":
                                    [
                                        {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a36a6a6aa86368696c6472656ec0", "value":
                                            [
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                                                 "value":
                                                    {"format":"fixstr", "header":"0xa3", "raw":"0xa36a6a6a", "value":"jjj"}
                                                },
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                                                 "value":
                                                    {"format":"nil", "header":"0xc0", "raw":"0xc0", "value":null}
                                                }
                                            ]
                                        }
                                    ]
                                }

                            }
                        ]
                    },
                    {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a46b676767a86368696c6472656e9282a576616c7565a46b6b6464a86368696c6472656ec082a576616c7565a474676767a86368696c6472656ec0", "value":
                        [
                            {"key":
                                {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                             "value":
                                {"format":"fixstr", "header":"0xa4", "raw":"0xa46b676767", "value":"kggg"}
                            },
                            {"key":
                                {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                             "value":
                                {"format":"fixarray", "header":"0x92", "length":2, "raw":"0x9282a576616c7565a46b6b6464a86368696c6472656ec082a576616c7565a474676767a86368696c6472656ec0", "value":
                                    [
                                        {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a46b6b6464a86368696c6472656ec0", "value":
                                            [
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                                                 "value":
                                                    {"format":"fixstr", "header":"0xa4", "raw":"0xa46b6b6464", "value":"kkdd"}
                                                },
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                                                 "value":
                                                    {"format":"nil", "header":"0xc0", "raw":"0xc0", "value":null}
                                                }
                                            ]
                                        },
                                        {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a474676767a86368696c6472656ec0", "value":
                                            [
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                                                 "value":
                                                    {"format":"fixstr", "header":"0xa4", "raw":"0xa474676767", "value":"tggg"}
                                                },
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                                                 "value":
                                                    {"format":"nil", "header":"0xc0", "raw":"0xc0", "value":null}
                                                }
                                            ]
                                        }
                                    ]
                                }

                            }
                        ]
                    },
                    {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a56564646464a86368696c6472656e9182a576616c7565a46f727272a86368696c6472656ec0", "value":
                        [
                            {"key":
                                {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                             "value":
                                {"format":"fixstr", "header":"0xa5", "raw":"0xa56564646464", "value":"edddd"}
                            },
                            {"key":
                                {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                             "value":
                                {"format":"fixarray", "header":"0x91", "length":1, "raw":"0x9182a576616c7565a46f727272a86368696c6472656ec0", "value":
                                    [
                                        {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a46f727272a86368696c6472656ec0", "value":
                                            [
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                                                 "value":
                                                    {"format":"fixstr", "header":"0xa4", "raw":"0xa46f727272", "value":"orrr"}
                                                },
                                                {"key":
                                                    {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                                                 "value":
                                                    {"format":"nil", "header":"0xc0", "raw":"0xc0", "value":null}
                                                }
                                            ]
                                        }
                                    ]
                                }

                            }
                        ]
                    },
                    {"format":"fixmap", "header":"0x82", "length":2, "raw":"0x82a576616c7565a467676767a86368696c6472656ec0", "value":
                        [
                            {"key":
                                {"format":"fixstr", "header":"0xa5", "raw":"0xa576616c7565", "value":"value"},
                             "value":
                                {"format":"fixstr", "header":"0xa4", "raw":"0xa467676767", "value":"gggg"}
                            },
                            {"key":
                                {"format":"fixstr", "header":"0xa8", "raw":"0xa86368696c6472656e", "value":"children"},
                             "value":
                                {"format":"nil", "header":"0xc0", "raw":"0xc0", "value":null}
                            }
                        ]
                    }
                ]
            }

        }
    ]
}

19:41:15 > cat testdata/sample1.md 
- a
        - vvv
                - jjj
        - kggg
                - kkdd
                - tggg
        - edddd
                - orrr
        - gggg

ServiceWorker、バージョン変えてもロードしてくれない

https://azisava.sakura.ne.jp/programming/0037.html

Windowsユーザー向けにScoopでインストールできるようにしたい

• scoopが良いそう
  • http://www2.nagano.ac.jp/hiraoka/ANY/scoop.html
• たぶん、以下辺りを参考にすれば良さそう
  • https://github.com/arrow2nd/nimotsu/blob/a42248879d3d9d8bd2dd329af3cbd4f916c70f3a/.goreleaser.yml#L42

インプットのファイルを監視してツリーを生成する

• 以下、wsl2でうまく動作しなかった
  • https://github.com/rjeczalik/notify
  • https://github.com/fsnotify/fsnotify
• tickerで定期的にファイルのstatを見るようにするかも

Webページ開いてtree!押下でツリー出力しない事がある

• それまでそんな挙動してなかったから、gtree-wasm配下のコミット履歴調べる
• firefox, edgeは大丈夫そう。プライベートウィンドウで確認した。chromeだけ？
  • edge, chromeは、https://github.com/ddddddO/gtree から遷移するとダメみたい。プライベートウィンドウで確認した。

使ってるcliパッケージ v3にした方がいい？

github.com/urfave/cli/v3