Refactor packages structure

- Isolate files into their own packages
- Create new printer package and interface
- Refactor Repo stuct to embed the go-git *Repository directly
- Simplify cmd package

pkg/config.go

@@ -1,112 +0,0 @@
-package pkg
-
-import (
-	"path"
-	"strings"
-
-	"github.com/go-git/go-git/v5/config"
-	plumbing "github.com/go-git/go-git/v5/plumbing/format/config"
-	"github.com/mitchellh/go-homedir"
-	"github.com/spf13/viper"
-)
-
-const (
-	GitgetPrefix   = "gitget"
-	KeyReposRoot   = "reposRoot"
-	DefReposRoot   = "repositories"
-	KeyDefaultHost = "defaultHost"
-	DefDefaultHost = "github.com"
-	KeyPrivateKey  = "privateKey"
-	DefPrivateKey  = "id_rsa"
-)
-
-// gitconfig provides methods for looking up configiration values inside .gitconfig file
-type gitconfig struct {
-	*config.Config
-}
-
-// InitConfig initializes viper config registry. Values are looked up in the following order: cli flag, env variable, gitconfig file, default value
-// Viper doesn't support gitconfig file format so it can't find missing values there automatically. They need to be specified in setMissingValues func.
-//
-// Because it reads the cli flags it needs to be called after the cmd.Execute().
-func InitConfig() {
-	viper.SetEnvPrefix(strings.ToUpper(GitgetPrefix))
-	viper.AutomaticEnv()
-
-	cfg := loadGitconfig()
-	setMissingValues(cfg)
-}
-
-// loadGitconfig loads configuration from a gitconfig file.
-// We ignore errors when gitconfig file can't be found, opened or parsed. In those cases viper will provide default config values.
-func loadGitconfig() *gitconfig {
-	// TODO: load system scope
-	cfg, _ := config.LoadConfig(config.GlobalScope)
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-// setMissingValues checks if config values are provided by flags or env vars. If not, it tries loading them from gitconfig file.
-// If that fails, the default values are used.
-func setMissingValues(cfg *gitconfig) {
-	if isUnsetOrEmpty(KeyReposRoot) {
-		viper.Set(KeyReposRoot, cfg.get(KeyReposRoot, path.Join(home(), DefReposRoot)))
-	}
-
-	if isUnsetOrEmpty(KeyDefaultHost) {
-		viper.Set(KeyDefaultHost, cfg.get(KeyDefaultHost, DefDefaultHost))
-	}
-
-	if isUnsetOrEmpty(KeyPrivateKey) {
-		viper.Set(KeyPrivateKey, cfg.get(KeyPrivateKey, path.Join(home(), ".ssh", DefPrivateKey)))
-	}
-}
-
-// get looks up the value for a given key in gitconfig file.
-// It returns the default value when gitconfig is missing, or it doesn't contain a gitget section,
-// or if the section is empty, or if it doesn't contain a valid value for the key.
-func (c *gitconfig) get(key string, def string) string {
-	if c == nil || c.Config == nil {
-		return def
-	}
-
-	gitget := c.findGitconfigSection(GitgetPrefix)
-	if gitget == nil {
-		return def
-	}
-
-	opt := gitget.Option(key)
-	if strings.TrimSpace(opt) == "" {
-		return def
-	}
-
-	return opt
-}
-
-func (c *gitconfig) findGitconfigSection(name string) *plumbing.Section {
-	for _, s := range c.Raw.Sections {
-		if strings.ToLower(s.Name) == strings.ToLower(name) {
-			return s
-		}
-	}
-
-	return nil
-}
-
-// home returns path to a home directory or empty string if can't be found.
-// Using empty string means that in the unlikely situation where home dir can't be found
-// and there's no reposRoot specified by any of the config methods, the current dir will be used as repos root.
-func home() string {
-	home, err := homedir.Dir()
-	if err != nil {
-		return ""
-	}
-
-	return home
-}
-
-func isUnsetOrEmpty(key string) bool {
-	return !viper.IsSet(key) || strings.TrimSpace(viper.GetString(key)) == ""
-}

pkg/config_test.go

@@ -1,158 +0,0 @@
-package pkg
-
-import (
-	"os"
-	"path"
-	"strings"
-	"testing"
-
-	"github.com/go-git/go-git/v5/config"
-	"github.com/spf13/viper"
-)
-
-const (
-	EnvDefaultHost = "GITGET_DEFAULTHOST"
-	EnvReposRoot   = "GITGET_REPOSROOT"
-)
-
-func newConfigWithFullGitconfig() *gitconfig {
-	cfg := config.NewConfig()
-
-	gitget := cfg.Raw.Section(GitgetPrefix)
-	gitget.AddOption(KeyReposRoot, "file.root")
-	gitget.AddOption(KeyDefaultHost, "file.host")
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func newConfigWithEmptyGitgetSection() *gitconfig {
-	cfg := config.NewConfig()
-
-	_ = cfg.Raw.Section(GitgetPrefix)
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func newConfigWithEmptyValues() *gitconfig {
-	cfg := config.NewConfig()
-
-	gitget := cfg.Raw.Section(GitgetPrefix)
-	gitget.AddOption(KeyReposRoot, "")
-	gitget.AddOption(KeyDefaultHost, "   ")
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func newConfigWithoutGitgetSection() *gitconfig {
-	cfg := config.NewConfig()
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func newConfigWithEmptyGitconfig() *gitconfig {
-	return &gitconfig{
-		Config: nil,
-	}
-}
-
-func newConfigWithEnvVars() *gitconfig {
-	_ = os.Setenv(EnvDefaultHost, "env.host")
-	_ = os.Setenv(EnvReposRoot, "env.root")
-
-	return &gitconfig{
-		Config: nil,
-	}
-}
-
-func newConfigWithGitconfigAndEnvVars() *gitconfig {
-	cfg := config.NewConfig()
-
-	gitget := cfg.Raw.Section(GitgetPrefix)
-	gitget.AddOption(KeyReposRoot, "file.root")
-	gitget.AddOption(KeyDefaultHost, "file.host")
-
-	_ = os.Setenv(EnvDefaultHost, "env.host")
-	_ = os.Setenv(EnvReposRoot, "env.root")
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func newConfigWithEmptySectionAndEnvVars() *gitconfig {
-	cfg := config.NewConfig()
-
-	_ = cfg.Raw.Section(GitgetPrefix)
-
-	_ = os.Setenv(EnvDefaultHost, "env.host")
-	_ = os.Setenv(EnvReposRoot, "env.root")
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func newConfigWithMixed() *gitconfig {
-	cfg := config.NewConfig()
-
-	gitget := cfg.Raw.Section(GitgetPrefix)
-	gitget.AddOption(KeyReposRoot, "file.root")
-	gitget.AddOption(KeyDefaultHost, "file.host")
-
-	_ = os.Setenv(EnvDefaultHost, "env.host")
-
-	return &gitconfig{
-		Config: cfg,
-	}
-}
-
-func TestConfig(t *testing.T) {
-	defReposRoot := path.Join(home(), DefReposRoot)
-
-	var tests = []struct {
-		makeConfig      func() *gitconfig
-		wantReposRoot   string
-		wantDefaultHost string
-	}{
-		{newConfigWithFullGitconfig, "file.root", "file.host"},
-		{newConfigWithoutGitgetSection, defReposRoot, DefDefaultHost},
-		{newConfigWithEmptyGitconfig, defReposRoot, DefDefaultHost},
-		{newConfigWithEnvVars, "env.root", "env.host"},
-		{newConfigWithGitconfigAndEnvVars, "env.root", "env.host"},
-		{newConfigWithEmptySectionAndEnvVars, "env.root", "env.host"},
-		{newConfigWithEmptyGitgetSection, defReposRoot, DefDefaultHost},
-		{newConfigWithEmptyValues, defReposRoot, DefDefaultHost},
-		{newConfigWithMixed, "file.root", "env.host"},
-	}
-
-	for _, test := range tests {
-		viper.SetEnvPrefix(strings.ToUpper(GitgetPrefix))
-		viper.AutomaticEnv()
-
-		cfg := test.makeConfig()
-		setMissingValues(cfg)
-
-		if viper.GetString(KeyDefaultHost) != test.wantDefaultHost {
-			t.Errorf("Wrong %s value, got: %s; want: %s", KeyDefaultHost, viper.GetString(KeyDefaultHost), test.wantDefaultHost)
-		}
-
-		if viper.GetString(KeyReposRoot) != test.wantReposRoot {
-			t.Errorf("Wrong %s value, got: %s; want: %s", KeyReposRoot, viper.GetString(KeyReposRoot), test.wantReposRoot)
-		}
-
-		// Unset env variables and reset viper registry after each test
-		viper.Reset()
-		err := os.Unsetenv(EnvDefaultHost)
-		checkFatal(t, err)
-		err = os.Unsetenv(EnvReposRoot)
-		checkFatal(t, err)
-	}
-}

pkg/helpers_test.go

@@ -1,246 +0,0 @@
-package pkg
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/go-git/go-git/v5/plumbing"
-
-	"github.com/go-git/go-git/v5/plumbing/object"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/pkg/errors"
-)
-
-const (
-	testUser  = "Test User"
-	testEmail = "testuser@example.com"
-)
-
-func newRepoEmpty(t *testing.T) *Repo {
-	dir := newTempDir(t)
-
-	repo, err := git.PlainInit(dir, false)
-	checkFatal(t, err)
-
-	return newRepo(repo, dir)
-}
-
-func newRepoWithUntracked(t *testing.T) *Repo {
-	r := newRepoEmpty(t)
-	r.writeFile(t, "README", "I'm a README file")
-
-	return r
-}
-
-func newRepoWithStaged(t *testing.T) *Repo {
-	r := newRepoEmpty(t)
-	r.writeFile(t, "README", "I'm a README file")
-	r.addFile(t, "README")
-
-	return r
-}
-
-func newRepoWithCommit(t *testing.T) *Repo {
-	r := newRepoEmpty(t)
-	r.writeFile(t, "README", "I'm a README file")
-	r.addFile(t, "README")
-	r.newCommit(t, "Initial commit")
-
-	return r
-}
-
-func newRepoWithModified(t *testing.T) *Repo {
-	r := newRepoEmpty(t)
-	r.writeFile(t, "README", "I'm a README file")
-	r.addFile(t, "README")
-	r.newCommit(t, "Initial commit")
-	r.writeFile(t, "README", "I'm modified")
-
-	return r
-}
-
-func newRepoWithIgnored(t *testing.T) *Repo {
-	r := newRepoEmpty(t)
-	r.writeFile(t, ".gitignore", "ignoreme")
-	r.addFile(t, ".gitignore")
-	r.newCommit(t, "Initial commit")
-	r.writeFile(t, "ignoreme", "I'm being ignored")
-
-	return r
-}
-
-func newRepoWithLocalBranch(t *testing.T) *Repo {
-	r := newRepoWithCommit(t)
-	r.newBranch(t, "local")
-	return r
-}
-
-func newRepoWithClonedBranch(t *testing.T) *Repo {
-	origin := newRepoWithCommit(t)
-
-	r := origin.clone(t)
-	r.newBranch(t, "local")
-	r.checkoutBranch(t, "local")
-
-	return r
-}
-
-func newRepoWithDetachedHead(t *testing.T) *Repo {
-	r := newRepoWithCommit(t)
-
-	r.writeFile(t, "new", "I'm a new file")
-	r.addFile(t, "new")
-	hash := r.newCommit(t, "new commit")
-
-	r.checkoutHash(t, hash)
-
-	return r
-}
-
-func newRepoWithBranchAhead(t *testing.T) *Repo {
-	origin := newRepoWithCommit(t)
-
-	r := origin.clone(t)
-	r.writeFile(t, "new", "I'm a new file")
-	r.addFile(t, "new")
-	r.newCommit(t, "new commit")
-
-	return r
-}
-
-func newRepoWithBranchBehind(t *testing.T) *Repo {
-	origin := newRepoWithCommit(t)
-
-	r := origin.clone(t)
-
-	origin.writeFile(t, "origin.new", "I'm a new file on origin")
-	origin.addFile(t, "origin.new")
-	origin.newCommit(t, "new origin commit")
-
-	r.fetch(t)
-	return r
-}
-
-func newRepoWithBranchAheadAndBehind(t *testing.T) *Repo {
-	origin := newRepoWithCommit(t)
-
-	r := origin.clone(t)
-	r.writeFile(t, "local.new", "I'm a new file on local")
-	r.addFile(t, "local.new")
-	r.newCommit(t, "new local commit")
-
-	origin.writeFile(t, "origin.new", "I'm a new file on origin")
-	origin.addFile(t, "origin.new")
-	origin.newCommit(t, "new origin commit")
-
-	r.fetch(t)
-	return r
-}
-
-func newTempDir(t *testing.T) string {
-	dir, err := ioutil.TempDir("", "git-get-repo-")
-	checkFatal(t, errors.Wrap(err, "Failed creating test repo directory"))
-
-	// Automatically remove repo when test is over
-	t.Cleanup(func() {
-		err := os.RemoveAll(dir)
-		if err != nil {
-			t.Errorf("failed cleaning up repo")
-		}
-	})
-
-	return dir
-}
-
-func (r *Repo) writeFile(t *testing.T, name string, content string) {
-	wt, err := r.repo.Worktree()
-	checkFatal(t, errors.Wrap(err, "Failed getting worktree"))
-
-	file, err := wt.Filesystem.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-	checkFatal(t, errors.Wrap(err, "Failed opening a file"))
-
-	_, err = file.Write([]byte(content))
-	checkFatal(t, errors.Wrap(err, "Failed writing a file"))
-}
-
-func (r *Repo) addFile(t *testing.T, name string) {
-	wt, err := r.repo.Worktree()
-	checkFatal(t, errors.Wrap(err, "Failed getting worktree"))
-
-	_, err = wt.Add(name)
-	checkFatal(t, errors.Wrap(err, "Failed adding file to index"))
-}
-
-func (r *Repo) newCommit(t *testing.T, msg string) plumbing.Hash {
-	wt, err := r.repo.Worktree()
-	checkFatal(t, errors.Wrap(err, "Failed getting worktree"))
-
-	opts := &git.CommitOptions{
-		Author: &object.Signature{
-			Name:  testUser,
-			Email: testEmail,
-			When:  time.Date(2000, 01, 01, 16, 00, 00, 0, time.UTC),
-		},
-	}
-
-	hash, err := wt.Commit(msg, opts)
-	checkFatal(t, errors.Wrap(err, "Failed creating commit"))
-	return hash
-}
-
-func (r *Repo) newBranch(t *testing.T, name string) {
-	head, err := r.repo.Head()
-	checkFatal(t, err)
-
-	ref := plumbing.NewHashReference(plumbing.NewBranchReferenceName(name), head.Hash())
-
-	err = r.repo.Storer.SetReference(ref)
-	checkFatal(t, err)
-}
-
-func (r *Repo) clone(t *testing.T) *Repo {
-	dir := newTempDir(t)
-	url, err := ParseURL("file://" + r.path)
-	checkFatal(t, err)
-
-	repo, err := CloneRepo(url, dir, true)
-	checkFatal(t, err)
-
-	return repo
-}
-
-func (r *Repo) fetch(t *testing.T) {
-	err := r.Fetch()
-	checkFatal(t, err)
-}
-
-func (r *Repo) checkoutBranch(t *testing.T, name string) {
-	wt, err := r.repo.Worktree()
-	checkFatal(t, errors.Wrap(err, "Failed getting worktree"))
-
-	opts := &git.CheckoutOptions{
-		Branch: plumbing.NewBranchReferenceName(name),
-	}
-	err = wt.Checkout(opts)
-	checkFatal(t, errors.Wrap(err, "Failed checking out branch"))
-}
-
-func (r *Repo) checkoutHash(t *testing.T, hash plumbing.Hash) {
-	wt, err := r.repo.Worktree()
-	checkFatal(t, errors.Wrap(err, "Failed getting worktree"))
-
-	opts := &git.CheckoutOptions{
-		Hash: hash,
-	}
-	err = wt.Checkout(opts)
-	checkFatal(t, errors.Wrap(err, "Failed checking out hash"))
-}
-
-func checkFatal(t *testing.T, err error) {
-	if err != nil {
-		t.Fatalf("%+v", err)
-	}
-}

pkg/list.go

@@ -1,198 +0,0 @@
-package pkg
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/spf13/viper"
-
-	"github.com/karrick/godirwalk"
-)
-
-// skipNode is used as an error indicating that .git directory has been found.
-// It's handled by ErrorsCallback to tell the WalkCallback to skip this dir.
-var skipNode = errors.New(".git directory found, skipping this node")
-
-var repos []string
-
-func FindRepos() ([]string, error) {
-	repos = []string{}
-
-	root := viper.GetString(KeyReposRoot)
-
-	if _, err := os.Stat(root); err != nil {
-		return nil, fmt.Errorf("Repos root %s does not exist or can't be accessed", root)
-	}
-
-	walkOpts := &godirwalk.Options{
-		ErrorCallback: ErrorCb,
-		Callback:      WalkCb,
-		// Use Unsorted to improve speed because repos will be processed by goroutines in a random order anyway.
-		Unsorted: true,
-	}
-
-	err := godirwalk.Walk(root, walkOpts)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(repos) == 0 {
-		return nil, fmt.Errorf("No git repos found in repos root %s", root)
-	}
-
-	return repos, nil
-}
-
-func WalkCb(path string, ent *godirwalk.Dirent) error {
-	if ent.IsDir() && ent.Name() == git.GitDirName {
-		repos = append(repos, strings.TrimSuffix(path, git.GitDirName))
-		return skipNode
-	}
-	return nil
-}
-
-func ErrorCb(_ string, err error) godirwalk.ErrorAction {
-	if errors.Is(err, skipNode) {
-		return godirwalk.SkipNode
-	}
-	return godirwalk.Halt
-}
-
-func OpenAll(paths []string) ([]*Repo, error) {
-	var repos []*Repo
-	reposChan := make(chan *Repo)
-
-	for _, path := range paths {
-		go func(path string) {
-			repo, err := OpenRepo(path)
-
-			if err != nil {
-				// TODO handle error
-				fmt.Println(err)
-			}
-
-			err = repo.LoadStatus()
-			if err != nil {
-				// TODO handle error
-				fmt.Println(err)
-			}
-			// when error happened we just sent a nil
-			reposChan <- repo
-		}(path)
-	}
-
-	for repo := range reposChan {
-		repos = append(repos, repo)
-
-		// TODO: is this the right way to close the channel? What if we have non-unique paths?
-		if len(repos) == len(paths) {
-			close(reposChan)
-		}
-	}
-
-	// sort the final array to make printing easier
-	sort.Slice(repos, func(i, j int) bool {
-		return strings.Compare(repos[i].path, repos[j].path) < 0
-	})
-
-	return repos, nil
-}
-
-func PrintRepos(repos []*Repo) {
-	root := viper.GetString(KeyReposRoot)
-
-	tree := BuildTree(root, repos)
-	fmt.Println(RenderSmartTree(tree))
-}
-
-const (
-	ColorRed    = "\033[1;31m%s\033[0m"
-	ColorGreen  = "\033[1;32m%s\033[0m"
-	ColorBlue   = "\033[1;34m%s\033[0m"
-	ColorYellow = "\033[1;33m%s\033[0m"
-)
-
-func renderWorktreeStatus(repo *Repo) string {
-	clean := true
-	var status []string
-
-	// if current branch status can't be found it's probably a detached head
-	// TODO: what if current HEAD points to a tag?
-	if current := repo.findCurrentBranchStatus(); current == nil {
-		status = append(status, fmt.Sprintf(ColorYellow, repo.Status.CurrentBranch))
-	} else {
-		status = append(status, renderBranchStatus(current))
-	}
-
-	// TODO: this is ugly
-	// unset clean flag to use it to render braces around worktree status and remove "ok" from branch status if it's there
-	if repo.Status.HasUncommittedChanges || repo.Status.HasUntrackedFiles {
-		clean = false
-	}
-
-	if !clean {
-		status[len(status)-1] = strings.TrimSuffix(status[len(status)-1], StatusOk)
-		status = append(status, "[")
-	}
-
-	if repo.Status.HasUntrackedFiles {
-		status = append(status, fmt.Sprintf(ColorRed, StatusUntracked))
-	}
-
-	if repo.Status.HasUncommittedChanges {
-		status = append(status, fmt.Sprintf(ColorRed, StatusUncommitted))
-	}
-
-	if !clean {
-		status = append(status, "]")
-	}
-
-	return strings.Join(status, " ")
-}
-
-func renderBranchStatus(branch *BranchStatus) string {
-	// ok indicates that the branch has upstream and is not ahead or behind it
-	ok := true
-	var status []string
-
-	status = append(status, fmt.Sprintf(ColorBlue, branch.Name))
-
-	if branch.Upstream == "" {
-		ok = false
-		status = append(status, fmt.Sprintf(ColorYellow, StatusNoUpstream))
-	}
-
-	if branch.NeedsPull {
-		ok = false
-		status = append(status, fmt.Sprintf(ColorYellow, StatusBehind))
-	}
-
-	if branch.NeedsPush {
-		ok = false
-		status = append(status, fmt.Sprintf(ColorYellow, StatusAhead))
-	}
-
-	if ok {
-		status = append(status, fmt.Sprintf(ColorGreen, StatusOk))
-	}
-
-	return strings.Join(status, " ")
-}
-
-func (r *Repo) findCurrentBranchStatus() *BranchStatus {
-	if r.Status.CurrentBranch == StatusDetached || r.Status.CurrentBranch == StatusUnknown {
-		return nil
-	}
-
-	for _, b := range r.Status.Branches {
-		if b.Name == r.Status.CurrentBranch {
-			return b
-		}
-	}
-
-	return nil
-}

pkg/repo.go

@@ -1,114 +0,0 @@
-package pkg
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/url"
-	"os"
-	"path"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/viper"
-	"golang.org/x/crypto/ssh"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing/transport"
-	go_git_ssh "github.com/go-git/go-git/v5/plumbing/transport/ssh"
-)
-
-type Repo struct {
-	repo   *git.Repository
-	path   string
-	Status *RepoStatus
-}
-
-func CloneRepo(url *url.URL, reposRoot string, quiet bool) (*Repo, error) {
-	repoPath := path.Join(reposRoot, URLToPath(url))
-
-	var progress io.Writer
-	if !quiet {
-		progress = os.Stdout
-		fmt.Printf("Cloning into '%s'...\n", repoPath)
-	}
-
-	// TODO: can this be cleaner?
-	var auth transport.AuthMethod
-	var err error
-	if url.Scheme == "ssh" {
-		if auth, err = sshKeyAuth(); err != nil {
-			return nil, err
-		}
-	}
-
-	opts := &git.CloneOptions{
-		URL:               url.String(),
-		Auth:              auth,
-		RemoteName:        git.DefaultRemoteName,
-		ReferenceName:     "",
-		SingleBranch:      false,
-		NoCheckout:        false,
-		Depth:             0,
-		RecurseSubmodules: git.NoRecurseSubmodules,
-		Progress:          progress,
-		Tags:              git.AllTags,
-	}
-
-	repo, err := git.PlainClone(repoPath, false, opts)
-	if err != nil {
-		return nil, errors.Wrap(err, "Failed cloning repo")
-	}
-
-	return newRepo(repo, repoPath), nil
-}
-
-func OpenRepo(repoPath string) (*Repo, error) {
-	repo, err := git.PlainOpen(repoPath)
-	if err != nil {
-		return nil, errors.Wrap(err, "Failed opening repo")
-	}
-
-	return newRepo(repo, repoPath), nil
-}
-
-func newRepo(repo *git.Repository, repoPath string) *Repo {
-	return &Repo{
-		repo:   repo,
-		path:   repoPath,
-		Status: &RepoStatus{},
-	}
-}
-
-// Fetch performs a git fetch on all remotes
-func (r *Repo) Fetch() error {
-	remotes, err := r.repo.Remotes()
-	if err != nil {
-		return errors.Wrap(err, "Failed getting remotes")
-	}
-
-	for _, remote := range remotes {
-		err = remote.Fetch(&git.FetchOptions{})
-		if err != nil {
-			return errors.Wrapf(err, "Failed fetching remote %s", remote.Config().Name)
-		}
-	}
-
-	return nil
-}
-
-func sshKeyAuth() (transport.AuthMethod, error) {
-	privateKey := viper.GetString(KeyPrivateKey)
-	sshKey, err := ioutil.ReadFile(privateKey)
-	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to open ssh private key %s", privateKey)
-	}
-
-	signer, err := ssh.ParsePrivateKey([]byte(sshKey))
-	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to parse ssh private key %s", privateKey)
-	}
-
-	// TODO: can it ba a different user
-	auth := &go_git_ssh.PublicKeys{User: "git", Signer: signer}
-	return auth, nil
-}

pkg/status.go

@@ -1,264 +0,0 @@
-package pkg
-
-import (
-	"sort"
-	"strings"
-
-	"github.com/go-git/go-billy/v5/osfs"
-
-	"github.com/go-git/go-git/v5/plumbing/format/gitignore"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/pkg/errors"
-)
-
-const (
-	StatusUnknown     = "unknown"
-	StatusDetached    = "detached HEAD"
-	StatusNoUpstream  = "no upstream"
-	StatusAhead       = "ahead"
-	StatusBehind      = "behind"
-	StatusOk          = "ok"
-	StatusUncommitted = "uncommitted"
-	StatusUntracked   = "untracked"
-)
-
-type RepoStatus struct {
-	HasUntrackedFiles     bool
-	HasUncommittedChanges bool
-	CurrentBranch         string
-	Branches              []*BranchStatus
-}
-
-type BranchStatus struct {
-	Name      string
-	Upstream  string
-	NeedsPull bool
-	NeedsPush bool
-}
-
-func (r *Repo) LoadStatus() error {
-	wt, err := r.repo.Worktree()
-	if err != nil {
-		return errors.Wrap(err, "Failed getting worktree")
-	}
-
-	// worktree.Status doesn't load gitignore patterns that may be defined outside of .gitignore file using excludesfile
-	// We need to load them explicitly here
-	// TODO: variables are not expanded so if excludesfile is declared like "~/gitignore_global" or "$HOME/gitignore_global", this will fail to open it
-	globalPatterns, err := gitignore.LoadGlobalPatterns(osfs.New(""))
-	if err != nil {
-		return errors.Wrap(err, "Failed loading global gitignore patterns")
-	}
-	wt.Excludes = append(wt.Excludes, globalPatterns...)
-
-	systemPatterns, err := gitignore.LoadSystemPatterns(osfs.New(""))
-	if err != nil {
-		return errors.Wrap(err, "Failed loading system gitignore patterns")
-	}
-	wt.Excludes = append(wt.Excludes, systemPatterns...)
-
-	status, err := wt.Status()
-	if err != nil {
-		return errors.Wrap(err, "Failed getting worktree status")
-	}
-
-	r.Status.HasUncommittedChanges = hasUncommitted(status)
-	r.Status.HasUntrackedFiles = hasUntracked(status)
-	r.Status.CurrentBranch = currentBranch(r)
-
-	err = r.loadBranchesStatus()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// hasUntracked returns true if there are any untracked files in the worktree
-func hasUntracked(status git.Status) bool {
-	for _, fs := range status {
-		if fs.Worktree == git.Untracked || fs.Staging == git.Untracked {
-			return true
-		}
-	}
-
-	return false
-}
-
-// hasUncommitted returns true if there are any uncommitted (but tracked) files in the worktree
-func hasUncommitted(status git.Status) bool {
-	// If repo is clean it means every file in worktree and staging has 'Unmodified' state
-	if status.IsClean() {
-		return false
-	}
-
-	// If repo is not clean, check if any file has state different than 'Untracked' - it means they are tracked and have uncommitted modifications
-	for _, fs := range status {
-		if fs.Worktree != git.Untracked || fs.Staging != git.Untracked {
-			return true
-		}
-	}
-
-	return false
-}
-
-func currentBranch(r *Repo) string {
-	head, err := r.repo.Head()
-	if err != nil {
-		return StatusUnknown
-	}
-
-	if head.Name().Short() == plumbing.HEAD.String() {
-		return StatusDetached
-	}
-
-	return head.Name().Short()
-}
-
-func (r *Repo) loadBranchesStatus() error {
-	iter, err := r.repo.Branches()
-	if err != nil {
-		return errors.Wrap(err, "Failed getting branches iterator")
-	}
-
-	err = iter.ForEach(func(reference *plumbing.Reference) error {
-		bs, err := r.newBranchStatus(reference.Name().Short())
-		if err != nil {
-			return err
-		}
-
-		r.Status.Branches = append(r.Status.Branches, bs)
-		return nil
-	})
-	if err != nil {
-		return errors.Wrap(err, "Failed iterating over branches")
-	}
-
-	// Sort branches by name (but with "master" always at the top). It's useful to have them sorted for printing and testing.
-	sort.Slice(r.Status.Branches, func(i, j int) bool {
-		if r.Status.Branches[i].Name == "master" {
-			return true
-		}
-
-		return strings.Compare(r.Status.Branches[i].Name, r.Status.Branches[j].Name) < 0
-	})
-	return nil
-}
-
-func (r *Repo) newBranchStatus(branch string) (*BranchStatus, error) {
-	bs := &BranchStatus{
-		Name: branch,
-	}
-
-	upstream, err := r.upstream(branch)
-	if err != nil {
-		return nil, err
-	}
-
-	if upstream == "" {
-		return bs, nil
-	}
-
-	needsPull, needsPush, err := r.needsPullOrPush(branch, upstream)
-	if err != nil {
-		return nil, err
-	}
-
-	bs.Upstream = upstream
-	bs.NeedsPush = needsPush
-	bs.NeedsPull = needsPull
-
-	return bs, nil
-}
-
-// upstream finds if a given branch tracks an upstream.
-// Returns found upstream branch name (eg, origin/master) or empty string if branch doesn't track an upstream.
-//
-// Information about upstream is taken from .git/config file.
-// If a branch has an upstream, there's a [branch] section in the file with two fields:
-// "remote" - name of the remote containing upstream branch (or "." if upstream is a local branch)
-// "merge" - full ref name of the upstream branch (eg, ref/heads/master)
-func (r *Repo) upstream(branch string) (string, error) {
-	cfg, err := r.repo.Config()
-	if err != nil {
-		return "", errors.Wrap(err, "Failed getting repo config")
-	}
-
-	// Check if our branch exists in "branch" config sections. If not, it doesn't have an upstream configured.
-	bcfg := cfg.Branches[branch]
-	if bcfg == nil {
-		return "", nil
-	}
-
-	remote := bcfg.Remote
-	if remote == "" {
-		return "", nil
-	}
-
-	merge := bcfg.Merge.Short()
-	if merge == "" {
-		return "", nil
-	}
-	return remote + "/" + merge, nil
-}
-
-func (r *Repo) needsPullOrPush(localBranch string, upstreamBranch string) (needsPull bool, needsPush bool, err error) {
-	localHash, err := r.repo.ResolveRevision(plumbing.Revision(localBranch))
-	if err != nil {
-		return false, false, errors.Wrapf(err, "Failed resolving revision %s", localBranch)
-	}
-
-	upstreamHash, err := r.repo.ResolveRevision(plumbing.Revision(upstreamBranch))
-	if err != nil {
-		return false, false, errors.Wrapf(err, "Failed resolving revision %s", upstreamBranch)
-	}
-
-	localCommit, err := r.repo.CommitObject(*localHash)
-	if err != nil {
-		return false, false, errors.Wrapf(err, "Failed finding a commit for hash %s", localHash.String())
-	}
-
-	upstreamCommit, err := r.repo.CommitObject(*upstreamHash)
-	if err != nil {
-		return false, false, errors.Wrapf(err, "Failed finding a commit for hash %s", upstreamHash.String())
-	}
-
-	// If local branch hash is the same as upstream, it means there is no difference between local and upstream
-	if *localHash == *upstreamHash {
-		return false, false, nil
-	}
-
-	commons, err := localCommit.MergeBase(upstreamCommit)
-	if err != nil {
-		return false, false, errors.Wrapf(err, "Failed finding common ancestors for branches %s & %s", localBranch, upstreamBranch)
-	}
-
-	if len(commons) == 0 {
-		// TODO: No common ancestors. This should be an error
-		return false, false, nil
-	}
-
-	if len(commons) > 1 {
-		// TODO: multiple best ancestors. How to handle this?
-		return false, false, nil
-	}
-
-	mergeBase := commons[0]
-
-	// If merge base is the same as upstream branch, local branch is ahead and push is needed
-	// If merge base is the same as local branch, local branch is behind and pull is needed
-	// If merge base is something else, branches have diverged and merge is needed (both pull and push)
-	// ref: https://stackoverflow.com/a/17723781/1085632
-
-	if mergeBase.Hash == *upstreamHash {
-		return false, true, nil
-	}
-
-	if mergeBase.Hash == *localHash {
-		return true, false, nil
-	}
-
-	return true, true, nil
-}

pkg/status_test.go

@@ -1,175 +0,0 @@
-package pkg
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestStatus(t *testing.T) {
-	var tests = []struct {
-		makeTestRepo func(*testing.T) *Repo
-		want         *RepoStatus
-	}{
-		{newRepoEmpty, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         StatusUnknown,
-			Branches:              nil,
-		}},
-		{newRepoWithUntracked, &RepoStatus{
-			HasUntrackedFiles:     true,
-			HasUncommittedChanges: false,
-			CurrentBranch:         StatusUnknown,
-			Branches:              nil,
-		}},
-		{newRepoWithStaged, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: true,
-			CurrentBranch:         StatusUnknown,
-			Branches:              nil,
-		}},
-		{newRepoWithCommit, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithModified, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: true,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithIgnored, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithLocalBranch, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				}, {
-					Name:      "local",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithClonedBranch, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "local",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "origin/master",
-					NeedsPull: false,
-					NeedsPush: false,
-				}, {
-					Name:      "local",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithDetachedHead, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         StatusDetached,
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "",
-					NeedsPull: false,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithBranchAhead, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "origin/master",
-					NeedsPull: false,
-					NeedsPush: true,
-				},
-			},
-		}},
-		{newRepoWithBranchBehind, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "origin/master",
-					NeedsPull: true,
-					NeedsPush: false,
-				},
-			},
-		}},
-		{newRepoWithBranchAheadAndBehind, &RepoStatus{
-			HasUntrackedFiles:     false,
-			HasUncommittedChanges: false,
-			CurrentBranch:         "master",
-			Branches: []*BranchStatus{
-				{
-					Name:      "master",
-					Upstream:  "origin/master",
-					NeedsPull: true,
-					NeedsPush: true,
-				},
-			},
-		}},
-	}
-
-	for _, test := range tests {
-		repo := test.makeTestRepo(t)
-
-		err := repo.LoadStatus()
-		checkFatal(t, err)
-
-		if !reflect.DeepEqual(repo.Status, test.want) {
-			t.Errorf("Wrong repo status, got: %+v; want: %+v", repo.Status, test.want)
-		}
-	}
-}
-
-// TODO: test branch status when tracking a local branch
-// TODO: test head pointing to a tag
-// TODO: newRepoWithGlobalGitignore
-// TODO: newRepoWithGlobalGitignoreSymlink

