git 配置文件读取和写入

[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
	ignorecase = true
	precomposeunicode = true
[submodule]
	active = .
[remote "origin"]
	url = https://github.com/xxx/xxx.git
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
	remote = origin
	merge = refs/heads/master
[submodule "lib/xxx"]
	url = https://github.com/xxx/xxx
[submodule "lib/xxx"]
	url = https://github.com/xxx/xxx

type ConfFile struct {
	core       map[string]string
	submodule  map[string]string
	remote     map[string]map[string]string
	branch     map[string]map[string]string
	submodules map[string]map[string]string
}

func NewConfFle() ConfFile {
	return ConfFile{
		core: map[string]string{
			"repositoryformatversion": "0",
			"filemode":                "true",
			"bare":                    "false",
			"logallrefupdates":        "true",
			"ignorecase":              "true",
			"precomposeunicode":       "true",
		},
	}
}

func ReadFileToConf(path string) (*ConfFile, error) {
	confFile := &ConfFile{}
	var currentSection string
	var currentSubSection string
	file, err := os.Open(path)
	if err != nil {
		panic("配置文件不存在")
	}
	defer file.Close()

    // 读取每行内容
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		//约定注释为 # 跳过注释和空行
		if strings.HasPrefix(line, "#") || line == "" {
			continue
		}

		if strings.HasPrefix(line, "[") && strings.HasSuffix(line, "]") {
			sectionLine := line[1 : len(line)-1]
			currentSection = ""
			currentSubSection = ""

			if sectionSplit := strings.SplitN(sectionLine, " ", 2); len(sectionSplit) == 2 {
				currentSection = sectionSplit[0]
				currentSubSection = sectionSplit[1]
			} else {
				currentSection = sectionLine
			}
			continue
		}
		if currentSection != "" {
			parts := strings.SplitN(line, "=", 2)
			if len(parts) != 2 {
				continue
			}
			key := parts[0]
			value := parts[1]

			switch currentSection {
			case "core":
				confFile.core[key] = value
			case "submodule":
				if currentSubSection == "" {
					confFile.submodule[key] = value
				} else {
					confFile.submodules[currentSubSection][key] = value
				}
			case "remote":
				if currentSubSection == "" {
					panic("conf 文件格式不正确")
				}
				confFile.remote[currentSubSection][key] = value
			case "branch":
				if currentSubSection == "" {
					panic("conf 文件格式不正确")
				}
				confFile.branch[currentSubSection][key] = value
			}

		}

	}
	if err := scanner.Err(); err != nil {
		return nil, err
	}
	return confFile, nil
}

func (c *ConfFile) WriteToFile(path string) error {
	if _, err := os.Stat(path); os.IsNotExist(err) {
		panic("不是一个 git目录,无法写入文件")
	}
	file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
	if err != nil {
		panic("打开文件失败")
	}
	defer func(file *os.File) {
		err := file.Close()
		if err != nil {

		}
	}(file)

	// 写入  core
	_, err = file.WriteString("[core]\n")
	if err != nil {
		panic("写入失败")
	}
	for k, v := range c.core {
		_, err := file.WriteString("        " + k + "=" + v + "\n")
		if err != nil {
			panic("写入失败")
		}
	}

	// 写入  submodule
	if c.submodule != nil {
		_, err = file.WriteString("[submodule]\n")
		if err != nil {
			return err
		}
		for k, v := range c.submodule {
			_, err := file.WriteString("        " + k + "=" + v + "\n")
			if err != nil {
				panic("写入失败")
			}
		}
	}

	// 写入 remote
	if c.remote != nil {
		for k1, v1 := range c.submodules {
			_, err := file.WriteString("[remote " + k1 + "]\n")
			if err != nil {
				return err
			}
			if v1 == nil {
				continue
			}
			for k2, v2 := range v1 {
				_, err := file.WriteString("        " + k2 + "=" + v2 + "\n")
				if err != nil {
					panic("写入失败")
				}
			}
		}
	}

	// 写入  branch
	if c.branch != nil {
		for k1, v1 := range c.branch {
			_, err := file.WriteString("[branch " + k1 + "]\n")
			if err != nil {
				return err
			}
			if v1 == nil {
				continue
			}
			for k2, v2 := range v1 {
				_, err := file.WriteString("        " + k2 + "=" + v2 + "\n")
				if err != nil {
					panic("写入失败")
				}
			}
		}
	}

	// 写入  submodules
	if c.submodules != nil {
		for k1, v1 := range c.branch {
			_, err := file.WriteString("[submodules " + k1 + "]\n")
			if err != nil {
				return err
			}
			if v1 == nil {
				continue
			}
			for k2, v2 := range v1 {
				_, err := file.WriteString("        " + k2 + "=" + v2 + "\n")
				if err != nil {
					panic("写入失败")
				}
			}
		}
	}
	return nil
}