hub 1.8.4 → 1.9.0

data/README.md

@@ -302,24 +302,10 @@ superpowers:
 Configuration
 -------------
 
-### GitHub username & token
+### GitHub OAuth authentication
 
-To get the most out of hub, you'll want to ensure your GitHub login
-is stored locally in your Git config or environment variables.
-
-To test it run this:
-
-    $ git config --global github.user
-
-If you see nothing, you need to set the config setting:
-
-    $ git config --global github.user YOUR_USER
-
-For commands that require write access to GitHub (such as `fork`), you'll want to
-setup "github.token" as well. See [GitHub config guide][2] for more information.
-
-If present, environment variables `GITHUB_USER` and `GITHUB_TOKEN` override the
-values of "github.user" and "github.token".
+Hub will prompt for GitHub username & password the first time it needs to access
+the API and exchange it for an OAuth token, which it saves in "~/.config/hub".
 
 ### HTTPS insted of git protocol
 
@@ -381,5 +367,4 @@ GitHub simpler:
 
 
 [speed]: http://gist.github.com/284823
-[2]: http://help.github.com/set-your-user-name-email-and-github-token/
 [gc]: https://twitter.com/brynary/status/49560668994674688

data/Rakefile

@@ -27,7 +27,7 @@ end
 # Tests
 #
 
-task :default => :test
+task :default => [:test, :features]
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
@@ -36,6 +36,10 @@ Rake::TestTask.new do |t|
   t.verbose = false
 end
 
+task :features do
+  sh 'RUBYLIB=lib cucumber -f progress -t ~@wip features'
+end
+
 #
 # Manual
 #
@@ -91,7 +95,7 @@ end
 # Build
 #
 
-file "hub" => FileList.new("lib/hub/*.rb", "man/hub.1") do |task|
+file "hub" => FileList.new("lib/hub.rb", "lib/hub/*.rb", "man/hub.1") do |task|
   Rake::Task[:load_path].invoke
   require 'hub/standalone'
   Hub::Standalone.save(task.name)

data/lib/hub.rb

@@ -1,5 +1,7 @@
 require 'hub/version'
 require 'hub/args'
+require 'hub/ssh_config'
+require 'hub/github_api'
 require 'hub/context'
 require 'hub/json'
 require 'hub/commands'

data/lib/hub/commands.rb

@@ -66,6 +66,8 @@ module Hub
       else
         raise
       end
+    rescue Context::FatalError => err
+      abort "fatal: #{err.message}"
     end
 
     # $ hub pull-request
@@ -131,7 +133,7 @@ module Hub
       options[:head] ||= (tracked_branch || current_branch).short_name
 
       # when no tracking, assume remote branch is published under active user's fork
-      user = github_user(true, head_project.host)
+      user = github_user(head_project.host)
       if head_project.owner != user and !tracked_branch and !explicit_owner
         head_project = head_project.owned_by(user)
       end
@@ -178,12 +180,12 @@ module Hub
         }
       end
 
-      pull = create_pullrequest(options)
+      pull = api_client.create_pullrequest(options)
 
       args.executable = 'echo'
       args.replace [pull['html_url']]
-    rescue HTTPExceptions
-      display_http_exception("creating pull request", $!.response)
+    rescue GitHubAPI::Exceptions
+      display_api_exception("creating pull request", $!.response)
       exit 1
     end
 
@@ -214,9 +216,9 @@ module Hub
             # FIXME: this logic shouldn't be duplicated here!
             name, owner = arg, nil
             owner, name = name.split('/', 2) if name.index('/')
-            host = ENV['GITHUB_HOST']
-            project = Context::GithubProject.new(nil, owner || github_user(true, host), name, host || 'github.com')
-            ssh ||= args[0] != 'submodule' && project.owner == github_user(false, host) || host
+            host = ENV['GITHUB_HOST'] || 'github.com'
+            project = Context::GithubProject.new(nil, owner || github_user(host), name, host)
+            ssh ||= args[0] != 'submodule' && project.owner == github_user(host) || host != 'github.com'
             args[idx] = project.git_url(:private => ssh, :https => https_protocol?)
           end
           break
@@ -319,7 +321,7 @@ module Hub
       projects = names.map { |name|
         unless name =~ /\W/ or remotes.include?(name) or remotes_group(name)
           project = github_project(nil, name)
-          project if repo_exists?(project)
+          project if api_client.repo_exists?(project)
         end
       }.compact
 
