2016-05-18 10:43:42 +00:00
|
|
|
// Package config collects together all configuration settings
|
|
|
|
// NOTE: Subject to change, do not rely on this package from outside git-lfs source
|
2016-05-13 16:38:06 +00:00
|
|
|
package config
|
2013-11-05 17:07:03 +00:00
|
|
|
|
2013-11-05 17:45:01 +00:00
|
|
|
import (
|
2017-10-18 20:45:53 +00:00
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
2017-10-24 21:22:13 +00:00
|
|
|
"strings"
|
2015-04-23 01:07:52 +00:00
|
|
|
"sync"
|
2015-05-13 19:43:41 +00:00
|
|
|
|
2017-10-24 21:22:13 +00:00
|
|
|
"github.com/git-lfs/git-lfs/fs"
|
2017-10-18 18:34:36 +00:00
|
|
|
"github.com/git-lfs/git-lfs/git"
|
2016-11-15 17:01:18 +00:00
|
|
|
"github.com/git-lfs/git-lfs/tools"
|
2017-10-24 21:22:13 +00:00
|
|
|
"github.com/rubyist/tracerx"
|
2013-11-05 17:45:01 +00:00
|
|
|
)
|
|
|
|
|
2015-06-17 20:38:09 +00:00
|
|
|
var (
|
2015-11-24 18:58:52 +00:00
|
|
|
ShowConfigWarnings = false
|
|
|
|
defaultRemote = "origin"
|
|
|
|
gitConfigWarningPrefix = "lfs."
|
2015-06-17 20:38:09 +00:00
|
|
|
)
|
|
|
|
|
2013-11-05 17:07:03 +00:00
|
|
|
type Configuration struct {
|
2016-08-04 20:41:04 +00:00
|
|
|
// Os provides a `*Environment` used to access to the system's
|
2016-08-03 22:07:05 +00:00
|
|
|
// environment through os.Getenv. It is the point of entry for all
|
|
|
|
// system environment configuration.
|
2016-08-15 19:17:11 +00:00
|
|
|
Os Environment
|
2016-08-03 22:07:05 +00:00
|
|
|
|
2016-08-05 20:16:29 +00:00
|
|
|
// Git provides a `*Environment` used to access to the various levels of
|
|
|
|
// `.gitconfig`'s. It is the point of entry for all Git environment
|
|
|
|
// configuration.
|
2016-08-15 19:17:11 +00:00
|
|
|
Git Environment
|
2016-08-05 23:23:56 +00:00
|
|
|
|
2017-10-27 21:11:54 +00:00
|
|
|
currentRemote *string
|
2017-11-03 16:36:12 +00:00
|
|
|
pushRemote *string
|
2017-10-24 21:58:42 +00:00
|
|
|
|
2017-10-18 18:52:24 +00:00
|
|
|
// gitConfig can fetch or modify the current Git config and track the Git
|
2017-10-18 18:34:36 +00:00
|
|
|
// version.
|
2017-10-18 18:52:24 +00:00
|
|
|
gitConfig *git.Configuration
|
2017-10-18 18:34:36 +00:00
|
|
|
|
2017-10-27 22:38:49 +00:00
|
|
|
ref *git.Ref
|
2017-10-31 17:23:37 +00:00
|
|
|
remoteRef *git.Ref
|
2017-10-24 21:58:42 +00:00
|
|
|
fs *fs.Filesystem
|
|
|
|
gitDir *string
|
|
|
|
workDir string
|
2017-04-14 16:46:28 +00:00
|
|
|
loading sync.Mutex // guards initialization of gitConfig and remotes
|
2017-10-24 21:58:42 +00:00
|
|
|
loadingGit sync.Mutex // guards initialization of local git and working dirs
|
2017-04-14 16:46:28 +00:00
|
|
|
remotes []string
|
|
|
|
extensions map[string]Extension
|
2013-11-05 17:07:03 +00:00
|
|
|
}
|
|
|
|
|
2016-07-21 23:38:44 +00:00
|
|
|
func New() *Configuration {
|
2017-10-25 18:20:25 +00:00
|
|
|
return NewIn("", "")
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewIn(workdir, gitdir string) *Configuration {
|
2017-10-25 19:47:13 +00:00
|
|
|
gitConf := git.NewConfig(workdir, gitdir)
|
2017-10-18 18:34:36 +00:00
|
|
|
c := &Configuration{
|
2017-10-27 21:11:54 +00:00
|
|
|
Os: EnvironmentOf(NewOsFetcher()),
|
|
|
|
gitConfig: gitConf,
|
2017-10-18 18:34:36 +00:00
|
|
|
}
|
2017-10-25 18:20:25 +00:00
|
|
|
|
2017-10-25 19:47:13 +00:00
|
|
|
if len(gitConf.WorkDir) > 0 {
|
|
|
|
c.gitDir = &gitConf.GitDir
|
|
|
|
c.workDir = gitConf.WorkDir
|
2017-10-25 18:20:25 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 20:45:53 +00:00
|
|
|
c.Git = &delayedEnvironment{
|
|
|
|
callback: func() Environment {
|
2017-10-19 00:35:03 +00:00
|
|
|
sources, err := gitConf.Sources(filepath.Join(c.LocalWorkingDir(), ".lfsconfig"))
|
2017-10-18 20:45:53 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Error reading git config: %s\n", err)
|
|
|
|
}
|
|
|
|
return c.readGitConfig(sources...)
|
|
|
|
},
|
2017-10-18 18:34:36 +00:00
|
|
|
}
|
2015-03-05 19:59:52 +00:00
|
|
|
return c
|
|
|
|
}
|
|
|
|
|
2017-10-18 20:45:53 +00:00
|
|
|
func (c *Configuration) readGitConfig(gitconfigs ...*git.ConfigurationSource) Environment {
|
|
|
|
gf, extensions, uniqRemotes := readGitConfig(gitconfigs...)
|
|
|
|
c.extensions = extensions
|
|
|
|
c.remotes = make([]string, 0, len(uniqRemotes))
|
2018-07-26 18:40:47 +00:00
|
|
|
for remote := range uniqRemotes {
|
2017-10-18 20:45:53 +00:00
|
|
|
c.remotes = append(c.remotes, remote)
|
|
|
|
}
|
|
|
|
|
|
|
|
return EnvironmentOf(gf)
|
|
|
|
}
|
|
|
|
|
2016-08-03 23:42:21 +00:00
|
|
|
// Values is a convenience type used to call the NewFromValues function. It
|
|
|
|
// specifies `Git` and `Env` maps to use as mock values, instead of calling out
|
|
|
|
// to real `.gitconfig`s and the `os.Getenv` function.
|
|
|
|
type Values struct {
|
2016-08-04 20:41:04 +00:00
|
|
|
// Git and Os are the stand-in maps used to provide values for their
|
2016-08-03 23:42:21 +00:00
|
|
|
// respective environments.
|
2017-04-12 21:29:11 +00:00
|
|
|
Git, Os map[string][]string
|
2016-08-03 23:42:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewFrom returns a new `*config.Configuration` that reads both its Git
|
|
|
|
// and Enviornment-level values from the ones provided instead of the actual
|
|
|
|
// `.gitconfig` file or `os.Getenv`, respectively.
|
2016-05-31 16:38:02 +00:00
|
|
|
//
|
2016-08-03 23:42:21 +00:00
|
|
|
// This method should only be used during testing.
|
|
|
|
func NewFrom(v Values) *Configuration {
|
2017-10-18 20:45:53 +00:00
|
|
|
c := &Configuration{
|
2017-10-27 21:11:54 +00:00
|
|
|
Os: EnvironmentOf(mapFetcher(v.Os)),
|
|
|
|
gitConfig: git.NewConfig("", ""),
|
2016-05-31 16:38:02 +00:00
|
|
|
}
|
2017-10-18 20:45:53 +00:00
|
|
|
c.Git = &delayedEnvironment{
|
|
|
|
callback: func() Environment {
|
|
|
|
source := &git.ConfigurationSource{
|
|
|
|
Lines: make([]string, 0, len(v.Git)),
|
|
|
|
}
|
|
|
|
|
|
|
|
for key, values := range v.Git {
|
|
|
|
for _, value := range values {
|
|
|
|
fmt.Printf("Config: %s=%s\n", key, value)
|
|
|
|
source.Lines = append(source.Lines, fmt.Sprintf("%s=%s", key, value))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return c.readGitConfig(source)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return c
|
2016-05-31 16:38:02 +00:00
|
|
|
}
|
|
|
|
|
2016-07-25 18:50:58 +00:00
|
|
|
// BasicTransfersOnly returns whether to only allow "basic" HTTP transfers.
|
2016-06-10 07:43:32 +00:00
|
|
|
// Default is false, including if the lfs.basictransfersonly is invalid
|
2016-06-09 10:45:24 +00:00
|
|
|
func (c *Configuration) BasicTransfersOnly() bool {
|
2016-08-15 21:43:38 +00:00
|
|
|
return c.Git.Bool("lfs.basictransfersonly", false)
|
2016-06-09 10:45:24 +00:00
|
|
|
}
|
|
|
|
|
2016-07-25 18:50:58 +00:00
|
|
|
// TusTransfersAllowed returns whether to only use "tus.io" HTTP transfers.
|
|
|
|
// Default is false, including if the lfs.tustransfers is invalid
|
|
|
|
func (c *Configuration) TusTransfersAllowed() bool {
|
2016-08-15 21:43:38 +00:00
|
|
|
return c.Git.Bool("lfs.tustransfers", false)
|
2016-06-09 10:45:24 +00:00
|
|
|
}
|
|
|
|
|
2016-05-31 15:48:09 +00:00
|
|
|
func (c *Configuration) FetchIncludePaths() []string {
|
2016-08-05 21:59:57 +00:00
|
|
|
patterns, _ := c.Git.Get("lfs.fetchinclude")
|
|
|
|
return tools.CleanPaths(patterns, ",")
|
2015-08-06 13:56:57 +00:00
|
|
|
}
|
2016-05-27 19:11:24 +00:00
|
|
|
|
2016-05-31 15:48:09 +00:00
|
|
|
func (c *Configuration) FetchExcludePaths() []string {
|
2016-08-05 22:30:25 +00:00
|
|
|
patterns, _ := c.Git.Get("lfs.fetchexclude")
|
2016-08-05 21:59:57 +00:00
|
|
|
return tools.CleanPaths(patterns, ",")
|
2015-08-06 13:56:57 +00:00
|
|
|
}
|
|
|
|
|
2017-10-27 22:38:49 +00:00
|
|
|
func (c *Configuration) CurrentRef() *git.Ref {
|
|
|
|
c.loading.Lock()
|
|
|
|
defer c.loading.Unlock()
|
|
|
|
if c.ref == nil {
|
|
|
|
r, err := git.CurrentRef()
|
|
|
|
if err != nil {
|
|
|
|
tracerx.Printf("Error loading current ref: %s", err)
|
|
|
|
c.ref = &git.Ref{}
|
|
|
|
} else {
|
|
|
|
c.ref = r
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return c.ref
|
|
|
|
}
|
|
|
|
|
2017-10-27 21:31:46 +00:00
|
|
|
func (c *Configuration) IsDefaultRemote() bool {
|
|
|
|
return c.Remote() == defaultRemote
|
|
|
|
}
|
|
|
|
|
2017-10-27 22:42:49 +00:00
|
|
|
// Remote returns the default remote based on:
|
|
|
|
// 1. The currently tracked remote branch, if present
|
|
|
|
// 2. Any other SINGLE remote defined in .git/config
|
|
|
|
// 3. Use "origin" as a fallback.
|
|
|
|
// Results are cached after the first hit.
|
2017-10-27 21:00:07 +00:00
|
|
|
func (c *Configuration) Remote() string {
|
2017-10-27 22:38:49 +00:00
|
|
|
ref := c.CurrentRef()
|
|
|
|
|
|
|
|
c.loading.Lock()
|
|
|
|
defer c.loading.Unlock()
|
|
|
|
|
2017-10-27 21:11:54 +00:00
|
|
|
if c.currentRemote == nil {
|
2017-10-27 22:38:49 +00:00
|
|
|
if len(ref.Name) == 0 {
|
|
|
|
c.currentRemote = &defaultRemote
|
|
|
|
return defaultRemote
|
|
|
|
}
|
|
|
|
|
|
|
|
if remote, ok := c.Git.Get(fmt.Sprintf("branch.%s.remote", ref.Name)); ok {
|
|
|
|
// try tracking remote
|
|
|
|
c.currentRemote = &remote
|
|
|
|
} else if remotes := c.Remotes(); len(remotes) == 1 {
|
|
|
|
// use only remote if there is only 1
|
|
|
|
c.currentRemote = &remotes[0]
|
2017-10-27 21:32:01 +00:00
|
|
|
} else {
|
2017-10-27 22:38:49 +00:00
|
|
|
// fall back to default :(
|
2017-10-27 21:32:01 +00:00
|
|
|
c.currentRemote = &defaultRemote
|
|
|
|
}
|
2017-10-27 21:11:54 +00:00
|
|
|
}
|
|
|
|
return *c.currentRemote
|
2017-10-27 21:00:07 +00:00
|
|
|
}
|
|
|
|
|
2017-11-03 16:36:12 +00:00
|
|
|
func (c *Configuration) PushRemote() string {
|
|
|
|
ref := c.CurrentRef()
|
|
|
|
c.loading.Lock()
|
|
|
|
defer c.loading.Unlock()
|
|
|
|
|
|
|
|
if c.pushRemote == nil {
|
|
|
|
if remote, ok := c.Git.Get(fmt.Sprintf("branch.%s.pushRemote", ref.Name)); ok {
|
|
|
|
c.pushRemote = &remote
|
|
|
|
} else if remote, ok := c.Git.Get("remote.pushDefault"); ok {
|
|
|
|
c.pushRemote = &remote
|
|
|
|
} else {
|
|
|
|
c.loading.Unlock()
|
|
|
|
remote := c.Remote()
|
|
|
|
c.loading.Lock()
|
|
|
|
|
|
|
|
c.pushRemote = &remote
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *c.pushRemote
|
|
|
|
}
|
|
|
|
|
2017-10-27 22:20:38 +00:00
|
|
|
func (c *Configuration) SetValidRemote(name string) error {
|
|
|
|
if err := git.ValidateRemote(name); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
c.SetRemote(name)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-07-20 23:38:39 +00:00
|
|
|
func (c *Configuration) SetValidPushRemote(name string) error {
|
|
|
|
if err := git.ValidateRemote(name); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
c.SetPushRemote(name)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-10-27 21:00:07 +00:00
|
|
|
func (c *Configuration) SetRemote(name string) {
|
2017-10-27 21:11:54 +00:00
|
|
|
c.currentRemote = &name
|
2017-10-27 21:00:07 +00:00
|
|
|
}
|
|
|
|
|
2018-07-20 23:38:39 +00:00
|
|
|
func (c *Configuration) SetPushRemote(name string) {
|
|
|
|
c.pushRemote = &name
|
|
|
|
}
|
|
|
|
|
2014-02-01 20:38:29 +00:00
|
|
|
func (c *Configuration) Remotes() []string {
|
2015-03-05 19:49:15 +00:00
|
|
|
c.loadGitConfig()
|
2014-02-01 20:38:29 +00:00
|
|
|
return c.remotes
|
|
|
|
}
|
|
|
|
|
2015-07-10 20:54:06 +00:00
|
|
|
func (c *Configuration) Extensions() map[string]Extension {
|
|
|
|
c.loadGitConfig()
|
|
|
|
return c.extensions
|
|
|
|
}
|
|
|
|
|
2016-05-13 16:38:06 +00:00
|
|
|
// SortedExtensions gets the list of extensions ordered by Priority
|
|
|
|
func (c *Configuration) SortedExtensions() ([]Extension, error) {
|
|
|
|
return SortExtensions(c.Extensions())
|
|
|
|
}
|
|
|
|
|
2016-05-10 10:38:17 +00:00
|
|
|
func (c *Configuration) SkipDownloadErrors() bool {
|
2016-08-16 17:20:15 +00:00
|
|
|
return c.Os.Bool("GIT_LFS_SKIP_DOWNLOAD_ERRORS", false) || c.Git.Bool("lfs.skipdownloaderrors", false)
|
2016-05-10 10:38:17 +00:00
|
|
|
}
|
|
|
|
|
2017-01-06 09:53:14 +00:00
|
|
|
func (c *Configuration) SetLockableFilesReadOnly() bool {
|
|
|
|
return c.Os.Bool("GIT_LFS_SET_LOCKABLE_READONLY", true) && c.Git.Bool("lfs.setlockablereadonly", true)
|
|
|
|
}
|
|
|
|
|
2017-10-18 21:51:48 +00:00
|
|
|
func (c *Configuration) HookDir() string {
|
2017-10-26 02:23:43 +00:00
|
|
|
if git.IsGitVersionAtLeast("2.9.0") {
|
2017-10-18 21:51:48 +00:00
|
|
|
hp, ok := c.Git.Get("core.hooksPath")
|
|
|
|
if ok {
|
|
|
|
return hp
|
|
|
|
}
|
|
|
|
}
|
2017-10-19 00:35:03 +00:00
|
|
|
return filepath.Join(c.LocalGitDir(), "hooks")
|
2017-10-19 00:25:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) InRepo() bool {
|
2017-10-24 21:58:42 +00:00
|
|
|
return len(c.LocalGitDir()) > 0
|
2017-10-18 21:51:48 +00:00
|
|
|
}
|
|
|
|
|
2017-10-19 00:09:33 +00:00
|
|
|
func (c *Configuration) LocalWorkingDir() string {
|
2017-10-24 21:58:42 +00:00
|
|
|
c.loadGitDirs()
|
|
|
|
return c.workDir
|
2017-10-19 00:09:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) LocalGitDir() string {
|
2017-10-24 21:58:42 +00:00
|
|
|
c.loadGitDirs()
|
|
|
|
return *c.gitDir
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) loadGitDirs() {
|
|
|
|
c.loadingGit.Lock()
|
|
|
|
defer c.loadingGit.Unlock()
|
|
|
|
|
|
|
|
if c.gitDir != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
gitdir, workdir, err := git.GitAndRootDirs()
|
|
|
|
if err != nil {
|
|
|
|
errMsg := err.Error()
|
|
|
|
tracerx.Printf("Error running 'git rev-parse': %s", errMsg)
|
config/config.go: case-insensitive error search
In the internal function loadGitDirs, Git LFS will attempt to resolve
the working and dotgit directory by calling 'git rev-parse --git-dir
--show-top-level'.
This information is used in the output of 'git lfs env', which displays
information about the system- and repository-level configuration as it
pertains to Git LFS.
However, when 'git lfs env' is called outside of the repository, any
information that is repository-specific is left blank. For example,
$ git lfs env
git-lfs/2.4.0 (GitHub; darwin amd64; go 1.10.3)
git version: 2.18.0
LocalWorkingDir=
We ``silence'' the error coming from 'git-rev-parse(1)' in loadGitDirs
by looking for the string "Not a git repository". If we found that
string, we don't show the error message on STDERR (because it is OK not
to), but if we fail to find that string, we assume that the error is
legitimate and thusly forward it on to STDERR.
This string changed casing in [1], so we make a corresponding change
here in order to catch the casing on all versions of Git (by making the
comparison case-insensitive).
[1]: git/git@fc045fe7d4 (Mark messages for translations, 2018-02-13)
2018-07-02 17:04:27 +00:00
|
|
|
if !strings.Contains(strings.ToLower(errMsg),
|
|
|
|
"not a git repository") {
|
2017-10-24 21:58:42 +00:00
|
|
|
fmt.Fprintf(os.Stderr, "Error: %s\n", errMsg)
|
|
|
|
}
|
|
|
|
c.gitDir = &gitdir
|
|
|
|
}
|
|
|
|
|
|
|
|
gitdir = tools.ResolveSymlinks(gitdir)
|
|
|
|
c.gitDir = &gitdir
|
|
|
|
c.workDir = tools.ResolveSymlinks(workdir)
|
2017-10-19 00:09:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) LocalGitStorageDir() string {
|
2017-10-24 21:22:13 +00:00
|
|
|
return c.Filesystem().GitStorageDir
|
2017-10-19 00:09:33 +00:00
|
|
|
}
|
|
|
|
|
2018-07-09 15:28:23 +00:00
|
|
|
func (c *Configuration) LocalReferenceDirs() []string {
|
|
|
|
return c.Filesystem().ReferenceDirs
|
2017-10-19 00:09:33 +00:00
|
|
|
}
|
|
|
|
|
2017-10-24 21:58:42 +00:00
|
|
|
func (c *Configuration) LFSStorageDir() string {
|
|
|
|
return c.Filesystem().LFSStorageDir
|
|
|
|
}
|
|
|
|
|
2017-10-25 01:16:14 +00:00
|
|
|
func (c *Configuration) LFSObjectDir() string {
|
|
|
|
return c.Filesystem().LFSObjectDir()
|
|
|
|
}
|
|
|
|
|
2017-10-25 01:20:09 +00:00
|
|
|
func (c *Configuration) LFSObjectExists(oid string, size int64) bool {
|
|
|
|
return c.Filesystem().ObjectExists(oid, size)
|
|
|
|
}
|
|
|
|
|
2017-10-25 15:49:46 +00:00
|
|
|
func (c *Configuration) EachLFSObject(fn func(fs.Object) error) error {
|
|
|
|
return c.Filesystem().EachObject(fn)
|
|
|
|
}
|
|
|
|
|
2017-10-19 00:09:33 +00:00
|
|
|
func (c *Configuration) LocalLogDir() string {
|
2017-10-24 22:21:15 +00:00
|
|
|
return c.Filesystem().LogDir()
|
2017-10-19 00:09:33 +00:00
|
|
|
}
|
|
|
|
|
2017-10-25 00:59:36 +00:00
|
|
|
func (c *Configuration) TempDir() string {
|
|
|
|
return c.Filesystem().TempDir()
|
|
|
|
}
|
|
|
|
|
2017-10-25 15:49:46 +00:00
|
|
|
func (c *Configuration) Filesystem() *fs.Filesystem {
|
|
|
|
c.loadGitDirs()
|
|
|
|
c.loading.Lock()
|
|
|
|
defer c.loading.Unlock()
|
|
|
|
|
|
|
|
if c.fs == nil {
|
|
|
|
lfsdir, _ := c.Git.Get("lfs.storage")
|
2018-07-09 16:23:27 +00:00
|
|
|
c.fs = fs.New(
|
|
|
|
c.Os,
|
|
|
|
c.LocalGitDir(),
|
|
|
|
c.LocalWorkingDir(),
|
|
|
|
lfsdir,
|
|
|
|
)
|
2017-10-25 15:49:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return c.fs
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) Cleanup() error {
|
|
|
|
c.loading.Lock()
|
|
|
|
defer c.loading.Unlock()
|
|
|
|
return c.fs.Cleanup()
|
|
|
|
}
|
|
|
|
|
2017-10-25 21:33:20 +00:00
|
|
|
func (c *Configuration) OSEnv() Environment {
|
|
|
|
return c.Os
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) GitEnv() Environment {
|
|
|
|
return c.Git
|
|
|
|
}
|
|
|
|
|
2017-10-18 18:52:24 +00:00
|
|
|
func (c *Configuration) GitConfig() *git.Configuration {
|
|
|
|
return c.gitConfig
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) FindGitGlobalKey(key string) string {
|
|
|
|
return c.gitConfig.FindGlobal(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) FindGitSystemKey(key string) string {
|
|
|
|
return c.gitConfig.FindSystem(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) FindGitLocalKey(key string) string {
|
|
|
|
return c.gitConfig.FindLocal(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) SetGitGlobalKey(key, val string) (string, error) {
|
|
|
|
return c.gitConfig.SetGlobal(key, val)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) SetGitSystemKey(key, val string) (string, error) {
|
|
|
|
return c.gitConfig.SetSystem(key, val)
|
|
|
|
}
|
|
|
|
|
2017-10-26 01:20:35 +00:00
|
|
|
func (c *Configuration) SetGitLocalKey(key, val string) (string, error) {
|
|
|
|
return c.gitConfig.SetLocal(key, val)
|
2017-10-18 18:52:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) UnsetGitGlobalSection(key string) (string, error) {
|
|
|
|
return c.gitConfig.UnsetGlobalSection(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) UnsetGitSystemSection(key string) (string, error) {
|
|
|
|
return c.gitConfig.UnsetSystemSection(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Configuration) UnsetGitLocalSection(key string) (string, error) {
|
|
|
|
return c.gitConfig.UnsetLocalSection(key)
|
|
|
|
}
|
|
|
|
|
2017-10-26 01:20:35 +00:00
|
|
|
func (c *Configuration) UnsetGitLocalKey(key string) (string, error) {
|
|
|
|
return c.gitConfig.UnsetLocalKey(key)
|
2017-10-18 18:52:24 +00:00
|
|
|
}
|
|
|
|
|
2016-08-15 20:48:43 +00:00
|
|
|
// loadGitConfig is a temporary measure to support legacy behavior dependent on
|
|
|
|
// accessing properties set by ReadGitConfig, namely:
|
|
|
|
// - `c.extensions`
|
|
|
|
// - `c.uniqRemotes`
|
|
|
|
// - `c.gitConfig`
|
|
|
|
//
|
|
|
|
// Since the *gitEnvironment is responsible for setting these values on the
|
|
|
|
// (*config.Configuration) instance, we must call that method, if it exists.
|
|
|
|
//
|
|
|
|
// loadGitConfig returns a bool returning whether or not `loadGitConfig` was
|
|
|
|
// called AND the method did not return early.
|
2017-10-18 20:45:53 +00:00
|
|
|
func (c *Configuration) loadGitConfig() {
|
|
|
|
if g, ok := c.Git.(*delayedEnvironment); ok {
|
|
|
|
g.Load()
|
2015-10-20 16:31:56 +00:00
|
|
|
}
|
|
|
|
}
|
2016-12-05 11:45:24 +00:00
|
|
|
|
|
|
|
// CurrentCommitter returns the name/email that would be used to author a commit
|
|
|
|
// with this configuration. In particular, the "user.name" and "user.email"
|
|
|
|
// configuration values are used
|
|
|
|
func (c *Configuration) CurrentCommitter() (name, email string) {
|
|
|
|
name, _ = c.Git.Get("user.name")
|
|
|
|
email, _ = c.Git.Get("user.email")
|
|
|
|
return
|
|
|
|
}
|