pkg/tree.go

@@ -1,170 +0,0 @@
-package pkg
-
-import (
-	"path/filepath"
-	"strings"
-)
-
-// Node represents a node in a repos tree
-type Node struct {
-	val      string
-	depth    int // depth is a nesting depth used when rendering a tree, not an depth level of a node inside the tree
-	parent   *Node
-	children []*Node
-	repo     *Repo
-}
-
-// Root creates a new root of a tree
-func Root(val string) *Node {
-	root := &Node{
-		val: val,
-	}
-	return root
-}
-
-// Add adds a child node
-func (n *Node) Add(val string) *Node {
-	if n.children == nil {
-		n.children = make([]*Node, 0)
-	}
-
-	child := &Node{
-		val:    val,
-		parent: n,
-	}
-	n.children = append(n.children, child)
-	return child
-}
-
-// GetChild finds a node with val inside this node's children (only 1 level deep).
-// Returns pointer to found child or nil if node doesn't have any children or doesn't have a child with sought value.
-func (n *Node) GetChild(val string) *Node {
-	if n.children == nil {
-		return nil
-	}
-
-	for _, child := range n.children {
-		if child.val == val {
-			return child
-		}
-	}
-
-	return nil
-}
-
-// BuildTree builds a directory tree of paths to repositories.
-// Each node represents a directory in the repo path.
-// Each leaf (final node) contains a pointer to the repo.
-func BuildTree(root string, repos []*Repo) *Node {
-	tree := Root(root)
-
-	for _, repo := range repos {
-		path := strings.TrimPrefix(repo.path, root)
-		path = strings.Trim(path, string(filepath.Separator))
-		subs := strings.Split(path, string(filepath.Separator))
-
-		// For each path fragment, start at the root of the tree
-		// and check if the fragment exist among the children of the node.
-		// If not, add it to node's children and move to next fragment.
-		// If it does, just move to the next fragment.
-		node := tree
-		for i, sub := range subs {
-			child := node.GetChild(sub)
-			if child == nil {
-				node = node.Add(sub)
-
-				// If that's the last fragment, it's a tree leaf and needs a *Repo attached.
-				if i == len(subs)-1 {
-					node.repo = repo
-				}
-
-				continue
-			}
-			node = child
-		}
-	}
-	return tree
-}
-
-// RenderSmartTree returns a string representation of repos tree.
-// It's "smart" because it automatically folds branches which only have a single child and indents branches with many children.
-//
-// It recursively traverses the tree and prints its nodes.
-// If a node contains multiple children, they are be printed in new lines and indented.
-// If a node contains only a single child, it is printed in the same line using path separator.
-// For better readability the first level (repos hosts) is not indented.
-//
-// Example:
-// Following paths:
-//   /repos/github.com/user/repo1
-//   /repos/github.com/user/repo2
-//   /repos/github.com/another/repo
-//
-// will render a tree:
-//   /repos/
-//   github.com/
-//       user/
-//           repo1
-//           repo2
-//       another/repo
-//
-func RenderSmartTree(node *Node) string {
-	if node.children == nil {
-		// If node is a leaf, print repo name and its status and finish processing this node.
-		value := node.val
-
-		// TODO: Ugly
-		// If this is called from tests the repo will be nil and we should return just the name without the status.
-		if node.repo.repo == nil {
-			return value
-		}
-
-		value += " " + renderWorktreeStatus(node.repo)
-
-		// Print the status of each branch on a new line, indented to match the position of the current branch name.
-		indent := "\n" + strings.Repeat(" ", length+len(node.val))
-		for _, branch := range node.repo.Status.Branches {
-			// Don't print the status of the current branch. It was already printed above.
-			if branch.Name == node.repo.Status.CurrentBranch {
-				continue
-			}
-
-			value += indent + renderBranchStatus(branch)
-		}
-
-		return value
-	}
-
-	val := node.val + string(filepath.Separator)
-
-	shift := ""
-	if node.parent == nil {
-		// If node is a root, print its children on a new line without indentation.
-		shift = "\n"
-	} else if len(node.children) == 1 {
-		// If node has only a single child, print it on the same line as its parent.
-		// Setting node's depth to the same as parent's ensures that its children will be indented only once even if
-		// node's path has multiple levels above.
-		node.depth = node.parent.depth
-
-		length += len(val)
-	} else {
-		// If node has multiple children, print each of them on a new line
-		// and indent them once relative to the parent
-		node.depth = node.parent.depth + 1
-		shift = "\n" + strings.Repeat("    ", node.depth)
-		length = 0
-	}
-
-	for _, child := range node.children {
-		length += len(shift)
-		val += shift + RenderSmartTree(child)
-		length = 0
-	}
-
-	return val
-}
-
-// lenght is the size (number of chars) of the currently processed line.
-// It's used to correctly indent the lines with branches status.
-var length int

