func doGet(c *cli.Context) {
argURL := c.Args().Get(0)
branch := c.String("branch")
doUpdate := c.Bool("update")
isShallow := c.Bool("shallow")
isRecursive := c.Bool("recursive")
if argURL == "" {
cli.ShowCommandHelp(c, "get")
os.Exit(1)
}
if isShallow && isRecursive {
utils.Log("error", "Cannot specify both --shallow and --recursive options")
os.Exit(1)
}
// If argURL is a "./foo" or "../bar" form,
// find repository name trailing after github.com/USER/.
parts := strings.Split(argURL, string(filepath.Separator))
if parts[0] == "." || parts[0] == ".." {
if wd, err := os.Getwd(); err == nil {
path := filepath.Clean(filepath.Join(wd, filepath.Join(parts...)))
var repoPath string
for _, r := range localRepositoryRoots() {
p := strings.TrimPrefix(path, r+string(filepath.Separator))
if p != path && (repoPath == "" || len(p) < len(repoPath)) {
repoPath = p
}
}
if repoPath != "" {
// Guess it
utils.Log("resolved", fmt.Sprintf("relative %q to %q", argURL, "https://"+repoPath))
argURL = "https://" + repoPath
}
}
}
url, err := NewURL(argURL)
utils.DieIf(err)
isSSH := c.Bool("p")
if isSSH {
// Assume Git repository if `-p` is given.
url, err = ConvertGitURLHTTPToSSH(url)
utils.DieIf(err)
}
remote, err := NewRemoteRepository(url)
utils.DieIf(err)
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
os.Exit(1)
}
getRemoteRepository(remote, branch, doUpdate, isShallow, isRecursive)
}
func getRemoteRepository(remote RemoteRepository, doUpdate bool) {
remoteURL := remote.URL()
local := LocalRepositoryFromURL(remoteURL)
path := local.FullPath
newPath := false
_, err := os.Stat(path)
if err != nil {
if os.IsNotExist(err) {
newPath = true
err = nil
}
utils.PanicIf(err)
}
if newPath {
utils.Log("clone", fmt.Sprintf("%s -> %s", remoteURL, path))
remote.VCS().Clone(remoteURL, path)
} else {
if doUpdate {
utils.Log("update", path)
local.VCS().Update(path)
} else {
utils.Log("exists", path)
}
}
}
// getRemoteRepository clones or updates a remote repository remote.
// If doUpdate is true, updates the locally cloned repository. Otherwise does nothing.
// If isShallow is true, does shallow cloning. (no effect if already cloned or the VCS is Mercurial)
func getRemoteRepository(remote RemoteRepository, doUpdate bool, isShallow bool) {
remoteURL := remote.URL()
local := LocalRepositoryFromURL(remoteURL)
path := local.FullPath
newPath := false
_, err := os.Stat(path)
if err != nil {
if os.IsNotExist(err) {
newPath = true
err = nil
}
utils.PanicIf(err)
}
if newPath {
utils.Log("clone", fmt.Sprintf("%s -> %s", remoteURL, path))
vcs := remote.VCS()
if vcs == nil {
utils.Log("error", fmt.Sprintf("Could not find version control system: %s", remoteURL))
os.Exit(1)
}
vcs.Clone(remoteURL, path, isShallow)
} else {
if doUpdate {
utils.Log("update", path)
local.VCS().Update(path)
} else {
utils.Log("exists", path)
}
}
}
func (repo *OtherRepository) VCS() *VCSBackend {
if GitHasFeatureConfigURLMatch() {
// Respect 'ghq.url.https://ghe.example.com/.vcs' config variable
// (in gitconfig:)
// [ghq "https://ghe.example.com/"]
// vcs = github
vcs, err := GitConfig("--get-urlmatch", "ghq.vcs", repo.URL().String())
if err != nil {
utils.Log("error", err.Error())
}
if vcs == "git" || vcs == "github" {
return GitBackend
}
if vcs == "hg" || vcs == "mercurial" {
return MercurialBackend
}
} else {
utils.Log("warning", "This version of Git does not support `config --get-urlmatch`; per-URL settings are not available")
}
// Detect VCS backend automatically
if utils.RunSilently("hg", "identify", repo.url.String()) == nil {
return MercurialBackend
} else if utils.RunSilently("git", "ls-remote", repo.url.String()) == nil {
return GitBackend
} else {
return nil
}
}
func doImportPocket(c *cli.Context) {
if pocket.ConsumerKey == "" {
utils.Log("error", "Built without consumer key set")
return
}
accessToken, err := GitConfig("ghq.pocket.token")
utils.PanicIf(err)
if accessToken == "" {
receiverURL, ch, err := pocket.StartAccessTokenReceiver()
utils.PanicIf(err)
utils.Log("pocket", "Waiting for Pocket authentication callback at "+receiverURL)
utils.Log("pocket", "Obtaining request token")
authRequest, err := pocket.ObtainRequestToken(receiverURL)
utils.DieIf(err)
url := pocket.GenerateAuthorizationURL(authRequest.Code, receiverURL)
utils.Log("open", url)
<-ch
utils.Log("pocket", "Obtaining access token")
authorized, err := pocket.ObtainAccessToken(authRequest.Code)
utils.DieIf(err)
utils.Log("authorized", authorized.Username)
accessToken = authorized.AccessToken
utils.Run("git", "config", "ghq.pocket.token", authorized.AccessToken)
}
utils.Log("pocket", "Retrieving github.com entries")
res, err := pocket.RetrieveGitHubEntries(accessToken)
utils.DieIf(err)
for _, item := range res.List {
url, err := url.Parse(item.ResolvedURL)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not parse URL <%s>: %s", item.ResolvedURL, err))
continue
}
remote, err := NewRemoteRepository(url)
if utils.ErrorIf(err) {
continue
}
if remote.IsValid() == false {
utils.Log("skip", fmt.Sprintf("Not a valid repository: %s", url))
continue
}
getRemoteRepository(remote, c.Bool("update"))
}
}
func doLook(c *cli.Context) {
name := c.Args().First()
if name == "" {
cli.ShowCommandHelp(c, "look")
os.Exit(1)
}
reposFound := []*LocalRepository{}
walkLocalRepositories(func(repo *LocalRepository) {
if repo.Matches(name) {
reposFound = append(reposFound, repo)
}
})
switch len(reposFound) {
case 0:
utils.Log("error", "No repository found")
os.Exit(1)
case 1:
if runtime.GOOS == "windows" {
cmd := exec.Command(os.Getenv("COMSPEC"))
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = reposFound[0].FullPath
err := cmd.Start()
if err == nil {
cmd.Wait()
os.Exit(0)
}
} else {
shell := os.Getenv("SHELL")
if shell == "" {
shell = "/bin/sh"
}
utils.Log("cd", reposFound[0].FullPath)
err := os.Chdir(reposFound[0].FullPath)
utils.PanicIf(err)
syscall.Exec(shell, []string{shell}, syscall.Environ())
}
default:
utils.Log("error", "More than one repositories are found; Try more precise name")
for _, repo := range reposFound {
utils.Log("error", "- "+strings.Join(repo.PathParts, "/"))
}
}
}
func doGet(c *cli.Context) {
argURL := c.Args().Get(0)
category := c.Args().Get(1)
doUpdate := c.Bool("update")
isShallow := c.Bool("shallow")
if argURL == "" {
cli.ShowCommandHelp(c, "get")
os.Exit(1)
}
url, err := NewURL(argURL)
utils.DieIf(err)
isSSH := c.Bool("p")
if isSSH {
// Assume Git repository if `-p` is given.
url, err = ConvertGitURLHTTPToSSH(url)
utils.DieIf(err)
}
remote, err := NewRemoteRepository(url)
utils.DieIf(err)
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
os.Exit(1)
}
getRemoteRepository(remote, doUpdate, isShallow)
if category != "" {
localPath := LocalRepositoryFromURL(remote.URL()).FullPath
categoryFile := path.Dir(localPath) + "/." + path.Base(localPath)
if doUpdate {
utils.Log("overwrite category", fmt.Sprintf("%s as %s", localPath, category))
ioutil.WriteFile(categoryFile, []byte(category+"\n"), 0644)
} else {
_, err := os.Stat(localPath)
if err != nil {
utils.PanicIf(err)
} else {
utils.Log("new category", fmt.Sprintf("%s as %s", localPath, category))
ioutil.WriteFile(categoryFile, []byte(category+"\n"), 0644)
}
}
}
}
func doGet(c *cli.Context) {
argURL := c.Args().Get(0)
doUpdate := c.Bool("update")
if argURL == "" {
cli.ShowCommandHelp(c, "get")
os.Exit(1)
}
url, err := url.Parse(argURL)
utils.DieIf(err)
if !url.IsAbs() {
url.Scheme = "https"
url.Host = "github.com"
if url.Path[0] != '/' {
url.Path = "/" + url.Path
}
}
remote, err := NewRemoteRepository(url)
utils.DieIf(err)
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
os.Exit(1)
}
getRemoteRepository(remote, doUpdate)
}
func doGet(c *cli.Context) {
argURL := c.Args().Get(0)
doUpdate := c.Bool("update")
isShallow := c.Bool("shallow")
if argURL == "" {
cli.ShowCommandHelp(c, "get")
os.Exit(1)
}
url, err := NewURL(argURL)
utils.DieIf(err)
isSSH := c.Bool("p")
if isSSH {
// Assume Git repository if `-p` is given.
url, err = ConvertGitURLHTTPToSSH(url)
utils.DieIf(err)
}
remote, err := NewRemoteRepository(url)
utils.DieIf(err)
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
os.Exit(1)
}
getRemoteRepository(remote, doUpdate, isShallow)
}
func doImportStarred(c *cli.Context) {
user := c.Args().First()
if user == "" {
cli.ShowCommandHelp(c, "starred")
os.Exit(1)
}
client := github.NewClient(nil)
options := &github.ActivityListStarredOptions{Sort: "created"}
for page := 1; ; page++ {
options.Page = page
repositories, res, err := client.Activity.ListStarred(user, options)
utils.DieIf(err)
utils.Log("page", fmt.Sprintf("%d/%d", page, res.LastPage))
for _, repo := range repositories {
url, err := url.Parse(*repo.HTMLURL)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not parse URL <%s>: %s", repo.HTMLURL, err))
continue
}
remote, err := NewRemoteRepository(url)
if utils.ErrorIf(err) {
continue
}
if remote.IsValid() == false {
utils.Log("skip", fmt.Sprintf("Not a valid repository: %s", url))
continue
}
getRemoteRepository(remote, c.Bool("update"))
}
if page >= res.LastPage {
break
}
}
}
func doImport(c *cli.Context) {
var (
doUpdate = c.Bool("update")
isSSH = c.Bool("p")
isShallow = c.Bool("shallow")
)
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
line := scanner.Text()
url, err := url.Parse(line)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not parse URL <%s>: %s", line, err))
continue
}
if isSSH {
url, err = ConvertGitURLHTTPToSSH(url)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not convert URL <%s>: %s", url, err))
continue
}
}
remote, err := NewRemoteRepository(url)
if utils.ErrorIf(err) {
continue
}
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
continue
}
getRemoteRepository(remote, doUpdate, isShallow)
}
if err := scanner.Err(); err != nil {
utils.Log("error", fmt.Sprintf("While reading input: %s", err))
os.Exit(1)
}
}
func doLook(c *cli.Context) {
name := c.Args().First()
if name == "" {
cli.ShowCommandHelp(c, "look")
os.Exit(1)
}
reposFound := []*LocalRepository{}
walkLocalRepositories(func(repo *LocalRepository) {
if repo.Matches(name) {
reposFound = append(reposFound, repo)
}
})
switch len(reposFound) {
case 0:
utils.Log("error", "No repository found")
case 1:
shell := os.Getenv("SHELL")
if shell == "" {
shell = "/bin/sh"
}
utils.Log("cd", reposFound[0].FullPath)
err := os.Chdir(reposFound[0].FullPath)
utils.PanicIf(err)
syscall.Exec(shell, []string{shell}, syscall.Environ())
default:
utils.Log("error", "More than one repositories are found; Try more precise name")
for _, repo := range reposFound {
utils.Log("error", "- "+strings.Join(repo.PathParts, "/"))
}
}
}
func doImport(c *cli.Context) {
var (
branch = ""
doUpdate = c.Bool("update")
isSSH = c.Bool("p")
isShallow = c.Bool("shallow")
isRecursive = c.Bool("recursive")
)
var (
in io.Reader
finalize func() error
)
if isShallow && isRecursive {
utils.Log("error", "Cannot specify both --shallow and --recursive options")
os.Exit(1)
}
if len(c.Args()) == 0 {
// `ghq import` reads URLs from stdin
in = os.Stdin
finalize = func() error { return nil }
} else {
// Handle `ghq import starred motemen` case
// with `git config --global ghq.import.starred "!github-list-starred"`
subCommand := c.Args().First()
command, err := GitConfigSingle("ghq.import." + subCommand)
if err == nil && command == "" {
err = fmt.Errorf("ghq.import.%s configuration not found", subCommand)
}
utils.DieIf(err)
// execute `sh -c 'COMMAND "$@"' -- ARG...`
// TODO: Windows
command = strings.TrimLeft(command, "!")
shellCommand := append([]string{"sh", "-c", command + ` "$@"`, "--"}, c.Args().Tail()...)
utils.Log("run", strings.Join(append([]string{command}, c.Args().Tail()...), " "))
cmd := exec.Command(shellCommand[0], shellCommand[1:]...)
cmd.Stderr = os.Stderr
in, err = cmd.StdoutPipe()
utils.DieIf(err)
err = cmd.Start()
utils.DieIf(err)
finalize = cmd.Wait
}
scanner := bufio.NewScanner(in)
for scanner.Scan() {
line := scanner.Text()
fields := strings.Fields(line)
if len(fields) > 0 {
line = fields[0]
if len(fields) > 1 {
branch = fields[1]
} else {
branch = ""
}
}
url, err := NewURL(line)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not parse URL <%s>: %s", line, err))
continue
}
if isSSH {
url, err = ConvertGitURLHTTPToSSH(url)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not convert URL <%s>: %s", url, err))
continue
}
}
remote, err := NewRemoteRepository(url)
if utils.ErrorIf(err) {
continue
}
if remote.IsValid() == false {
utils.Log("error", fmt.Sprintf("Not a valid repository: %s", url))
continue
}
getRemoteRepository(remote, branch, doUpdate, isShallow, isRecursive)
}
if err := scanner.Err(); err != nil {
utils.Log("error", fmt.Sprintf("While reading input: %s", err))
os.Exit(1)
}
utils.DieIf(finalize())
}
func doImportStarred(c *cli.Context) {
user := c.Args().First()
doUpdate := c.Bool("update")
isSSH := c.Bool("p")
isShallow := c.Bool("shallow")
if user == "" {
cli.ShowCommandHelp(c, "starred")
os.Exit(1)
}
githubToken := os.Getenv("GHQ_GITHUB_TOKEN")
if githubToken == "" {
var err error
githubToken, err = GitConfigSingle("ghq.github.token")
utils.PanicIf(err)
}
var client *github.Client
if githubToken != "" {
oauthTransport := &oauth.Transport{
Token: &oauth.Token{AccessToken: githubToken},
}
client = github.NewClient(oauthTransport.Client())
} else {
client = github.NewClient(nil)
}
options := &github.ActivityListStarredOptions{Sort: "created"}
for page := 1; ; page++ {
options.Page = page
repositories, res, err := client.Activity.ListStarred(user, options)
utils.DieIf(err)
utils.Log("page", fmt.Sprintf("%d/%d", page, res.LastPage))
for _, repo := range repositories {
url, err := url.Parse(*repo.HTMLURL)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not parse URL <%s>: %s", repo.HTMLURL, err))
continue
}
if isSSH {
url, err = ConvertGitURLHTTPToSSH(url)
if err != nil {
utils.Log("error", fmt.Sprintf("Could not convert URL <%s>: %s", repo.HTMLURL, err))
continue
}
}
remote, err := NewRemoteRepository(url)
if utils.ErrorIf(err) {
continue
}
if remote.IsValid() == false {
utils.Log("skip", fmt.Sprintf("Not a valid repository: %s", url))
continue
}
getRemoteRepository(remote, doUpdate, isShallow)
}
if page >= res.LastPage {
break
}
}
}
