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