pkg/tree_test.go

@@ -1,107 +0,0 @@
-package pkg
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-func TestTree(t *testing.T) {
-	var tests = []struct {
-		paths []string
-		want  string
-	}{
-		{
-			[]string{
-				"root/github.com/grdl/repo1",
-			}, `
-root/
-github.com/grdl/repo1
-`,
-		},
-		{
-			[]string{
-				"root/github.com/grdl/repo1",
-				"root/github.com/grdl/repo2",
-			}, `
-root/
-github.com/grdl/
-	repo1
-	repo2
-`,
-		},
-		{
-			[]string{
-				"root/gitlab.com/grdl/repo1",
-				"root/github.com/grdl/repo1",
-			}, `
-root/
-gitlab.com/grdl/repo1
-github.com/grdl/repo1
-`,
-		},
-		{
-			[]string{
-				"root/gitlab.com/grdl/repo1",
-				"root/gitlab.com/grdl/repo2",
-				"root/gitlab.com/other/repo1",
-				"root/github.com/grdl/repo1",
-				"root/github.com/grdl/nested/repo2",
-			}, `
-root/
-gitlab.com/
-	grdl/
-		repo1
-		repo2
-	other/repo1
-github.com/grdl/
-	repo1
-	nested/repo2
-`,
-		},
-		{
-			[]string{
-				"root/gitlab.com/grdl/nested/repo1",
-				"root/gitlab.com/grdl/nested/repo2",
-				"root/gitlab.com/other/repo1",
-			}, `
-root/
-gitlab.com/
-	grdl/nested/
-		repo1
-		repo2
-	other/repo1
-`,
-		},
-		{
-			[]string{
-				"root/gitlab.com/grdl/double/nested/repo1",
-				"root/gitlab.com/grdl/nested/repo2",
-				"root/gitlab.com/other/repo1",
-			}, `
-root/
-gitlab.com/
-	grdl/
-		double/nested/repo1
-		nested/repo2
-	other/repo1
-`,
-		},
-	}
-
-	for i, test := range tests {
-		var repos []*Repo
-		for _, path := range test.paths {
-			repos = append(repos, newRepo(nil, path)) //&Repo{path: path})
-		}
-
-		tree := BuildTree("root", repos)
-		// Leading and trailing newlines are added to test cases for readability. We also need to add them to the rendering result.
-		got := fmt.Sprintf("\n%s\n", RenderSmartTree(tree))
-
-		// Rendered tree uses spaces for indentation but the test cases use tabs.
-		if got != strings.ReplaceAll(test.want, "\t", "    ") {
-			t.Errorf("Failed test case %d, got: %+v; want: %+v", i, got, test.want)
-		}
-	}
-}

