initial commit

github/config.go

@@ -0,0 +1,409 @@
+package github
+
+import (
+	"bufio"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/github/gh/ui"
+	"github.com/github/gh/utils"
+	"github.com/mitchellh/go-homedir"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+type yamlHost struct {
+	User       string `yaml:"user"`
+	OAuthToken string `yaml:"oauth_token"`
+	Protocol   string `yaml:"protocol"`
+	UnixSocket string `yaml:"unix_socket,omitempty"`
+}
+
+type Host struct {
+	Host        string `toml:"host"`
+	User        string `toml:"user"`
+	AccessToken string `toml:"access_token"`
+	Protocol    string `toml:"protocol"`
+	UnixSocket  string `toml:"unix_socket,omitempty"`
+}
+
+type Config struct {
+	Hosts []*Host `toml:"hosts"`
+}
+
+func (c *Config) PromptForHost(host string) (h *Host, err error) {
+	token := c.DetectToken()
+	tokenFromEnv := token != ""
+
+	if host != GitHubHost {
+		if _, e := url.Parse("https://" + host); e != nil {
+			err = fmt.Errorf("invalid hostname: %q", host)
+			return
+		}
+	}
+
+	h = c.Find(host)
+	if h != nil {
+		if h.User == "" {
+			utils.Check(CheckWriteable(configsFile()))
+			// User is missing from the config: this is a broken config probably
+			// because it was created with an old (broken) version of hub. Let's fix
+			// it now. See issue #1007 for details.
+			user := c.PromptForUser(host)
+			if user == "" {
+				utils.Check(fmt.Errorf("missing user"))
+			}
+			h.User = user
+			err := newConfigService().Save(configsFile(), c)
+			utils.Check(err)
+		}
+		if tokenFromEnv {
+			h.AccessToken = token
+		} else {
+			return
+		}
+	} else {
+		h = &Host{
+			Host:        host,
+			AccessToken: token,
+			Protocol:    "https",
+		}
+		c.Hosts = append(c.Hosts, h)
+	}
+
+	client := NewClientWithHost(h)
+
+	if !tokenFromEnv {
+		utils.Check(CheckWriteable(configsFile()))
+		err = c.authorizeClient(client, host)
+		if err != nil {
+			return
+		}
+	}
+
+	userFromEnv := os.Getenv("GITHUB_USER")
+	repoFromEnv := os.Getenv("GITHUB_REPOSITORY")
+	if userFromEnv == "" && repoFromEnv != "" {
+		repoParts := strings.SplitN(repoFromEnv, "/", 2)
+		if len(repoParts) > 0 {
+			userFromEnv = repoParts[0]
+		}
+	}
+	if tokenFromEnv && userFromEnv != "" {
+		h.User = userFromEnv
+	} else {
+		var currentUser *User
+		currentUser, err = client.CurrentUser()
+		if err != nil {
+			return
+		}
+		h.User = currentUser.Login
+	}
+
+	if !tokenFromEnv {
+		err = newConfigService().Save(configsFile(), c)
+	}
+
+	return
+}
+
+func (c *Config) authorizeClient(client *Client, host string) (err error) {
+	user := c.PromptForUser(host)
+	pass := c.PromptForPassword(host, user)
+
+	var code, token string
+	for {
+		token, err = client.FindOrCreateToken(user, pass, code)
+		if err == nil {
+			break
+		}
+
+		if ae, ok := err.(*errorInfo); ok && strings.HasPrefix(ae.Response.Header.Get("X-GitHub-OTP"), "required;") {
+			if code != "" {
+				ui.Errorln("warning: invalid two-factor code")
+			}
+			code = c.PromptForOTP()
+		} else {
+			break
+		}
+	}
+
+	if err == nil {
+		client.Host.AccessToken = token
+	}
+
+	return
+}
+
+func (c *Config) DetectToken() string {
+	return os.Getenv("GITHUB_TOKEN")
+}
+
+func (c *Config) PromptForUser(host string) (user string) {
+	user = os.Getenv("GITHUB_USER")
+	if user != "" {
+		return
+	}
+
+	ui.Printf("%s username: ", host)
+	user = c.scanLine()
+
+	return
+}
+
+func (c *Config) PromptForPassword(host, user string) (pass string) {
+	pass = os.Getenv("GITHUB_PASSWORD")
+	if pass != "" {
+		return
+	}
+
+	ui.Printf("%s password for %s (never stored): ", host, user)
+	if ui.IsTerminal(os.Stdin) {
+		if password, err := getPassword(); err == nil {
+			pass = password
+		}
+	} else {
+		pass = c.scanLine()
+	}
+
+	return
+}
+
+func (c *Config) PromptForOTP() string {
+	fmt.Print("two-factor authentication code: ")
+	return c.scanLine()
+}
+
+func (c *Config) scanLine() string {
+	var line string
+	scanner := bufio.NewScanner(os.Stdin)
+	if scanner.Scan() {
+		line = scanner.Text()
+	}
+	utils.Check(scanner.Err())
+
+	return line
+}
+
+func getPassword() (string, error) {
+	stdin := int(syscall.Stdin)
+	initialTermState, err := terminal.GetState(stdin)
+	if err != nil {
+		return "", err
+	}
+
+	c := make(chan os.Signal)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		s := <-c
+		terminal.Restore(stdin, initialTermState)
+		switch sig := s.(type) {
+		case syscall.Signal:
+			if int(sig) == 2 {
+				fmt.Println("^C")
+			}
+		}
+		os.Exit(1)
+	}()
+
+	passBytes, err := terminal.ReadPassword(stdin)
+	if err != nil {
+		return "", err
+	}
+
+	signal.Stop(c)
+	fmt.Print("\n")
+	return string(passBytes), nil
+}
+
+func (c *Config) Find(host string) *Host {
+	for _, h := range c.Hosts {
+		if h.Host == host {
+			return h
+		}
+	}
+
+	return nil
+}
+
+func (c *Config) selectHost() *Host {
+	options := len(c.Hosts)
+
+	if options == 1 {
+		return c.Hosts[0]
+	}
+
+	prompt := "Select host:\n"
+	for idx, host := range c.Hosts {
+		prompt += fmt.Sprintf(" %d. %s\n", idx+1, host.Host)
+	}
+	prompt += fmt.Sprint("> ")
+
+	ui.Printf(prompt)
+	index := c.scanLine()
+	i, err := strconv.Atoi(index)
+	if err != nil || i < 1 || i > options {
+		utils.Check(fmt.Errorf("Error: must enter a number [1-%d]", options))
+	}
+
+	return c.Hosts[i-1]
+}
+
+var defaultConfigsFile string
+
+func configsFile() string {
+	if configFromEnv := os.Getenv("HUB_CONFIG"); configFromEnv != "" {
+		return configFromEnv
+	}
+	if defaultConfigsFile == "" {
+		var err error
+		defaultConfigsFile, err = determineConfigLocation()
+		utils.Check(err)
+	}
+	return defaultConfigsFile
+}
+
+func homeConfig() (string, error) {
+	if home, err := homedir.Dir(); err != nil {
+		return "", err
+	} else {
+		return filepath.Join(home, ".config"), nil
+	}
+}
+
+func determineConfigLocation() (string, error) {
+	var err error
+
+	xdgHome := os.Getenv("XDG_CONFIG_HOME")
+	configDir := xdgHome
+	if configDir == "" {
+		if configDir, err = homeConfig(); err != nil {
+			return "", err
+		}
+	}
+
+	xdgDirs := os.Getenv("XDG_CONFIG_DIRS")
+	if xdgDirs == "" {
+		xdgDirs = "/etc/xdg"
+	}
+	searchDirs := append([]string{configDir}, strings.Split(xdgDirs, ":")...)
+
+	for _, dir := range searchDirs {
+		filename := filepath.Join(dir, "hub")
+		if _, err := os.Stat(filename); err == nil {
+			return filename, nil
+		}
+	}
+
+	configFile := filepath.Join(configDir, "hub")
+
+	if configDir == xdgHome {
+		if homeDir, _ := homeConfig(); homeDir != "" {
+			legacyConfig := filepath.Join(homeDir, "hub")
+			if _, err = os.Stat(legacyConfig); err == nil {
+				ui.Errorf("Notice: config file found but not respected at: %s\n", legacyConfig)
+				ui.Errorf("You might want to move it to `%s' to avoid re-authenticating.\n", configFile)
+			}
+		}
+	}
+
+	return configFile, nil
+}
+
+var currentConfig *Config
+var configLoadedFrom = ""
+
+func CurrentConfig() *Config {
+	filename := configsFile()
+	if configLoadedFrom != filename {
+		currentConfig = &Config{}
+		newConfigService().Load(filename, currentConfig)
+		configLoadedFrom = filename
+	}
+
+	return currentConfig
+}
+
+func (c *Config) DefaultHost() (host *Host, err error) {
+	if GitHubHostEnv != "" {
+		host, err = c.PromptForHost(GitHubHostEnv)
+	} else if len(c.Hosts) > 0 {
+		host = c.selectHost()
+		// HACK: forces host to inherit GITHUB_TOKEN if applicable
+		host, err = c.PromptForHost(host.Host)
+	} else {
+		host, err = c.PromptForHost(DefaultGitHubHost())
+	}
+
+	return
+}
+
+func (c *Config) DefaultHostNoPrompt() (*Host, error) {
+	if GitHubHostEnv != "" {
+		return c.PromptForHost(GitHubHostEnv)
+	} else if len(c.Hosts) > 0 {
+		host := c.Hosts[0]
+		// HACK: forces host to inherit GITHUB_TOKEN if applicable
+		return c.PromptForHost(host.Host)
+	} else {
+		return c.PromptForHost(GitHubHost)
+	}
+}
+
+// CheckWriteable checks if config file is writeable. This should
+// be called before asking for credentials and only if current
+// operation needs to update the file. See issue #1314 for details.
+func CheckWriteable(filename string) error {
+	// Check if file exists already. if it doesn't, we will delete it after
+	// checking for writeabilty
+	fileExistsAlready := false
+
+	if _, err := os.Stat(filename); err == nil {
+		fileExistsAlready = true
+	}
+
+	err := os.MkdirAll(filepath.Dir(filename), 0771)
+	if err != nil {
+		return err
+	}
+
+	w, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0600)
+	if err != nil {
+		return err
+	}
+	w.Close()
+
+	if !fileExistsAlready {
+		err := os.Remove(filename)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Public for testing purpose
+func CreateTestConfigs(user, token string) *Config {
+	f, _ := ioutil.TempFile("", "test-config")
+	os.Setenv("HUB_CONFIG", f.Name())
+
+	host := &Host{
+		User:        "jingweno",
+		AccessToken: "123",
+		Host:        GitHubHost,
+	}
+
+	c := &Config{Hosts: []*Host{host}}
+	err := newConfigService().Save(f.Name(), c)
+	if err != nil {
+		panic(err)
+	}
+
+	return c
+}

github/config_decoder.go

@@ -0,0 +1,61 @@
+package github
+
+import (
+	"io"
+	"io/ioutil"
+
+	"github.com/BurntSushi/toml"
+	"gopkg.in/yaml.v2"
+)
+
+type configDecoder interface {
+	Decode(r io.Reader, c *Config) error
+}
+
+type tomlConfigDecoder struct {
+}
+
+func (t *tomlConfigDecoder) Decode(r io.Reader, c *Config) error {
+	_, err := toml.DecodeReader(r, c)
+	return err
+}
+
+type yamlConfigDecoder struct {
+}
+
+func (y *yamlConfigDecoder) Decode(r io.Reader, c *Config) error {
+	d, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+
+	yc := yaml.MapSlice{}
+	err = yaml.Unmarshal(d, &yc)
+
+	if err != nil {
+		return err
+	}
+
+	for _, hostEntry := range yc {
+		v := hostEntry.Value.([]interface{})
+		if len(v) < 1 {
+			continue
+		}
+		host := &Host{Host: hostEntry.Key.(string)}
+		for _, prop := range v[0].(yaml.MapSlice) {
+			switch prop.Key.(string) {
+			case "user":
+				host.User = prop.Value.(string)
+			case "oauth_token":
+				host.AccessToken = prop.Value.(string)
+			case "protocol":
+				host.Protocol = prop.Value.(string)
+			case "unix_socket":
+				host.UnixSocket = prop.Value.(string)
+			}
+		}
+		c.Hosts = append(c.Hosts, host)
+	}
+
+	return nil
+}

github/config_encoder.go

@@ -0,0 +1,52 @@
+package github
+
+import (
+	"io"
+
+	"github.com/BurntSushi/toml"
+	"gopkg.in/yaml.v2"
+)
+
+type configEncoder interface {
+	Encode(w io.Writer, c *Config) error
+}
+
+type tomlConfigEncoder struct {
+}
+
+func (t *tomlConfigEncoder) Encode(w io.Writer, c *Config) error {
+	enc := toml.NewEncoder(w)
+	return enc.Encode(c)
+}
+
+type yamlConfigEncoder struct {
+}
+
+func (y *yamlConfigEncoder) Encode(w io.Writer, c *Config) error {
+	yc := yaml.MapSlice{}
+	for _, h := range c.Hosts {
+		yc = append(yc, yaml.MapItem{
+			Key: h.Host,
+			Value: []yamlHost{
+				{
+					User:       h.User,
+					OAuthToken: h.AccessToken,
+					Protocol:   h.Protocol,
+					UnixSocket: h.UnixSocket,
+				},
+			},
+		})
+	}
+
+	d, err := yaml.Marshal(yc)
+	if err != nil {
+		return err
+	}
+
+	n, err := w.Write(d)
+	if err == nil && n < len(d) {
+		err = io.ErrShortWrite
+	}
+
+	return err
+}

github/config_service.go

@@ -0,0 +1,43 @@
+package github
+
+import (
+	"os"
+	"path/filepath"
+)
+
+func newConfigService() *configService {
+	return &configService{
+		Encoder: &yamlConfigEncoder{},
+		Decoder: &yamlConfigDecoder{},
+	}
+}
+
+type configService struct {
+	Encoder configEncoder
+	Decoder configDecoder
+}
+
+func (s *configService) Save(filename string, c *Config) error {
+	err := os.MkdirAll(filepath.Dir(filename), 0771)
+	if err != nil {
+		return err
+	}
+
+	w, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return err
+	}
+	defer w.Close()
+
+	return s.Encoder.Encode(w, c)
+}
+
+func (s *configService) Load(filename string, c *Config) error {
+	r, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	return s.Decoder.Decode(r, c)
+}

