将通用 map 转换为 YAML。 语言

Question

So, I am working on a program where you have to generate the YAML file which represents the directory tree from a given directory location( path ). For example..

sc
├── file.go
├── file_test.go
└── src
    ├── deploy
    │   ├── deploy.go
    │   └── deploy_test.go
    ├── pod.go
    └── pod_test.go

This should be converted into

sc:
  fileTest: "true"
  src:
    deploy:
      deployTest: "true"
  podTest: "true"

Note that in above only the files with _test are chosen (it is conditional not much of a problem). My question is how do you generate a generic map[string]interface{} type of map from the directory tree which can be represented via a YAML. I have tried writing a DFS implementation to walk through the tree and generate a n-ary tree. Which has the following output. I get the root Node object for the tree.

name: sc
children:
- name: file.go
  children: []
- name: file_test.go
  children: []
- name: src
  children:
  - name: deploy
    children:
    - name: deploy.go
      children: []
    - name: deploy_test.go
      children: []
  - name: pod.go
    children: []
  - name: pod_test.go
    children: []

but as you can see it was unmarshalled using the datatype which represents every node.

//Node is the datatype which stores information regarding the file/directory
type Node struct {
    Name     string
    Path     string
    Children []*Node
}

I want a generic YAML where every key is different. Any ideas? Something like this would help.

func (node *Node) ToMap() map[string]interface{}{
 //Logic
}

DFS Code to generate the tree

func IteratePath(path string) {
    rootFile, err := os.Stat(path)
    if err != nil {
        logrus.Error("Path : ", path, " doesn't exist. ", err)
    }
    rootfile := ToFile(rootFile, path)
    stack := []*tree.Node{rootfile}
    for len(stack) > 0 {
        file := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        children, _ := ioutil.ReadDir(file.Path)
        for _, chld := range children {
            child := ToFile(chld, filepath.Join(file.Path, chld.Name()))
            file.Children = append(file.Children, child)
            stack = append(stack, child)
        }
    }

func ToFile(file os.FileInfo, path string) *tree.Node {
    outFile := tree.Node{
        Name:     file.Name(),
        Children: []*tree.Node{},
        Path:     path,
    }
    return &outFile
}

Answer 1

You're already using recursion (with a stack variable instead of the call stack), so why not use recursion again to translate your tree into nested maps. Here's a method I wrote to do that starting with a node (based on your Node struct above):

The tree to nested map method:

type Node struct {
    Name     string
    Children []*Node
}

func (n *Node) ToMap() interface{} {
    if len(n.Children) < 1 {
        return "true"
    }

    yamlMap := make(map[string]interface{})

    for _, child := range n.Children {
        yamlMap[child.Name] = child.ToMap()
    }

    return yamlMap
}

The map generated by this function is marshal-able by gopkg.in/yaml.v2 into a YAML file of the format you want.

Here's the code running in Go Playground including marshalling to YAML