pkg/url.go

@@ -1,72 +0,0 @@
-package pkg
-
-import (
-	urlpkg "net/url"
-	"path"
-	"regexp"
-	"strings"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/viper"
-)
-
-// scpSyntax matches the SCP-like addresses used by the ssh protocol (eg, [user@]host.xz:path/to/repo.git/).
-// See: https://golang.org/src/cmd/go/internal/get/vcs.go
-var scpSyntax = regexp.MustCompile(`^([a-zA-Z0-9_]+)@([a-zA-Z0-9._-]+):(.*)$`)
-
-func ParseURL(rawURL string) (url *urlpkg.URL, err error) {
-	// If rawURL matches the SCP-like syntax, convert it into a standard ssh Path.
-	// eg, git@github.com:user/repo => ssh://git@github.com/user/repo
-	if m := scpSyntax.FindStringSubmatch(rawURL); m != nil {
-		url = &urlpkg.URL{
-			Scheme: "ssh",
-			User:   urlpkg.User(m[1]),
-			Host:   m[2],
-			Path:   m[3],
-		}
-	} else {
-		url, err = urlpkg.Parse(rawURL)
-		if err != nil {
-			return nil, errors.Wrap(err, "Failed parsing Path")
-		}
-	}
-
-	if url.Host == "" && url.Path == "" {
-		return nil, errors.New("Parsed Path is empty")
-	}
-
-	if url.Scheme == "git+ssh" {
-		url.Scheme = "ssh"
-	}
-
-	// Default to "git" user when using ssh and no user is provided
-	if url.Scheme == "ssh" && url.User == nil {
-		url.User = urlpkg.User("git")
-	}
-
-	// Default to configured defaultHost when host is empty
-	if url.Host == "" {
-		url.Host = viper.GetString(KeyDefaultHost)
-	}
-
-	// Default to https when scheme is empty
-	if url.Scheme == "" {
-		url.Scheme = "https"
-	}
-
-	return url, nil
-}
-
-func URLToPath(url *urlpkg.URL) (repoPath string) {
-	// Remove port numbers from host
-	repoHost := strings.Split(url.Host, ":")[0]
-
-	// Remove trailing ".git" from repo name
-	repoPath = path.Join(repoHost, url.Path)
-	repoPath = strings.TrimSuffix(repoPath, ".git")
-
-	// Remove tilde (~) char from username
-	repoPath = strings.ReplaceAll(repoPath, "~", "")
-
-	return repoPath
-}