github/hosts.go

@@ -0,0 +1,64 @@
+package github
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/github/gh/git"
+)
+
+var (
+	GitHubHostEnv = os.Getenv("GITHUB_HOST")
+	cachedHosts   []string
+)
+
+type GithubHostError struct {
+	url *url.URL
+}
+
+func (e *GithubHostError) Error() string {
+	return fmt.Sprintf("Invalid GitHub URL: %s", e.url)
+}
+
+func knownGitHubHostsInclude(host string) bool {
+	for _, hh := range knownGitHubHosts() {
+		if hh == host {
+			return true
+		}
+	}
+
+	return false
+}
+
+func knownGitHubHosts() []string {
+	if cachedHosts != nil {
+		return cachedHosts
+	}
+
+	hosts := []string{}
+	defaultHost := DefaultGitHubHost()
+	hosts = append(hosts, defaultHost)
+	hosts = append(hosts, "ssh.github.com")
+
+	ghHosts, _ := git.ConfigAll("hub.host")
+	for _, ghHost := range ghHosts {
+		ghHost = strings.TrimSpace(ghHost)
+		if ghHost != "" {
+			hosts = append(hosts, ghHost)
+		}
+	}
+
+	cachedHosts = hosts
+	return hosts
+}
+
+func DefaultGitHubHost() string {
+	defaultHost := GitHubHostEnv
+	if defaultHost == "" {
+		defaultHost = GitHubHost
+	}
+
+	return defaultHost
+}

