path.go

package gitconfig

import (
	"bufio"
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strings"
)

const (
	gitSystemConfigEnv = "TEST_GIT_SYSTEM_CONFIG"
)

// homeDir returns home directory
func homeDir() (string, error) {
	var (
		home string
	)

	if runtime.GOOS == "windows" {
		home = os.Getenv("USERPROFILE")
		if home == "" {
			home = os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
		}
	}
	if home == "" {
		home = os.Getenv("HOME")
	}

	if home == "" {
		return "", fmt.Errorf("cannot find HOME")
	}

	return home, nil
}

func xdgConfigHome(file string) (string, error) {
	var (
		home string
		err  error
	)

	home = os.Getenv("XDG_CONFIG_HOME")
	if home != "" {
		return filepath.Join(home, "git", file), nil
	}

	home, err = homeDir()
	if err != nil {
		return "", err
	}

	return filepath.Join(home, ".config", "git", file), nil
}

// expendHome expends path prefix "~/" to home dir
func expendHome(name string) (string, error) {
	if filepath.IsAbs(name) {
		return name, nil
	}

	home, err := homeDir()
	if err != nil {
		return "", err
	}

	if len(name) == 0 || name == "~" {
		return home, nil
	} else if len(name) > 1 && name[0] == '~' && (name[1] == '/' || name[1] == '\\') {
		return filepath.Join(home, name[2:]), nil
	}

	return filepath.Join(home, name), nil
}

// absPath returns absolute path and will expend homedir if path has "~/' prefix
func absPath(name string) (string, error) {
	if name == "" {
		return os.Getwd()
	}

	if filepath.IsAbs(name) {
		return name, nil
	}

	if len(name) > 0 && name[0] == '~' && (len(name) == 1 || name[1] == '/' || name[1] == '\\') {
		return expendHome(name)
	}

	return filepath.Abs(name)
}

// absJoin returns absolute path, and use <dir> as parent dir for relative path
func absJoin(dir, name string) (string, error) {
	if name == "" {
		return filepath.Abs(dir)
	}

	if filepath.IsAbs(name) {
		return name, nil
	}

	if len(name) > 0 && name[0] == '~' && (len(name) == 1 || name[1] == '/' || name[1] == '\\') {
		return expendHome(name)
	}

	return absPath(filepath.Join(dir, name))
}

func getWorkTree(gitDir string) (string, error) {
	var err error

	if !filepath.IsAbs(gitDir) {
		gitDir, err = filepath.Abs(gitDir)
		if err != nil {
			return "", err
		}
	}
	// A git-worktree gitdir?
	fn := filepath.Join(gitDir, "gitdir")
	f, err := os.Open(fn)
	if err == nil {
		s := bufio.NewScanner(f)
		if s.Scan() {
			if !filepath.IsAbs(s.Text()) {
				gitDir = filepath.Join(gitDir, s.Text())
			} else {
				gitDir = s.Text()
			}
		}
		f.Close()
	}
	if filepath.Base(gitDir) != ".git" {
		return "", fmt.Errorf("repository name is not '.git', a bare repository?")
	}
	return filepath.Dir(gitDir), nil
}

func getGitCommonDir(gitDir string) (string, error) {
	commonDir := gitDir
	if IsFile(filepath.Join(gitDir, "commondir")) {
		f, err := os.Open(filepath.Join(gitDir, "commondir"))
		if err == nil {
			s := bufio.NewScanner(f)
			if s.Scan() {
				commonDir = s.Text()
				if !filepath.IsAbs(commonDir) {
					commonDir = filepath.Join(gitDir, commonDir)
				}
			}
			f.Close()
		}
	}

	if IsFile(filepath.Join(commonDir, "config")) &&
		IsDir(filepath.Join(commonDir, "refs")) &&
		IsDir(filepath.Join(commonDir, "objects")) {
		return commonDir, nil
	}
	return "", fmt.Errorf("'%s' is not a valid gitdir", commonDir)
}