pkg/url_test.go

@@ -1,84 +0,0 @@
-package pkg
-
-import (
-	"testing"
-)
-
-// Following URLs are considered valid according to https://git-scm.com/docs/git-clone#_git_urls:
-// ssh://[user@]host.xz[:port]/path/to/repo.git
-// ssh://[user@]host.xz[:port]/~[user]/path/to/repo.git/
-// [user@]host.xz:path/to/repo.git/
-// [user@]host.xz:/~[user]/path/to/repo.git/
-// git://host.xz[:port]/path/to/repo.git/
-// git://host.xz[:port]/~[user]/path/to/repo.git/
-// http[s]://host.xz[:port]/path/to/repo.git/
-// ftp[s]://host.xz[:port]/path/to/repo.git/
-// /path/to/repo.git/
-// file:///path/to/repo.git/
-
-func TestURLParse(t *testing.T) {
-	tests := []struct {
-		in   string
-		want string
-	}{
-		{"ssh://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"ssh://user@github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"ssh://user@github.com:1234/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"ssh://user@github.com/~user/grdl/git-get.git", "github.com/user/grdl/git-get"},
-		{"git+ssh://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"git@github.com:grdl/git-get.git", "github.com/grdl/git-get"},
-		{"git@github.com:/~user/grdl/git-get.git", "github.com/user/grdl/git-get"},
-		{"git://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"git://github.com/~user/grdl/git-get.git", "github.com/user/grdl/git-get"},
-		{"https://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"http://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"https://github.com/grdl/git-get", "github.com/grdl/git-get"},
-		{"https://github.com/git-get.git", "github.com/git-get"},
-		{"https://github.com/git-get", "github.com/git-get"},
-		{"https://github.com/grdl/sub/path/git-get.git", "github.com/grdl/sub/path/git-get"},
-		{"https://github.com:1234/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"https://github.com/grdl/git-get.git/", "github.com/grdl/git-get"},
-		{"https://github.com/grdl/git-get/", "github.com/grdl/git-get"},
-		{"https://github.com/grdl/git-get/////", "github.com/grdl/git-get"},
-		{"https://github.com/grdl/git-get.git/////", "github.com/grdl/git-get"},
-		{"ftp://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"ftps://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"rsync://github.com/grdl/git-get.git", "github.com/grdl/git-get"},
-		{"local/grdl/git-get/", "github.com/local/grdl/git-get"},
-		{"file://local/grdl/git-get", "local/grdl/git-get"},
-	}
-
-	// We need to init config first so the default values are correctly loaded
-	InitConfig()
-
-	for _, test := range tests {
-		url, err := ParseURL(test.in)
-		if err != nil {
-			t.Errorf("Error parsing Path: %+v", err)
-		}
-
-		got := URLToPath(url)
-
-		if got != test.want {
-			t.Errorf("Wrong result of parsing Path: %s, got: %s; want: %s", test.in, got, test.want)
-		}
-	}
-}
-
-func TestInvalidURLParse(t *testing.T) {
-	invalidURLs := []string{
-		"",
-		//TODO: This Path is technically a correct scp-like syntax. Not sure how to handle it
-		"github.com:grdl/git-git.get.git",
-
-		//TODO: Is this a valid git Path?
-		//"git@github.com:1234:grdl/git-get.git",
-	}
-
-	for _, in := range invalidURLs {
-		got, err := ParseURL(in)
-		if err == nil {
-			t.Errorf("Wrong result of parsing invalid Path: %s, got: %s, want: error", in, got)
-		}
-	}
-}