github/http.go

@@ -0,0 +1,537 @@
+package github
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/github/gh/ui"
+	"github.com/github/gh/utils"
+)
+
+const apiPayloadVersion = "application/vnd.github.v3+json;charset=utf-8"
+const patchMediaType = "application/vnd.github.v3.patch;charset=utf-8"
+const textMediaType = "text/plain;charset=utf-8"
+const checksType = "application/vnd.github.antiope-preview+json;charset=utf-8"
+const draftsType = "application/vnd.github.shadow-cat-preview+json;charset=utf-8"
+const cacheVersion = 2
+
+var inspectHeaders = []string{
+	"Authorization",
+	"X-GitHub-OTP",
+	"Location",
+	"Link",
+	"Accept",
+}
+
+type verboseTransport struct {
+	Transport   *http.Transport
+	Verbose     bool
+	OverrideURL *url.URL
+	Out         io.Writer
+	Colorized   bool
+}
+
+func (t *verboseTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	if t.Verbose {
+		t.dumpRequest(req)
+	}
+
+	if t.OverrideURL != nil {
+		port := "80"
+		if s := strings.Split(req.URL.Host, ":"); len(s) > 1 {
+			port = s[1]
+		}
+
+		req = cloneRequest(req)
+		req.Header.Set("X-Original-Scheme", req.URL.Scheme)
+		req.Header.Set("X-Original-Port", port)
+		req.Host = req.URL.Host
+		req.URL.Scheme = t.OverrideURL.Scheme
+		req.URL.Host = t.OverrideURL.Host
+	}
+
+	resp, err = t.Transport.RoundTrip(req)
+
+	if err == nil && t.Verbose {
+		t.dumpResponse(resp)
+	}
+
+	return
+}
+
+func (t *verboseTransport) dumpRequest(req *http.Request) {
+	info := fmt.Sprintf("> %s %s://%s%s", req.Method, req.URL.Scheme, req.URL.Host, req.URL.RequestURI())
+	t.verbosePrintln(info)
+	t.dumpHeaders(req.Header, ">")
+	body := t.dumpBody(req.Body)
+	if body != nil {
+		// reset body since it's been read
+		req.Body = body
+	}
+}
+
+func (t *verboseTransport) dumpResponse(resp *http.Response) {
+	info := fmt.Sprintf("< HTTP %d", resp.StatusCode)
+	t.verbosePrintln(info)
+	t.dumpHeaders(resp.Header, "<")
+	body := t.dumpBody(resp.Body)
+	if body != nil {
+		// reset body since it's been read
+		resp.Body = body
+	}
+}
+
+func (t *verboseTransport) dumpHeaders(header http.Header, indent string) {
+	for _, listed := range inspectHeaders {
+		for name, vv := range header {
+			if !strings.EqualFold(name, listed) {
+				continue
+			}
+			for _, v := range vv {
+				if v != "" {
+					r := regexp.MustCompile("(?i)^(basic|token) (.+)")
+					if r.MatchString(v) {
+						v = r.ReplaceAllString(v, "$1 [REDACTED]")
+					}
+
+					info := fmt.Sprintf("%s %s: %s", indent, name, v)
+					t.verbosePrintln(info)
+				}
+			}
+		}
+	}
+}
+
+func (t *verboseTransport) dumpBody(body io.ReadCloser) io.ReadCloser {
+	if body == nil {
+		return nil
+	}
+
+	defer body.Close()
+	buf := new(bytes.Buffer)
+	_, err := io.Copy(buf, body)
+	utils.Check(err)
+
+	if buf.Len() > 0 {
+		t.verbosePrintln(buf.String())
+	}
+
+	return ioutil.NopCloser(buf)
+}
+
+func (t *verboseTransport) verbosePrintln(msg string) {
+	if t.Colorized {
+		msg = fmt.Sprintf("\033[36m%s\033[0m", msg)
+	}
+
+	fmt.Fprintln(t.Out, msg)
+}
+
+func newHttpClient(testHost string, verbose bool, unixSocket string) *http.Client {
+	var testURL *url.URL
+	if testHost != "" {
+		testURL, _ = url.Parse(testHost)
+	}
+	var httpTransport *http.Transport
+	if unixSocket != "" {
+		dialFunc := func(network, addr string) (net.Conn, error) {
+			return net.Dial("unix", unixSocket)
+		}
+		dialContext := func(_ context.Context, _, _ string) (net.Conn, error) {
+			return net.Dial("unix", unixSocket)
+		}
+		httpTransport = &http.Transport{
+			DialContext:           dialContext,
+			DialTLS:               dialFunc,
+			ResponseHeaderTimeout: 30 * time.Second,
+			ExpectContinueTimeout: 10 * time.Second,
+			TLSHandshakeTimeout:   10 * time.Second,
+		}
+	} else {
+		httpTransport = &http.Transport{
+			Proxy: proxyFromEnvironment,
+			DialContext: (&net.Dialer{
+				Timeout:   30 * time.Second,
+				KeepAlive: 30 * time.Second,
+			}).DialContext,
+			TLSHandshakeTimeout: 10 * time.Second,
+		}
+	}
+	tr := &verboseTransport{
+		Transport:   httpTransport,
+		Verbose:     verbose,
+		OverrideURL: testURL,
+		Out:         ui.Stderr,
+		Colorized:   ui.IsTerminal(os.Stderr),
+	}
+
+	return &http.Client{
+		Transport: tr,
+	}
+}
+
+func cloneRequest(req *http.Request) *http.Request {
+	dup := new(http.Request)
+	*dup = *req
+	dup.URL, _ = url.Parse(req.URL.String())
+	dup.Header = make(http.Header)
+	for k, s := range req.Header {
+		dup.Header[k] = s
+	}
+	return dup
+}
+
+// An implementation of http.ProxyFromEnvironment that isn't broken
+func proxyFromEnvironment(req *http.Request) (*url.URL, error) {
+	proxy := os.Getenv("http_proxy")
+	if proxy == "" {
+		proxy = os.Getenv("HTTP_PROXY")
+	}
+	if proxy == "" {
+		return nil, nil
+	}
+
+	proxyURL, err := url.Parse(proxy)
+	if err != nil || !strings.HasPrefix(proxyURL.Scheme, "http") {
+		if proxyURL, err := url.Parse("http://" + proxy); err == nil {
+			return proxyURL, nil
+		}
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)
+	}
+
+	return proxyURL, nil
+}
+
+type simpleClient struct {
+	httpClient     *http.Client
+	rootUrl        *url.URL
+	PrepareRequest func(*http.Request)
+	CacheTTL       int
+}
+
+func (c *simpleClient) performRequest(method, path string, body io.Reader, configure func(*http.Request)) (*simpleResponse, error) {
+	url, err := url.Parse(path)
+	if err == nil {
+		url = c.rootUrl.ResolveReference(url)
+		return c.performRequestUrl(method, url, body, configure)
+	} else {
+		return nil, err
+	}
+}
+
+func (c *simpleClient) performRequestUrl(method string, url *url.URL, body io.Reader, configure func(*http.Request)) (res *simpleResponse, err error) {
+	req, err := http.NewRequest(method, url.String(), body)
+	if err != nil {
+		return
+	}
+	if c.PrepareRequest != nil {
+		c.PrepareRequest(req)
+	}
+	req.Header.Set("User-Agent", UserAgent)
+	req.Header.Set("Accept", apiPayloadVersion)
+
+	if configure != nil {
+		configure(req)
+	}
+
+	key := cacheKey(req)
+	if cachedResponse := c.cacheRead(key, req); cachedResponse != nil {
+		res = &simpleResponse{cachedResponse}
+		return
+	}
+
+	httpResponse, err := c.httpClient.Do(req)
+	if err != nil {
+		return
+	}
+
+	c.cacheWrite(key, httpResponse)
+	res = &simpleResponse{httpResponse}
+
+	return
+}
+
+func isGraphQL(req *http.Request) bool {
+	return req.URL.Path == "/graphql"
+}
+
+func canCache(req *http.Request) bool {
+	return strings.EqualFold(req.Method, "GET") || isGraphQL(req)
+}
+
+func (c *simpleClient) cacheRead(key string, req *http.Request) (res *http.Response) {
+	if c.CacheTTL > 0 && canCache(req) {
+		f := cacheFile(key)
+		cacheInfo, err := os.Stat(f)
+		if err != nil {
+			return
+		}
+		if time.Since(cacheInfo.ModTime()).Seconds() > float64(c.CacheTTL) {
+			return
+		}
+		cf, err := os.Open(f)
+		if err != nil {
+			return
+		}
+		defer cf.Close()
+
+		cb, err := ioutil.ReadAll(cf)
+		if err != nil {
+			return
+		}
+		parts := strings.SplitN(string(cb), "\r\n\r\n", 2)
+		if len(parts) < 2 {
+			return
+		}
+
+		res = &http.Response{
+			Body:   ioutil.NopCloser(bytes.NewBufferString(parts[1])),
+			Header: http.Header{},
+		}
+		headerLines := strings.Split(parts[0], "\r\n")
+		if len(headerLines) < 1 {
+			return
+		}
+		if proto := strings.SplitN(headerLines[0], " ", 3); len(proto) >= 3 {
+			res.Proto = proto[0]
+			res.Status = fmt.Sprintf("%s %s", proto[1], proto[2])
+			if code, _ := strconv.Atoi(proto[1]); code > 0 {
+				res.StatusCode = code
+			}
+		}
+		for _, line := range headerLines[1:] {
+			kv := strings.SplitN(line, ":", 2)
+			if len(kv) >= 2 {
+				res.Header.Add(kv[0], strings.TrimLeft(kv[1], " "))
+			}
+		}
+	}
+	return
+}
+
+func (c *simpleClient) cacheWrite(key string, res *http.Response) {
+	if c.CacheTTL > 0 && canCache(res.Request) && res.StatusCode < 500 && res.StatusCode != 403 {
+		bodyCopy := &bytes.Buffer{}
+		bodyReplacement := readCloserCallback{
+			Reader: io.TeeReader(res.Body, bodyCopy),
+			Closer: res.Body,
+			Callback: func() {
+				f := cacheFile(key)
+				err := os.MkdirAll(filepath.Dir(f), 0771)
+				if err != nil {
+					return
+				}
+				cf, err := os.OpenFile(f, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+				if err != nil {
+					return
+				}
+				defer cf.Close()
+				fmt.Fprintf(cf, "%s %s\r\n", res.Proto, res.Status)
+				res.Header.Write(cf)
+				fmt.Fprintf(cf, "\r\n")
+				io.Copy(cf, bodyCopy)
+			},
+		}
+		res.Body = &bodyReplacement
+	}
+}
+
+type readCloserCallback struct {
+	Callback func()
+	Closer   io.Closer
+	io.Reader
+}
+
+func (rc *readCloserCallback) Close() error {
+	err := rc.Closer.Close()
+	if err == nil {
+		rc.Callback()
+	}
+	return err
+}
+
+func cacheKey(req *http.Request) string {
+	path := strings.Replace(req.URL.EscapedPath(), "/", "-", -1)
+	if len(path) > 1 {
+		path = strings.TrimPrefix(path, "-")
+	}
+	host := req.Host
+	if host == "" {
+		host = req.URL.Host
+	}
+	hash := md5.New()
+	fmt.Fprintf(hash, "%d:", cacheVersion)
+	io.WriteString(hash, req.Header.Get("Accept"))
+	io.WriteString(hash, req.Header.Get("Authorization"))
+	queryParts := strings.Split(req.URL.RawQuery, "&")
+	sort.Strings(queryParts)
+	for _, q := range queryParts {
+		fmt.Fprintf(hash, "%s&", q)
+	}
+	if isGraphQL(req) && req.Body != nil {
+		if b, err := ioutil.ReadAll(req.Body); err == nil {
+			req.Body = ioutil.NopCloser(bytes.NewBuffer(b))
+			hash.Write(b)
+		}
+	}
+	return fmt.Sprintf("%s/%s_%x", host, path, hash.Sum(nil))
+}
+
+func cacheFile(key string) string {
+	return path.Join(os.TempDir(), "hub", "api", key)
+}
+
+func (c *simpleClient) jsonRequest(method, path string, body interface{}, configure func(*http.Request)) (*simpleResponse, error) {
+	json, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	buf := bytes.NewBuffer(json)
+
+	return c.performRequest(method, path, buf, func(req *http.Request) {
+		req.Header.Set("Content-Type", "application/json; charset=utf-8")
+		if configure != nil {
+			configure(req)
+		}
+	})
+}
+
+func (c *simpleClient) Get(path string) (*simpleResponse, error) {
+	return c.performRequest("GET", path, nil, nil)
+}
+
+func (c *simpleClient) GetFile(path string, mimeType string) (*simpleResponse, error) {
+	return c.performRequest("GET", path, nil, func(req *http.Request) {
+		req.Header.Set("Accept", mimeType)
+	})
+}
+
+func (c *simpleClient) Delete(path string) (*simpleResponse, error) {
+	return c.performRequest("DELETE", path, nil, nil)
+}
+
+func (c *simpleClient) PostJSON(path string, payload interface{}) (*simpleResponse, error) {
+	return c.jsonRequest("POST", path, payload, nil)
+}
+
+func (c *simpleClient) PostJSONPreview(path string, payload interface{}, mimeType string) (*simpleResponse, error) {
+	return c.jsonRequest("POST", path, payload, func(req *http.Request) {
+		req.Header.Set("Accept", mimeType)
+	})
+}
+
+func (c *simpleClient) PatchJSON(path string, payload interface{}) (*simpleResponse, error) {
+	return c.jsonRequest("PATCH", path, payload, nil)
+}
+
+func (c *simpleClient) PostFile(path, filename string) (*simpleResponse, error) {
+	stat, err := os.Stat(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	return c.performRequest("POST", path, file, func(req *http.Request) {
+		req.ContentLength = stat.Size()
+		req.Header.Set("Content-Type", "application/octet-stream")
+	})
+}
+
+type simpleResponse struct {
+	*http.Response
+}
+
+type errorInfo struct {
+	Message  string       `json:"message"`
+	Errors   []fieldError `json:"errors"`
+	Response *http.Response
+}
+type errorInfoSimple struct {
+	Message string   `json:"message"`
+	Errors  []string `json:"errors"`
+}
+type fieldError struct {
+	Resource string `json:"resource"`
+	Message  string `json:"message"`
+	Code     string `json:"code"`
+	Field    string `json:"field"`
+}
+
+func (e *errorInfo) Error() string {
+	return e.Message
+}
+
+func (res *simpleResponse) Unmarshal(dest interface{}) (err error) {
+	defer res.Body.Close()
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return
+	}
+
+	return json.Unmarshal(body, dest)
+}
+
+func (res *simpleResponse) ErrorInfo() (msg *errorInfo, err error) {
+	defer res.Body.Close()
+
+	body, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return
+	}
+
+	msg = &errorInfo{}
+	err = json.Unmarshal(body, msg)
+	if err != nil {
+		msgSimple := &errorInfoSimple{}
+		if err = json.Unmarshal(body, msgSimple); err == nil {
+			msg.Message = msgSimple.Message
+			for _, errMsg := range msgSimple.Errors {
+				msg.Errors = append(msg.Errors, fieldError{
+					Code:    "custom",
+					Message: errMsg,
+				})
+			}
+		}
+	}
+	if err == nil {
+		msg.Response = res.Response
+	}
+
+	return
+}
+
+func (res *simpleResponse) Link(name string) string {
+	linkVal := res.Header.Get("Link")
+	re := regexp.MustCompile(`<([^>]+)>; rel="([^"]+)"`)
+	for _, match := range re.FindAllStringSubmatch(linkVal, -1) {
+		if match[2] == name {
+			return match[1]
+		}
+	}
+	return ""
+}

