hub 1.10.6 → 1.11.0

data/lib/hub/context.rb

@@ -1,6 +1,6 @@
 require 'shellwords'
 require 'forwardable'
-require 'uri'
+require 'delegate'
 
 module Hub
   # Methods for inspecting the environment, such as reading git config,
@@ -99,7 +99,7 @@ module Hub
 
     repo_methods = [
       :current_branch,
-      :current_project, :upstream_project,
+      :remote_branch_and_project,
       :repo_owner, :repo_host,
       :remotes, :remotes_group, :origin_remote
     ]
@@ -141,15 +141,13 @@ module Hub
         remote = origin_remote and remote.project
       end
 
-      def upstream_project
-        if branch = current_branch and upstream = branch.upstream and upstream.remote?
-          remote = remote_by_name upstream.remote_name
-          remote.project
+      def remote_branch_and_project(username_fetcher)
+        project = main_project
+        if project and branch = current_branch
+          branch = branch.push_target(username_fetcher.call(project.host))
+          project = remote_by_name(branch.remote_name).project if branch && branch.remote?
         end
-      end
-
-      def current_project
-        upstream_project || main_project
+        [branch, project]
       end
 
       def current_branch
@@ -159,19 +157,31 @@ module Hub
       end
 
       def master_branch
-        Branch.new self, 'refs/heads/master'
+        if remote = origin_remote
+          default_branch = git_command("rev-parse --symbolic-full-name #{remote}")
+        end
+        Branch.new(self, default_branch || 'refs/heads/master')
       end
 
+      ORIGIN_NAMES = %w[ upstream github origin ]
+
       def remotes
         @remotes ||= begin
           # TODO: is there a plumbing command to get a list of remotes?
           list = git_command('remote').to_s.split("\n")
-          # force "origin" to be first in the list
-          main = list.delete('origin') and list.unshift(main)
+          list = ORIGIN_NAMES.inject([]) { |sorted, name|
+            sorted << list.delete(name)
+          }.compact.concat(list)
           list.map { |name| Remote.new self, name }
         end
       end
 
+      def remotes_for_publish(owner_name)
+        list = ORIGIN_NAMES.map {|n| remote_by_name(n) }
+        list << remotes.find {|r| p = r.project and p.owner == owner_name }
+        list.compact.uniq.reverse
+      end
+
       def remotes_group(name)
         git_config "remotes.#{name}"
       end
@@ -269,7 +279,7 @@ module Hub
       end
     end
 
-    class GithubURL < URI::HTTPS
+    class GithubURL < DelegateClass(URI::HTTP)
       extend Forwardable
 
       attr_reader :project
@@ -279,16 +289,15 @@ module Hub
       def self.resolve(url, local_repo)
         u = URI(url)
         if %[http https].include? u.scheme and project = GithubProject.from_url(u, local_repo)
-          self.new(u.scheme, u.userinfo, u.host, u.port, u.registry,
-                   u.path, u.opaque, u.query, u.fragment, project)
+          self.new(u, project)
         end
       rescue URI::InvalidURIError
         nil
       end
 
-      def initialize(*args)
-        @project = args.pop
-        super(*args)
+      def initialize(uri, project)
+        @project = project
+        super(uri)
       end
 
       # segment of path after the project owner and name
@@ -305,7 +314,10 @@ module Hub
       end
 
       def master?
-        short_name == 'master'
+        master_name = if local_repo then local_repo.master_branch.short_name
+        else 'master'
+        end
+        short_name == master_name
       end
 
       def upstream
@@ -314,6 +326,21 @@ module Hub
         end
       end
 
+      def push_target(owner_name)
+        push_default = local_repo.git_config('push.default')
+        if %w[upstream tracking].include?(push_default)
+          upstream
+        else
+          short = short_name
+          refs = local_repo.remotes_for_publish(owner_name).map { |remote|
+            "refs/remotes/#{remote}/#{short}"
+          }
+          if branch = refs.detect {|ref| local_repo.git_command("rev-parse -q --verify #{ref}") }
+            Branch.new(local_repo, branch)
+          end
+        end
+      end
+
       def remote?
         name.index('refs/remotes/') == 0
       end
@@ -431,6 +458,7 @@ module Hub
     def git_editor
       # possible: ~/bin/vi, $SOME_ENVIRONMENT_VARIABLE, "C:\Program Files\Vim\gvim.exe" --nofork
       editor = git_command 'var GIT_EDITOR'
