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)
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 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 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 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 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 (
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
}
}
}