github/project.go

@@ -0,0 +1,181 @@
+package github
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/github/gh/git"
+	"github.com/github/gh/utils"
+)
+
+type Project struct {
+	Name     string
+	Owner    string
+	Host     string
+	Protocol string
+}
+
+func (p Project) String() string {
+	return fmt.Sprintf("%s/%s", p.Owner, p.Name)
+}
+
+func (p *Project) SameAs(other *Project) bool {
+	return strings.ToLower(p.Owner) == strings.ToLower(other.Owner) &&
+		strings.ToLower(p.Name) == strings.ToLower(other.Name) &&
+		strings.ToLower(p.Host) == strings.ToLower(other.Host)
+}
+
+func (p *Project) WebURL(name, owner, path string) string {
+	if owner == "" {
+		owner = p.Owner
+	}
+	if name == "" {
+		name = p.Name
+	}
+
+	ownerWithName := fmt.Sprintf("%s/%s", owner, name)
+	if strings.Contains(ownerWithName, ".wiki") {
+		ownerWithName = strings.TrimSuffix(ownerWithName, ".wiki")
+		if path != "wiki" {
+			if strings.HasPrefix(path, "commits") {
+				path = "_history"
+			} else if path != "" {
+				path = fmt.Sprintf("_%s", path)
+			}
+
+			if path != "" {
+				path = utils.ConcatPaths("wiki", path)
+			} else {
+				path = "wiki"
+			}
+		}
+	}
+
+	url := fmt.Sprintf("%s://%s", p.Protocol, utils.ConcatPaths(p.Host, ownerWithName))
+	if path != "" {
+		url = utils.ConcatPaths(url, path)
+	}
+
+	return url
+}
+
+func (p *Project) GitURL(name, owner string, isSSH bool) (url string) {
+	if name == "" {
+		name = p.Name
+	}
+	if owner == "" {
+		owner = p.Owner
+	}
+
+	host := rawHost(p.Host)
+
+	if preferredProtocol() == "https" {
+		url = fmt.Sprintf("https://%s/%s/%s.git", host, owner, name)
+	} else if isSSH || preferredProtocol() == "ssh" {
+		url = fmt.Sprintf("git@%s:%s/%s.git", host, owner, name)
+	} else {
+		url = fmt.Sprintf("git://%s/%s/%s.git", host, owner, name)
+	}
+
+	return url
+}
+
+// Remove the scheme from host when the host url is absolute.
+func rawHost(host string) string {
+	u, err := url.Parse(host)
+	utils.Check(err)
+
+	if u.IsAbs() {
+		return u.Host
+	} else {
+		return u.Path
+	}
+}
+
+func preferredProtocol() string {
+	userProtocol := os.Getenv("HUB_PROTOCOL")
+	if userProtocol == "" {
+		userProtocol, _ = git.Config("hub.protocol")
+	}
+	return userProtocol
+}
+
+func NewProjectFromURL(url *url.URL) (p *Project, err error) {
+	if !knownGitHubHostsInclude(url.Host) {
+		err = &GithubHostError{url}
+		return
+	}
+
+	parts := strings.SplitN(url.Path, "/", 4)
+	if len(parts) <= 2 {
+		err = fmt.Errorf("Invalid GitHub URL: %s", url)
+		return
+	}
+
+	name := strings.TrimSuffix(parts[2], ".git")
+	p = newProject(parts[1], name, url.Host, url.Scheme)
+
+	return
+}
+
+func NewProject(owner, name, host string) *Project {
+	return newProject(owner, name, host, "")
+}
+
+func newProject(owner, name, host, protocol string) *Project {
+	if strings.Contains(owner, "/") {
+		result := strings.SplitN(owner, "/", 2)
+		owner = result[0]
+		if name == "" {
+			name = result[1]
+		}
+	} else if strings.Contains(name, "/") {
+		result := strings.SplitN(name, "/", 2)
+		if owner == "" {
+			owner = result[0]
+		}
+		name = result[1]
+	}
+
+	if host == "" {
+		host = DefaultGitHubHost()
+	}
+	if host == "ssh.github.com" {
+		host = GitHubHost
+	}
+
+	if protocol != "http" && protocol != "https" {
+		protocol = ""
+	}
+	if protocol == "" {
+		h := CurrentConfig().Find(host)
+		if h != nil {
+			protocol = h.Protocol
+		}
+	}
+	if protocol == "" {
+		protocol = "https"
+	}
+
+	if owner == "" {
+		h := CurrentConfig().Find(host)
+		if h != nil {
+			owner = h.User
+		}
+	}
+
+	return &Project{
+		Name:     name,
+		Owner:    owner,
+		Host:     host,
+		Protocol: protocol,
+	}
+}
+
+func SanitizeProjectName(name string) string {
+	name = filepath.Base(name)
+	return strings.Replace(name, " ", "-", -1)
+}