+      editor.gsub!(/\$(\w+|\{\w+\})/) { ENV[$1.tr('{}', '')] }
       editor = ENV[$1] if editor =~ /^\$(\w+)$/
       editor = File.expand_path editor if (editor =~ /^[~.]/ or editor.index('/')) and editor !~ /["']/
       # avoid shellsplitting "C:\Program Files"
@@ -463,6 +491,11 @@ module Hub
         RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/
       end
 
+      def unix?
+        require 'rbconfig'
+        RbConfig::CONFIG['host_os'] =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+      end
+
       # Cross-platform way of finding an executable in the $PATH.
       #
       #   which('ruby') #=> /usr/bin/ruby
@@ -489,6 +522,16 @@ module Hub
       def tmp_dir
         ENV['TMPDIR'] || ENV['TEMP'] || '/tmp'
       end
+
+      def terminal_width
+        if unix?
+          width = %x{stty size 2>#{NULL}}.split[1].to_i
+          width = %x{tput cols 2>#{NULL}}.to_i if width.zero?
+        else
+          width = 0
+        end
+        width < 10 ? 78 : width
+      end
     end
 
     include System

data/lib/hub/github_api.rb

@@ -1,7 +1,4 @@
-require 'uri'
-require 'yaml'
 require 'forwardable'
-require 'fileutils'
 
 module Hub
   # Client for the GitHub v3 API.
@@ -15,7 +12,7 @@ module Hub
   #     config_file = ENV['HUB_CONFIG'] || '~/.config/hub'
   #     file_store = GitHubAPI::FileStore.new File.expand_path(config_file)
   #     file_config = GitHubAPI::Configuration.new file_store
-  #     GitHubAPI.new file_config, :app_url => 'http://defunkt.io/hub/'
+  #     GitHubAPI.new file_config, :app_url => 'http://hub.github.com/'
   #   end
   class GitHubAPI
     attr_reader :config, :oauth_app_url
@@ -25,7 +22,6 @@ module Hub
     # Options:
     # - config: an object that implements:
     #   - username(host)
-    #   - api_token(host, user)
     #   - password(host, user)
     #   - oauth_token(host, user)
     def initialize config, options
@@ -46,6 +42,19 @@ module Hub
       'github.com' == host ? 'api.github.com' : host
     end
 
+    def username_via_auth_dance host
+      host = api_host(host)
+      config.username(host) do
+        if block_given?
+          yield
+        else
+          res = get("https://%s/user" % host)
+          res.error! unless res.success?
+          config.value_to_persist(res.data['login'])
+        end
+      end
+    end
+
     # Public: Fetch data for a specific repo.
     def repo_info project
       get "https://%s/repos/%s/%s" %
@@ -66,7 +75,7 @@ module Hub
 
     # Public: Create a new project.
     def create_repo project, options = {}
-      is_org = project.owner.downcase != config.username(api_host(project.host)).downcase
+      is_org = project.owner.downcase != username_via_auth_dance(project.host).downcase
       params = { :name => project.name, :private => !!options[:private] }
       params[:description] = options[:description] if options[:description]
       params[:homepage]    = options[:homepage]    if options[:homepage]
@@ -88,6 +97,38 @@ module Hub
       res.data
     end
 
+    # Public: Fetch a pull request's patch
+    def pullrequest_patch project, pull_id
+      res = get "https://%s/repos/%s/%s/pulls/%d" %
+        [api_host(project.host), project.owner, project.name, pull_id] do |req|
+          req["Accept"] = "application/vnd.github.v3.patch"
+        end
+      res.error! unless res.success?
+      res.body
+    end
+
+    # Public: Fetch the patch from a commit
+    def commit_patch project, sha
+      res = get "https://%s/repos/%s/%s/commits/%s" %
+        [api_host(project.host), project.owner, project.name, sha] do |req|
+          req["Accept"] = "application/vnd.github.v3.patch"
+        end
+      res.error! unless res.success?
+      res.body
+    end
+
+    # Public: Fetch the first raw blob from a gist
+    def gist_raw gist_id
+      res = get("https://%s/gists/%s" % [api_host('github.com'), gist_id])
+      res.error! unless res.success?
+      raw_url = res.data['files'].values.first['raw_url']
+      res = get(raw_url) do |req|
+        req['Accept'] = 'text/plain'
+      end
+      res.error! unless res.success?
+      res.body
+    end
+
     # Returns parsed data from the new pull request.
     def create_pullrequest options
       project = options.fetch(:project)
@@ -110,12 +151,19 @@ module Hub
       res.data
     end
 
+    def statuses project, sha
+      res = get "https://%s/repos/%s/%s/statuses/%s" %
+        [api_host(project.host), project.owner, project.name, sha]
+
+      res.error! unless res.success?
+      res.data
+    end
+
     # Methods for performing HTTP requests
     #
     # Requires access to a `config` object that implements:
     # - proxy_uri(with_ssl)
     # - username(host)
-    # - update_username(host, old_username, new_username)
     # - password(host, user)
     module HttpMethods
       # Decorator for Net::HTTPResponse
@@ -180,6 +228,7 @@ module Hub
         req['User-Agent'] = "Hub #{Hub::VERSION}"
         apply_authentication(req, url)
         yield req if block_given?
+        finalize_request(req, url)
 
         begin
           res = http.start { http.request(req) }
@@ -192,7 +241,7 @@ module Hub
 
       def request_uri url
         str = url.request_uri
-        str = '/api/v3' << str if url.host != 'api.github.com'
+        str = '/api/v3' << str if url.host != 'api.github.com' && url.host != 'gist.github.com'
         str
       end
 
@@ -208,11 +257,17 @@ module Hub
       end
 
       def apply_authentication req, url
-        user = url.user || config.username(url.host)
+        user = url.user ? CGI.unescape(url.user) : config.username(url.host)
         pass = config.password(url.host, user)
         req.basic_auth user, pass
       end
 
+      def finalize_request(req, url)
+        if !req['Accept'] || req['Accept'] == '*/*'
+          req['Accept'] = 'application/vnd.github.v3+json'
+        end
+      end
+
       def create_connection url
         use_ssl = 'https' == url.scheme
 
@@ -220,7 +275,6 @@ module Hub
         if proxy = config.proxy_uri(use_ssl)
           proxy_args << proxy.host << proxy.port
           if proxy.userinfo
-            require 'cgi'
             # proxy user + password
             proxy_args.concat proxy.userinfo.split(':', 2).map {|a| CGI.unescape a }
           end
@@ -238,44 +292,59 @@ module Hub
 
     module OAuth
       def apply_authentication req, url
-        if (req.path =~ /\/authorizations$/)
+        if req.path =~ %r{^(/api/v3)?/authorizations$}
           super
         else
-          refresh = false
-          user = url.user || config.username(url.host)
+          user = url.user ? CGI.unescape(url.user) : config.username(url.host)
           token = config.oauth_token(url.host, user) {
-            refresh = true
             obtain_oauth_token url.host, user
           }
-          if refresh
-            # get current user info user to persist correctly capitalized login name
-            res = get "https://#{url.host}/user"
-            res.error! unless res.success?
-            config.update_username(url.host, user, res.data['login'])
-          end
           req['Authorization'] = "token #{token}"
         end
       end
 
-      def obtain_oauth_token host, user
+      def obtain_oauth_token host, user, two_factor_code = nil
+        auth_url = URI.parse("https://%s@%s/authorizations" % [CGI.escape(user), host])
+
+        # dummy request to trigger a 2FA SMS since a HTTP GET won't do it
+        post(auth_url) if !two_factor_code
+
         # first try to fetch existing authorization
-        res = get "https://#{user}@#{host}/authorizations"
-        res.error! unless res.success?
+        res = get(auth_url) do |req|
+          req['X-GitHub-OTP'] = two_factor_code if two_factor_code
+        end
+        unless res.success?
+          if !two_factor_code && res['X-GitHub-OTP'].to_s.include?('required')
+            two_factor_code = config.prompt_auth_code
+            return obtain_oauth_token(host, user, two_factor_code)
+          else
+            res.error!
+          end
+        end
 
         if found = res.data.find {|auth| auth['app']['url'] == oauth_app_url }
           found['token']
         else
           # create a new authorization
-          res = post "https://#{user}@#{host}/authorizations",
-            :scopes => %w[repo], :note => 'hub', :note_url => oauth_app_url
+          res = post auth_url,
+            :scopes => %w[repo], :note => 'hub', :note_url => oauth_app_url do |req|
+              req['X-GitHub-OTP'] = two_factor_code if two_factor_code
+            end
           res.error! unless res.success?
           res.data['token']
         end
       end
     end
 
+    module GistAuth
+      def apply_authentication(req, url)
+        super unless url.host == 'gist.github.com'
+      end
+    end
+
     include HttpMethods
     include OAuth
+    include GistAuth
 
     # Filesystem store suitable for Configuration
     class FileStore
@@ -286,47 +355,83 @@ module Hub
       def initialize filename
         @filename = filename
         @data = Hash.new {|d, host| d[host] = [] }
+        @persist_next_change = false
         load if File.exist? filename
       end
 
-      def fetch_user host
-        unless entry = get(host).first
-          user = yield
-          # FIXME: more elegant handling of empty strings
-          return nil if user.nil? or user.empty?
-          entry = entry_for_user(host, user)
-        end
-        entry['user']
-      end
-
       def fetch_value host, user, key
-        entry = entry_for_user host, user
-        entry[key.to_s] || begin
+        entries = get(host)
+        entries << {} if entries.empty?
+        entry = entries.first
+        entry.fetch(key.to_s) {
           value = yield
-          if value and !value.empty?
-            entry[key.to_s] = value
-            save
-            value
-          else
-            raise "no value"
-          end
-        end
+          raise "no value for key :#{key}" if value.nil? || value.empty?
+          entry[key.to_s] = value
+          save_if_needed
+          value
+        }
       end
 
-      def entry_for_user host, username
-        entries = get(host)
-        entries.find {|e| e['user'] == username } or
-          (entries << {'user' => username}).last
+      def persist_next_change!
+        @persist_next_change = true
+      end
+
+      def save_if_needed
+        @persist_next_change && save
+        @persist_next_change = false
       end
 
       def load
         existing_data = File.read(@filename)
-        @data.update YAML.load(existing_data) unless existing_data.strip.empty?
+        @data.update yaml_load(existing_data) unless existing_data.strip.empty?
       end
 
       def save
-        FileUtils.mkdir_p File.dirname(@filename)
-        File.open(@filename, 'w', 0600) {|f| f << YAML.dump(@data) }
+        mkdir_p File.dirname(@filename)
+        File.open(@filename, 'w', 0600) {|f| f << yaml_dump(@data) }
+      end
+
+      def mkdir_p(dir)
+        dir.split('/').inject do |parent, name|
+          d = File.join(parent, name)
+          Dir.mkdir(d) unless File.exist?(d)
+          d
+        end
+      end
+
+      def yaml_load(string)
+        hash = {}
+        host = nil
+        string.split("\n").each do |line|
+          case line
+          when /^---\s*$/, /^\s*(?:#|$)/
+            # ignore
+          when /^(.+):\s*$/
+            host = hash[$1] = []
+          when /^([- ]) (.+?): (.+)/
+            key, value = $2, $3
+            host << {} if $1 == '-'
+            host.last[key] = value.gsub(/^'|'$/, '')
+          else
+            raise "unsupported YAML line: #{line}"
+          end
+        end
+        hash
+      end
+
+      def yaml_dump(data)
+        yaml = ['---']
+        data.each do |host, values|
+          yaml << "#{host}:"
+          values.each do |hash|
+            dash = '-'
+            hash.each do |key, value|
+              yaml << "#{dash} #{key}: #{value}"
+              dash = ' '
+            end
+          end
+        end
+        yaml.join("\n")
       end
     end
 
@@ -347,41 +452,36 @@ module Hub
       def username host
         return ENV['GITHUB_USER'] unless ENV['GITHUB_USER'].to_s.empty?
         host = normalize_host host
-        @data.fetch_user host do
+        @data.fetch_value(host, nil, :user) do
           if block_given? then yield
           else prompt "#{host} username"
           end
         end
       end
 
-      def update_username host, old_username, new_username
-        entry = @data.entry_for_user(normalize_host(host), old_username)
-        entry['user'] = new_username
-        @data.save
-      end
-
-      def api_token host, user
-        host = normalize_host host
-        @data.fetch_value host, user, :api_token do
-          if block_given? then yield
-          else prompt "#{host} API token for #{user}"
-          end
-        end
-      end
-
       def password host, user
         return ENV['GITHUB_PASSWORD'] unless ENV['GITHUB_PASSWORD'].to_s.empty?
         host = normalize_host host
         @password_cache["#{user}@#{host}"] ||= prompt_password host, user
       end
 
-      def oauth_token host, user, &block
-        @data.fetch_value normalize_host(host), user, :oauth_token, &block
+      def oauth_token host, user
+        host = normalize_host(host)
+        @data.fetch_value(host, user, :oauth_token) do
+          value_to_persist(yield)
+        end
+      end
+
+      def value_to_persist(value = nil)
+        @data.persist_next_change!
+        value
       end
 
       def prompt what
         print "#{what}: "
         $stdin.gets.chomp
+      rescue Interrupt
+        abort
       end
 
       # special prompt that has hidden input
@@ -395,16 +495,38 @@ module Hub
           # in testing
           $stdin.gets.chomp
         end
+      rescue Interrupt
+        abort
+      end
+
+      def prompt_auth_code
+        print "two-factor authentication code: "
+        $stdin.gets.chomp
+      rescue Interrupt
+        abort
       end
 
       NULL = defined?(File::NULL) ? File::NULL :
                File.exist?('/dev/null') ? '/dev/null' : 'NUL'
 
       def askpass
+        noecho $stdin do |input|
+          input.gets.chomp
+        end
+      end
+
+      def noecho io
+        require 'io/console'
+        io.noecho { yield io }
+      rescue LoadError
+        fallback_noecho io
+      end
+
+      def fallback_noecho io
         tty_state = `stty -g 2>#{NULL}`
         system 'stty raw -echo -icanon isig' if $?.success?
         pass = ''
-        while char = getbyte($stdin) and !(char == 13 or char == 10)
+        while char = getbyte(io) and !(char == 13 or char == 10)
           if char == 127 or char == 8
             pass[-1,1] = '' unless pass.empty?
           else