// isGitDir test whether dir is a valid git dir
func isGitDir(dir string) bool {
	if !IsFile(filepath.Join(dir, "HEAD")) {
		return false
	}

	_, err := getGitCommonDir(dir)
	return err == nil
}

// findGitDir searches git dir
func findGitDir(dir string) (string, error) {
	var err error

	dir, err = absPath(dir)
	if err != nil {
		return "", err
	}

	for {
		// Check if is in a bare repo
		if isGitDir(dir) {
			return dir, nil
		}

		// Check .git
		gitdir := filepath.Join(dir, ".git")
		fi, err := os.Stat(gitdir)
		if err != nil {
			// Test parent dir
			oldDir := dir
			dir = filepath.Dir(dir)
			if oldDir == dir {
				break
			}
			continue
		} else if fi.IsDir() {
			if isGitDir(gitdir) {
				return gitdir, nil
			}
			return "", fmt.Errorf("corrupt git dir: %s", gitdir)
		} else {
			f, err := os.Open(gitdir)
			if err != nil {
				return "", fmt.Errorf("cannot open gitdir file '%s'", gitdir)
			}
			defer f.Close()
			reader := bufio.NewReader(f)
			line, err := reader.ReadString('\n')
			if strings.HasPrefix(line, "gitdir:") {
				realgit := strings.TrimSpace(strings.TrimPrefix(line, "gitdir:"))
				if !filepath.IsAbs(realgit) {
					realgit, err = absJoin(filepath.Dir(gitdir), realgit)
					if err != nil {
						return "", err
					}
				}
				if isGitDir(realgit) {
					return realgit, nil
				}
				return "", fmt.Errorf("gitdir '%s' points to corrupt git repo: %s", gitdir, realgit)
			}
			return "", fmt.Errorf("bad gitdir file '%s'", gitdir)
		}
	}
	return "", ErrNotInGitDir
}

// FindGitConfig returns local git config file
func FindGitConfig(dir string) (string, error) {
	var err error

	if dir, err = findGitDir(dir); err != nil {
		return "", err
	}
	if dir, err = getGitCommonDir(dir); err != nil {
		return "", err
	}
	return filepath.Join(dir, "config"), nil
}

// SystemConfigFile returns system git config file
func SystemConfigFile() string {
	file := os.Getenv(gitSystemConfigEnv)
	if file == "" {
		file = "/etc/gitconfig"
	}
	return file
}

// GlobalConfigFile returns global git config file
func GlobalConfigFile() (string, error) {
	var (
		file string
		err  error
	)

	file, err = xdgConfigHome("config")
	if err != nil {
		return "", err
	}

	// xdg config not exist, use ~/.gitconfig
	if _, err := os.Stat(file); err != nil {
		file, err = expendHome(".gitconfig")
		if err != nil {
			return "", err
		}
	}
	return file, nil
}

// unsetHome unsets HOME related environments
func unsetHome() {
	if runtime.GOOS == "windows" {
		os.Unsetenv("USERPROFILE")
		os.Unsetenv("HOMEDRIVE")
		os.Unsetenv("HOMEPATH")
	}
	os.Unsetenv("HOME")
}

// setHome sets proper HOME environments
func setHome(home string) {
	if runtime.GOOS == "windows" {
		os.Setenv("USERPROFILE", home)
		if strings.Contains(home, ":\\") {
			slices := strings.SplitN(home, ":\\", 2)
			if len(slices) == 2 {
				os.Setenv("HOMEDRIVE", slices[0]+":")
				os.Setenv("HOMEPATH", "\\"+slices[1])
			}
		}
	} else {
		os.Setenv("HOME", home)
	}
}

// Exist check if path is exist.
func Exist(name string) bool {
	if _, err := os.Stat(name); err == nil {
		return true
	}
	return false
}

// IsFile returns true if path is exist and is a file.
func IsFile(name string) bool {
	fi, err := os.Stat(name)
	if err != nil || fi.IsDir() {
		return false
	}
	return true
}

// IsDir returns true if path is exist and is a directory.
func IsDir(name string) bool {
	fi, err := os.Stat(name)
	if err != nil || !fi.IsDir() {
		return false
	}
	return true
}