github/remote.go

@@ -0,0 +1,101 @@
+package github
+
+import (
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/github/gh/git"
+)
+
+var (
+	OriginNamesInLookupOrder = []string{"upstream", "github", "origin"}
+)
+
+type Remote struct {
+	Name    string
+	URL     *url.URL
+	PushURL *url.URL
+}
+
+func (remote *Remote) String() string {
+	return remote.Name
+}
+
+func (remote *Remote) Project() (*Project, error) {
+	p, err := NewProjectFromURL(remote.URL)
+	if _, ok := err.(*GithubHostError); ok {
+		return NewProjectFromURL(remote.PushURL)
+	}
+	return p, err
+}
+
+func Remotes() (remotes []Remote, err error) {
+	re := regexp.MustCompile(`(.+)\s+(.+)\s+\((push|fetch)\)`)
+
+	rs, err := git.Remotes()
+	if err != nil {
+		err = fmt.Errorf("Can't load git remote")
+		return
+	}
+
+	// build the remotes map
+	remotesMap := make(map[string]map[string]string)
+	for _, r := range rs {
+		if re.MatchString(r) {
+			match := re.FindStringSubmatch(r)
+			name := strings.TrimSpace(match[1])
+			url := strings.TrimSpace(match[2])
+			urlType := strings.TrimSpace(match[3])
+			utm, ok := remotesMap[name]
+			if !ok {
+				utm = make(map[string]string)
+				remotesMap[name] = utm
+			}
+			utm[urlType] = url
+		}
+	}
+
+	// construct remotes in priority order
+	names := OriginNamesInLookupOrder
+	for _, name := range names {
+		if u, ok := remotesMap[name]; ok {
+			r, err := newRemote(name, u)
+			if err == nil {
+				remotes = append(remotes, r)
+				delete(remotesMap, name)
+			}
+		}
+	}
+
+	// the rest of the remotes
+	for n, u := range remotesMap {
+		r, err := newRemote(n, u)
+		if err == nil {
+			remotes = append(remotes, r)
+		}
+	}
+
+	return
+}
+
+func newRemote(name string, urlMap map[string]string) (Remote, error) {
+	r := Remote{}
+
+	fetchURL, ferr := git.ParseURL(urlMap["fetch"])
+	pushURL, perr := git.ParseURL(urlMap["push"])
+	if ferr != nil && perr != nil {
+		return r, fmt.Errorf("No valid remote URLs")
+	}
+
+	r.Name = name
+	if ferr == nil {
+		r.URL = fetchURL
+	}
+	if perr == nil {
+		r.PushURL = pushURL
+	}
+
+	return r, nil
+}