@@ -337,21 +339,18 @@ module Hub
       _, url_arg, new_branch_name = args.words
       if url = resolve_github_url(url_arg) and url.project_path =~ /^pull\/(\d+)/
         pull_id = $1
-
-        load_net_http
-        response = http_request(url.project.api_pullrequest_url(pull_id, 'json'))
-        pull_data = JSON.parse(response.body)['pull']
+        pull_data = api_client.pullrequest_info(url.project, pull_id)
 
         args.delete new_branch_name
         user, branch = pull_data['head']['label'].split(':', 2)
-        abort "Error: #{user}'s fork is not available anymore" unless pull_data['head']['repository']
+        abort "Error: #{user}'s fork is not available anymore" unless pull_data['head']['repo']
         new_branch_name ||= "#{user}-#{branch}"
 
         if remotes.include? user
           args.before ['remote', 'set-branches', '--add', user, branch]
           args.before ['fetch', user, "+refs/heads/#{branch}:refs/remotes/#{user}/#{branch}"]
         else
-          url = github_project(url.project_name, user).git_url(:private => pull_data['head']['repository']['private'],
+          url = github_project(url.project_name, user).git_url(:private => pull_data['head']['repo']['private'],
                                                                :https => https_protocol?)
           args.before ['remote', 'add', '-f', '-t', branch, user, url]
         end
@@ -426,8 +425,8 @@ module Hub
       if args.delete('-g')
         # can't use default_host because there is no local_repo yet
         # FIXME: this shouldn't be here!
-        host = ENV['GITHUB_HOST']
-        project = Context::GithubProject.new(nil, github_user(true, host), File.basename(current_dir), host || 'github.com')
+        host = ENV['GITHUB_HOST'] || 'github.com'
+        project = Context::GithubProject.new(nil, github_user(host), File.basename(current_dir), host)
         url = project.git_url(:private => true, :https => https_protocol?)
         args.after ['remote', 'add', 'origin', url]
       end
@@ -440,13 +439,13 @@ module Hub
       unless project = local_repo.main_project
         abort "Error: repository under 'origin' remote is not a GitHub project"
       end
-      forked_project = project.owned_by(github_user(true, project.host))
+      forked_project = project.owned_by(github_user(project.host))
 
-      if repo_exists?(forked_project)
+      if api_client.repo_exists?(forked_project)
         abort "Error creating fork: %s already exists on %s" %
           [ forked_project.name_with_owner, forked_project.host ]
       else
-        fork_repo(project) unless args.noop?
+        api_client.fork_repo(project) unless args.noop?
       end
 
       if args.include?('--no-remote')
@@ -456,8 +455,8 @@ module Hub
         args.replace %W"remote add -f #{forked_project.owner} #{url}"
         args.after 'echo', ['new remote:', forked_project.owner]
       end
-    rescue HTTPExceptions
-      display_http_exception("creating fork", $!.response)
+    rescue GitHubAPI::Exceptions
+      display_api_exception("creating fork", $!.response)
       exit 1
     end
 
@@ -467,7 +466,7 @@ module Hub
     def create(args)
       if !is_repo?
         abort "'create' must be run from inside a git repository"
-      elsif owner = github_user and github_token
+      elsif owner = github_user
         args.shift
         options = {}
         options[:private] = true if args.delete('-p')
@@ -491,12 +490,12 @@ module Hub
         new_repo_name ||= repo_name
         new_project = github_project(new_repo_name, owner)
 
-        if repo_exists?(new_project)
+        if api_client.repo_exists?(new_project)
           warn "#{new_project.name_with_owner} already exists on #{new_project.host}"
           action = "set remote origin"
         else
           action = "created repository"
-          create_repo(new_project, options) unless args.noop?
+          api_client.create_repo(new_project, options) unless args.noop?
         end
 
         url = new_project.git_url(:private => true, :https => https_protocol?)
@@ -509,8 +508,8 @@ module Hub
 
         args.after 'echo', ["#{action}:", new_project.name_with_owner]
       end
-    rescue HTTPExceptions
-      display_http_exception("creating repository", $!.response)
+    rescue GitHubAPI::Exceptions
+      display_api_exception("creating repository", $!.response)
       exit 1
     end
 
@@ -618,10 +617,12 @@ module Hub
     def hub(args)
       return help(args) unless args[1] == 'standalone'
       require 'hub/standalone'
-      $stdout.puts Hub::Standalone.build
+      Hub::Standalone.build $stdout
       exit
     rescue LoadError
-      abort "hub is running in standalone mode."
+      abort "hub is already running in standalone mode."
+    rescue Errno::EPIPE
+      exit # ignore broken pipe
     end
 
     def alias(args)
@@ -692,6 +693,21 @@ module Hub
     # from the command line.
     #
 
+    def api_client
+      @api_client ||= begin
+        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/'
+      end
+    end
+
+    def github_user host = nil
+      host ||= local_repo(false) && local_repo.main_host
+      return nil if host.nil?
+      api_client.config.username(host) { }
+    end
+
     def custom_command? cmd
       CUSTOM_COMMANDS.include? cmd
     end
@@ -898,53 +914,6 @@ help
       end
     end
 
-    # Determines whether a user has a fork of the current repo on GitHub.
-    def repo_exists?(project)
-      load_net_http
-      Net::HTTPSuccess === http_request(project.api_show_url('yaml'))
-    end
-
-    # Forks the current repo using the GitHub API.
-    #
-    # Returns nothing.
-    def fork_repo(project)
-      load_net_http
-      response = http_post project.api_fork_url('yaml')
-      response.error! unless Net::HTTPSuccess === response
-    end
-
-    # Creates a new repo using the GitHub API.
-    #
-    # Returns nothing.
-    def create_repo(project, options = {})
-      is_org = project.owner != github_user(true, project.host)
-      params = {'name' => is_org ? project.name_with_owner : project.name}
-      params['public'] = '0' if options[:private]
-      params['description'] = options[:description] if options[:description]
-      params['homepage'] = options[:homepage] if options[:homepage]
-
-      load_net_http
-      response = http_post(project.api_create_url('json'), params)
-      response.error! unless Net::HTTPSuccess === response
-    end
-
-    # Returns parsed data from the new pull request.
-    def create_pullrequest(options)
-      project = options.fetch(:project)
-      params = {
-        'pull[base]' => options.fetch(:base),
-        'pull[head]' => options.fetch(:head)
-      }
-      params['pull[issue]'] = options[:issue] if options[:issue]
-      params['pull[title]'] = options[:title] if options[:title]
-      params['pull[body]'] = options[:body] if options[:body]
-
-      load_net_http
-      response = http_post(project.api_create_pullrequest_url('json'), params)
-      response.error! unless Net::HTTPSuccess === response
-      JSON.parse(response.body)['pull']
-    end
-
     def pullrequest_editmsg(changes)
       message_file = File.join(git_dir, 'PULLREQ_EDITMSG')
       File.open(message_file, 'w') { |msg|
@@ -988,86 +957,13 @@ help
       end
     end
 
-    def http_request(url, type = :Get)
-      url = URI(url) unless url.respond_to? :host
-      user, token = github_user(type != :Get, url.host), github_token(type != :Get, url.host)
-
-      req = Net::HTTP.const_get(type).new(url.request_uri)
-      req.basic_auth "#{user}/token", token if user and token
-
-      http = setup_http(url)
-
-      yield req if block_given?
-      http.start { http.request(req) }
-    end
-
-    def http_post(url, params = nil)
-      http_request(url, :Post) do |req|
-        req.set_form_data params if params
-        req['Content-Length'] = req.body ? req.body.length : 0
-      end
-    end
-
-    def setup_http(url)
-      port = url.port
-      if use_ssl = 'https' == url.scheme and not use_ssl?
-        # ruby compiled without openssl
-        use_ssl = false
-        port = 80
-      end
-
-      http_args = [url.host, port]
-      if proxy = proxy_url(use_ssl)
-        http_args.concat proxy.select(:host, :port)
-        if proxy.userinfo
-          require 'cgi'
-          http_args.concat proxy.userinfo.split(':', 2).map {|a| CGI.unescape a }
-        end
-      end
-
-      http = Net::HTTP.new(*http_args)
-
-      if http.use_ssl = use_ssl
-        # TODO: SSL peer verification
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      return http
-    end
-
-    def load_net_http
-      require 'net/https'
-    rescue LoadError
-      require 'net/http'
-    end
-
-    def use_ssl?
-      defined? ::OpenSSL
-    end
-
-    def proxy_url(use_ssl)
-      env_name = "HTTP#{use_ssl ? 'S' : ''}_PROXY"
-      if proxy = ENV[env_name] || ENV[env_name.downcase]
-        proxy = "http://#{proxy}" unless proxy.include? '://'
-        URI.parse(proxy)
-      end
-    end
-
-    # Fake exception type for net/http exception handling.
-    # Necessary because net/http may or may not be loaded at the time.
-    module HTTPExceptions
-      def self.===(exception)
-        exception.class.ancestors.map {|a| a.to_s }.include? 'Net::HTTPExceptions'
-      end
-    end
-
-    def display_http_exception(action, response)
-      $stderr.puts "Error #{action}: #{response.message} (HTTP #{response.code})"
-      case response.code.to_i
-      when 401 then warn "Check your token configuration (`git config github.token`)"
-      when 422
-        if response.content_type =~ /\bjson\b/ and data = JSON.parse(response.body) and data["error"]
-          $stderr.puts data["error"]
-        end
+    def display_api_exception(action, response)
+      $stderr.puts "Error #{action}: #{response.message} (HTTP #{response.status})"
+      if 422 == response.status and response.error_message?
+        # display validation errors
+        msg = response.error_message
+        msg = msg.join("\n") if msg.respond_to? :join
+        warn msg
       end
     end
 

data/lib/hub/context.rb

@@ -3,8 +3,8 @@ require 'forwardable'
 require 'uri'
 
 module Hub
-  # Provides methods for inspecting the environment, such as GitHub user/token
-  # settings, repository info, and similar.
+  # Methods for inspecting the environment, such as reading git config,
+  # repository info, and other.
   module Context
     extend Forwardable
 
@@ -75,6 +75,9 @@ module Hub
       end
     end
 
+    class Error < RuntimeError; end
+    class FatalError < Error; end
+
     private
 
     def git_reader
@@ -89,7 +92,7 @@ module Hub
         if is_repo?
           LocalRepo.new git_reader, current_dir
         elsif fatal
-          abort "fatal: Not a git repository"
+          raise FatalError, "Not a git repository"
         end
       end
     end
@@ -243,30 +246,6 @@ module Hub
         else "git://#{host}/"
         end + name_with_owner + '.git'
       end
-
-      def api_url(type, resource, action)
-        URI("https://#{host}/api/v2/#{type}/#{resource}/#{action}")
-      end
-
-      def api_show_url(type)
-        api_url(type, 'repos', "show/#{owner}/#{name}")
-      end
-
-      def api_fork_url(type)
-        api_url(type, 'repos', "fork/#{owner}/#{name}")
-      end
-
-      def api_create_url(type)
-        api_url(type, 'repos', 'create')
-      end
-
-      def api_pullrequest_url(id, type)
-        api_url(type, 'pulls', "#{owner}/#{name}/#{id}")
-      end
-
-      def api_create_pullrequest_url(type)
-        api_url(type, 'pulls', "#{owner}/#{name}")
-      end
     end
 
     class GithubURL < URI::HTTPS
@@ -320,7 +299,7 @@ module Hub
 
       def remote_name
         name =~ %r{^refs/remotes/([^/]+)} and $1 or
-          raise "can't get remote name from #{name.inspect}"
+          raise Error, "can't get remote name from #{name.inspect}"
       end
     end
 
@@ -391,44 +370,6 @@ module Hub
       GithubURL.resolve(url, local_repo) if url =~ /^https?:/
     end
 
-    LGHCONF = "http://help.github.com/set-your-user-name-email-and-github-token/"
-
-    # Either returns the GitHub user as set by git-config(1) or aborts
-    # with an error message.
-    def github_user(fatal = true, host = nil)
-      if local = local_repo(false)
-        host ||= local.default_host
-        host = nil if host == local.main_host
-      end
-      host = %(."#{host}") if host
-      if user = ENV['GITHUB_USER'] || git_config("github#{host}.user")
-        user
-      elsif fatal
-        if host.nil?
-          abort("** No GitHub user set. See #{LGHCONF}")
-        else
-          abort("** No user set for github#{host}")
-        end
-      end
-    end
-
-    def github_token(fatal = true, host = nil)
-      if local = local_repo(false)
-        host ||= local.default_host
-        host = nil if host == local.main_host
-      end
-      host = %(."#{host}") if host
-      if token = ENV['GITHUB_TOKEN'] || git_config("github#{host}.token")
-        token
-      elsif fatal
-        if host.nil?
-          abort("** No GitHub token set. See #{LGHCONF}")
-        else
-          abort("** No token set for github#{host}")
-        end
-      end
-    end
-
     # legacy setting
     def http_clone?
       git_config('--bool hub.http-clone') == 'true'
@@ -468,136 +409,55 @@ module Hub
       editor.shellsplit
     end
 
-    # Cross-platform web browser command; respects the value set in $BROWSER.
-    # 
-    # Returns an array, e.g.: ['open']
-    def browser_launcher
-      browser = ENV['BROWSER'] || (
-        osx? ? 'open' : windows? ? 'start' :
-        %w[xdg-open cygstart x-www-browser firefox opera mozilla netscape].find { |comm| which comm }
-      )
-
-      abort "Please set $BROWSER to a web launcher to use this command." unless browser
-      Array(browser)
-    end
-
-    def osx?
-      require 'rbconfig'
-      RbConfig::CONFIG['host_os'].to_s.include?('darwin')
-    end
+    module System
+      # Cross-platform web browser command; respects the value set in $BROWSER.
+      # 
+      # Returns an array, e.g.: ['open']
+      def browser_launcher
+        browser = ENV['BROWSER'] || (
+          osx? ? 'open' : windows? ? 'start' :
+          %w[xdg-open cygstart x-www-browser firefox opera mozilla netscape].find { |comm| which comm }
+        )
 
-    def windows?
-      require 'rbconfig'
-      RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/
-    end
-
-    # Cross-platform way of finding an executable in the $PATH.
-    #
-    #   which('ruby') #=> /usr/bin/ruby
-    def which(cmd)
-      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-        exts.each { |ext|
-          exe = "#{path}/#{cmd}#{ext}"
-          return exe if File.executable? exe
-        }
+        abort "Please set $BROWSER to a web launcher to use this command." unless browser
+        Array(browser)
       end
-      return nil
-    end
 
-    # Checks whether a command exists on this system in the $PATH.
-    #
-    # name - The String name of the command to check for.
-    #
-    # Returns a Boolean.
-    def command?(name)
-      !which(name).nil?
-    end
-
-    class SshConfig
-      CONFIG_FILES = %w(~/.ssh/config /etc/ssh_config /etc/ssh/ssh_config)
-
-      def initialize files = nil
-        @settings = Hash.new {|h,k| h[k] = {} }
-        Array(files || CONFIG_FILES).each do |path|
-          file = File.expand_path path
-          parse_file file if File.exist? file
-        end
+      def osx?
+        require 'rbconfig'
+        RbConfig::CONFIG['host_os'].to_s.include?('darwin')
       end
 
-      # yields if not found
-      def get_value hostname, key
-        key = key.to_s.downcase
-        @settings.each do |pattern, settings|
-          if pattern.match? hostname and found = settings[key]
-            return found
-          end
-        end
-        yield
-      end
-
-      class HostPattern
-        def initialize pattern
-          @pattern = pattern.to_s.downcase
-        end
-
-        def to_s() @pattern end
-        def ==(other) other.to_s == self.to_s end
-
-        def matcher
-          @matcher ||=
-            if '*' == @pattern
-              Proc.new { true }
-            elsif @pattern !~ /[?*]/
-              lambda { |hostname| hostname.to_s.downcase == @pattern }
-            else
-              re = self.class.pattern_to_regexp @pattern
-              lambda { |hostname| re =~ hostname }
-            end
-        end
-
-        def match? hostname
-          matcher.call hostname
-        end
-
-        def self.pattern_to_regexp pattern
-          escaped = Regexp.escape(pattern)
-          escaped.gsub!('\*', '.*')
-          escaped.gsub!('\?', '.')
-          /^#{escaped}$/i
-        end
+      def windows?
+        require 'rbconfig'
+        RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/
       end
 
-      def parse_file file
-        host_patterns = [HostPattern.new('*')]
-
-        IO.foreach(file) do |line|
-          case line
-          when /^\s*(#|$)/ then next
-          when /^\s*(\S+)\s*=/
-            key, value = $1, $'
-          else
-            key, value = line.strip.split(/\s+/, 2)
-          end
-
-          next if value.nil?
-          key.downcase!
-          value = $1 if value =~ /^"(.*)"$/
-          value.chomp!
-
-          if 'host' == key
-            host_patterns = value.split(/\s+/).map {|p| HostPattern.new p }
-          else
-            record_setting key, value, host_patterns
-          end
+      # Cross-platform way of finding an executable in the $PATH.
+      #
+      #   which('ruby') #=> /usr/bin/ruby
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each { |ext|
+            exe = "#{path}/#{cmd}#{ext}"
+            return exe if File.executable? exe
+          }
         end
+        return nil
       end
 
-      def record_setting key, value, patterns
-        patterns.each do |pattern|
-          @settings[pattern][key] ||= value
-        end
+      # Checks whether a command exists on this system in the $PATH.
+      #
+      # name - The String name of the command to check for.
+      #
+      # Returns a Boolean.
+      def command?(name)
+        !which(name).nil?
       end
     end
+
+    include System
+    extend System
   end
 end