git-hub 1.5.1 → 1.6.0

data/Rakefile

@@ -1,104 +0,0 @@
-require 'rake/testtask'
-
-#
-# Helpers
-#
-
-def command?(command)
-  `which #{command} 2>/dev/null`
-  $?.success?
-end
-
-task :load_hub do
-  $LOAD_PATH.unshift 'lib'
-  require 'hub'
-end
-
-task :check_dirty do
-  if !`git status`.include?('nothing to commit')
-    abort "dirty index - not publishing!"
-  end
-end
-
-
-#
-# Tests
-#
-
-task :default => :test
-
-if command? :turn
-  desc "Run tests"
-  task :test do
-    suffix = "-n #{ENV['TEST']}" if ENV['TEST']
-    sh "turn test/*.rb #{suffix}"
-  end
-else
-  Rake::TestTask.new do |t|
-    t.libs << 'lib'
-    t.ruby_opts << '-rubygems'
-    t.pattern = 'test/**/*_test.rb'
-    t.verbose = false
-  end
-end
-
-if command? :kicker
-  desc "Launch Kicker (like autotest)"
-  task :kicker do
-    puts "Kicking... (ctrl+c to cancel)"
-    exec "kicker -e rake test lib"
-  end
-end
-
-
-#
-# Ron
-#
-
-if command? :ronn
-  desc "Show the manual"
-  task :man => "man:build" do
-    exec "man man/hub.1"
-  end
-
-  desc "Build the manual"
-  task "man:build" do
-    sh "ronn -br5 --organization=DEFUNKT --manual='Git Manual' man/*.ronn"
-  end
-end
-
-
-#
-# Gems
-#
-
-desc "Build standalone script"
-task :standalone => :load_hub do
-  require 'hub/standalone'
-  Hub::Standalone.save('hub')
-end
-
-desc "Install standalone script and man pages"
-task :install => :standalone do
-  prefix = ENV['PREFIX'] || ENV['prefix'] || '/usr/local'
-
-  FileUtils.mkdir_p "#{prefix}/bin"
-  FileUtils.cp "hub", "#{prefix}/bin"
-
-  FileUtils.mkdir_p "#{prefix}/share/man/man1"
-  FileUtils.cp "man/hub.1", "#{prefix}/share/man/man1"
-end
-
-desc "Publish to GitHub Pages"
-task :pages => [ "man:build", :check_dirty, :standalone ] do
-  cp "man/hub.1.html", "html"
-  sh "git checkout gh-pages"
-  sh "mv hub standalone"
-  sh "git add standalone*"
-  sh "mv html hub.1.html"
-  sh "git add hub.1.html"
-  sh "git commit -m 'update standalone'"
-  sh "git push origin gh-pages"
-  sh "git checkout master"
-  puts :done
-end

data/bin/hub

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-# hub(1)
-# alias git=hub
-
-require 'hub'
-Hub::Runner.execute(*ARGV)

data/lib/hub.rb

@@ -1,5 +0,0 @@
-require 'hub/version'
-require 'hub/args'
-require 'hub/context'
-require 'hub/commands'
-require 'hub/runner'

data/lib/hub/args.rb

@@ -1,99 +0,0 @@
-module Hub
-  # The Args class exists to make it more convenient to work with
-  # command line arguments intended for git from within the Hub
-  # codebase.
-  #
-  # The ARGV array is converted into an Args instance by the Hub
-  # instance when instantiated.
-  class Args < Array
-    attr_accessor :executable
-
-    def initialize(*args)
-      super
-      @executable = ENV["GIT"] || "git"
-      @after = nil
-      @skip = false
-      @original_args = args.first
-      @chain = [nil]
-    end
-
-    # Adds an `after` callback.
-    # A callback can be a command or a proc.
-    def after(cmd_or_args = nil, args = nil, &block)
-      @chain.insert(-1, normalize_callback(cmd_or_args, args, block))
-    end
-
-    # Adds a `before` callback.
-    # A callback can be a command or a proc.
-    def before(cmd_or_args = nil, args = nil, &block)
-      @chain.insert(@chain.index(nil), normalize_callback(cmd_or_args, args, block))
-    end
-
-    # Tells if there are multiple (chained) commands or not.
-    def chained?
-      @chain.size > 1
-    end
-
-    # Returns an array of all commands.
-    def commands
-      chain = @chain.dup
-      chain[chain.index(nil)] = self.to_exec
-      chain
-    end
-
-    # Skip running this command.
-    def skip!
-      @skip ||= true
-    end
-    
-    # Boolean indicating whether this command will run.
-    def skip?
-      @skip
-    end
-
-    # Array of `executable` followed by all args suitable as arguments
-    # for `exec` or `system` calls.
-    def to_exec(args = self)
-      [executable].concat args
-    end
-
-    # All the words (as opposed to flags) contained in this argument
-    # list.
-    #
-    # args = Args.new([ 'remote', 'add', '-f', 'tekkub' ])
-    # args.words == [ 'remote', 'add', 'tekkub' ]
-    def words
-      reject { |arg| arg.index('-') == 0 }
-    end
-
-    # All the flags (as opposed to words) contained in this argument
-    # list.
-    #
-    # args = Args.new([ 'remote', 'add', '-f', 'tekkub' ])
-    # args.flags == [ '-f' ]
-    def flags
-      self - words
-    end
-
-    # Tests if arguments were modified since instantiation
-    def changed?
-      chained? or self != @original_args
-    end
-
-    private
-
-    def normalize_callback(cmd_or_args, args, block)
-      if block
-        block
-      elsif args
-        [cmd_or_args].concat args
-      elsif Array === cmd_or_args
-        self.to_exec cmd_or_args
-      elsif cmd_or_args
-        cmd_or_args
-      else
-        raise ArgumentError, "command or block required"
-      end
-    end
-  end
-end

data/lib/hub/commands.rb

@@ -1,716 +0,0 @@
-module Hub
-  # See context.rb
-  module Context; end
-
-  # The Commands module houses the git commands that hub
-  # lovingly wraps. If a method exists here, it is expected to have a
-  # corresponding git command which either gets run before or after
-  # the method executes.
-  #
-  # The typical flow is as follows:
-  #
-  # 1. hub is invoked from the command line:
-  #    $ hub clone rtomayko/tilt
-  #
-  # 2. The Hub class is initialized:
-  #    >> hub = Hub.new('clone', 'rtomayko/tilt')
-  #
-  # 3. The method representing the git subcommand is executed with the
-  #    full args:
-  #    >> Commands.clone('clone', 'rtomayko/tilt')
-  #
-  # 4. That method rewrites the args as it sees fit:
-  #    >> args[1] = "git://github.com/" + args[1] + ".git"
-  #    => "git://github.com/rtomayko/tilt.git"
-  #
-  # 5. The new args are used to run `git`:
-  #    >> exec "git", "clone", "git://github.com/rtomayko/tilt.git"
-  #
-  # An optional `after` callback can be set. If so, it is run after
-  # step 5 (which then performs a `system` call rather than an
-  # `exec`). See `Hub::Args` for more information on the `after` callback.
-  module Commands
-    # We are a blank slate.
-    instance_methods.each { |m| undef_method(m) unless m =~ /(^__|send|to\?$)/ }
-    extend self
-
-    # Provides `github_url` and various inspection methods
-    extend Context
-
-    API_REPO   = 'http://github.com/api/v2/yaml/repos/show/%s/%s'
-    API_FORK   = 'http://github.com/api/v2/yaml/repos/fork/%s/%s'
-    API_CREATE = 'http://github.com/api/v2/yaml/repos/create'
-
-    def run(args)
-      # Hack to emulate git-style
-      args.unshift 'help' if args.grep(/^[^-]|version|exec-path$|html-path/).empty?
-
-      cmd = args[0]
-      expanded_args = expand_alias(cmd)
-      cmd = expanded_args[0] if expanded_args
-
-      # git commands can have dashes
-      cmd = cmd.sub(/(\w)-/, '\1_')
-      if method_defined?(cmd) and cmd != 'run'
-        args[0, 1] = expanded_args if expanded_args
-        send(cmd, args)
-      end
-    end
-
-    # $ hub clone rtomayko/tilt
-    # > git clone git://github.com/rtomayko/tilt.
-    #
-    # $ hub clone -p kneath/hemingway
-    # > git clone git@github.com:kneath/hemingway.git
-    #
-    # $ hub clone tilt
-    # > git clone git://github.com/YOUR_LOGIN/tilt.
-    #
-    # $ hub clone -p github
-    # > git clone git@github.com:YOUR_LOGIN/hemingway.git
-    def clone(args)
-      ssh = args.delete('-p')
-      has_values = /^(--(upload-pack|template|depth|origin|branch|reference)|-[ubo])$/
-      
-      idx = 1
-      while idx < args.length
-        arg = args[idx]
-        if arg.index('-') == 0
-          idx += 1 if arg =~ has_values
-        elsif arg.index('://') or arg.index('@') or File.directory?(arg)
-          # Bail out early for URLs and local paths.
-          break
-        elsif arg.scan('/').size <= 1 && !arg.include?(':')
-          # $ hub clone rtomayko/tilt
-          # $ hub clone tilt
-          args[args.index(arg)] = github_url(:repo => arg, :private => ssh)
-          break
-        end
-        idx += 1
-      end
-    end
-
-    # $ hub submodule add wycats/bundler vendor/bundler
-    # > git submodule add git://github.com/wycats/bundler.git vendor/bundler
-    #
-    # $ hub submodule add -p wycats/bundler vendor/bundler
-    # > git submodule add git@github.com:wycats/bundler.git vendor/bundler
-    #
-    # $ hub submodule add -b ryppl ryppl/pip vendor/bundler
-    # > git submodule add -b ryppl git://github.com/ryppl/pip.git vendor/pip
-    def submodule(args)
-      return unless index = args.index('add')
-      args.delete_at index
-
-      branch = args.index('-b') || args.index('--branch')
-      if branch
-        args.delete_at branch
-        branch_name = args.delete_at branch
-      end
-
-      clone(args)
-
-      if branch_name
-        args.insert branch, '-b', branch_name
-      end
-      args.insert index, 'add'
-    end
-
-    # $ hub remote add pjhyett
-    # > git remote add pjhyett git://github.com/pjhyett/THIS_REPO.git
-    #
-    # $ hub remote add -p mojombo
-    # > git remote add mojombo git@github.com:mojombo/THIS_REPO.git
-    #
-    # $ hub remote add origin
-    # > git remote add origin git://github.com/YOUR_LOGIN/THIS_REPO.git
-    def remote(args)
-      return unless ['add','set-url'].include?(args[1]) && args.last !~ %r{.+?://|.+?@|^[./]}
-
-      ssh = args.delete('-p')
-
-      # user/repo
-      args.last =~ /\b(.+?)(?:\/(.+))?$/
-      user, repo = $1, $2
-
-      if args.words[2] == 'origin' && args.words[3].nil?
-        # Origin special case triggers default user/repo
-        user = repo = nil
-      elsif args.words[-2] == args.words[1]
-        # rtomayko/tilt => rtomayko
-        # Make sure you dance around flags.
-        idx = args.index( args.words[-1] )
-        args[idx] = user
-      else
-        # They're specifying the remote name manually (e.g.
-        # git remote add blah rtomayko/tilt), so just drop the last
-        # argument.
-        args.replace args[0...-1]
-      end
-
-      args << github_url(:user => user, :repo => repo, :private => ssh)
-    end
-
-    # $ hub fetch mislav
-    # > git remote add mislav git://github.com/mislav/REPO.git
-    # > git fetch mislav
-    #
-    # $ hub fetch --multiple mislav xoebus
-    # > git remote add mislav ...
-    # > git remote add xoebus ...
-    # > git fetch --multiple mislav xoebus
-    def fetch(args)
-      # $ hub fetch --multiple <name1>, <name2>, ...
-      if args.include?('--multiple')
-        names = args.words[1..-1]
-      # $ hub fetch <name>
-      elsif remote_name = args.words[1]
-        # $ hub fetch <name1>,<name2>,...
-        if remote_name =~ /^\w+(,\w+)+$/
-          index = args.index(remote_name)
-          args.delete(remote_name)
-          names = remote_name.split(',')
-          args.insert(index, *names)
-          args.insert(index, '--multiple')
-        else
-          names = [remote_name]
-        end
-      else
-        names = []
-      end
-
-      names.reject! { |name|
-        name =~ /\W/ or remotes.include?(name) or
-          remotes_group(name) or not repo_exists?(name)
-      }
-
-      if names.any?
-        names.each do |name|
-          args.before ['remote', 'add', name, github_url(:user => name)]
-        end
-      end
-    end
-
-    # $ git cherry-pick http://github.com/mislav/hub/commit/a319d88#comments
-    # > git remote add -f mislav git://github.com/mislav/hub.git
-    # > git cherry-pick a319d88
-    #
-    # $ git cherry-pick mislav@a319d88
-    # > git remote add -f mislav git://github.com/mislav/hub.git
-    # > git cherry-pick a319d88
-    #
-    # $ git cherry-pick mislav@SHA
-    # > git fetch mislav
-    # > git cherry-pick SHA
-    def cherry_pick(args)
-      unless args.include?('-m') or args.include?('--mainline')
-        case ref = args.words.last
-        when %r{^(?:https?:)//github.com/(.+?)/(.+?)/commit/([a-f0-9]{7,40})}
-          user, repo, sha = $1, $2, $3
-          args[args.index(ref)] = sha
-        when /^(\w+)@([a-f1-9]{7,40})$/
-          user, repo, sha = $1, nil, $2
-          args[args.index(ref)] = sha
-        else
-          user = nil
-        end
-
-        if user
-          if user == repo_owner
-            # fetch from origin if the repo belongs to the user
-            args.before ['fetch', default_remote]
-          elsif remotes.include?(user)
-            args.before ['fetch', user]
-          else
-            remote_url = github_url(:user => user, :repo => repo, :private => false)
-            args.before ['remote', 'add', '-f', user, remote_url]
-          end
-        end
-      end
-    end
-
-    # $ hub am https://github.com/defunkt/hub/pull/55
-    # > curl https://github.com/defunkt/hub/pull/55.patch -o /tmp/55.patch
-    # > git am /tmp/55.patch
-    def am(args)
-      if url = args.find { |a| a =~ %r{^https?://(gist\.)?github\.com/} }
-        idx = args.index(url)
-        gist = $1 == 'gist.'
-        ext = gist ? '.txt' : '.patch'
-        url += ext unless File.extname(url) == ext
-        patch_file = File.join(ENV['TMPDIR'], "#{gist ? 'gist-' : ''}#{File.basename(url)}")
-        args.before 'curl', ['-#LA', "hub #{Hub::Version}", url, '-o', patch_file]
-        args[idx] = patch_file
-      end
-    end
-
-    # $ hub init -g
-    # > git init
-    # > git remote add origin git@github.com:USER/REPO.git
-    def init(args)
-      if args.delete('-g')
-        url = github_url(:private => true, :repo => current_dirname)
-        args.after "git remote add origin #{url}"
-      end
-    end
-
-    # $ hub fork
-    # ... hardcore forking action ...
-    # > git remote add -f YOUR_USER git@github.com:YOUR_USER/CURRENT_REPO.git
-    def fork(args)
-      # can't do anything without token and original owner name
-      if github_user && github_token && repo_owner
-        if repo_exists?(github_user)
-          puts "#{github_user}/#{repo_name} already exists on GitHub"
-        else
-          fork_repo
-        end
-
-        if args.include?('--no-remote')
-          exit
-        else
-          url = github_url(:private => true)
-          args.replace %W"remote add -f #{github_user} #{url}"
-          args.after { puts "new remote: #{github_user}" }
-        end
-      end
-    rescue Net::HTTPExceptions
-      response = $!.response
-      warn "error creating fork: #{response.message} (HTTP #{response.code})"
-      exit 1
-    end
-
-    # $ hub create
-    # ... create repo on github ...
-    # > git remote add -f origin git@github.com:YOUR_USER/CURRENT_REPO.git
-    def create(args)
-      if !is_repo?
-        puts "'create' must be run from inside a git repository"
-        args.skip!
-      elsif github_user && github_token
-        args.shift
-        options = {}
-        options[:private] = true if args.delete('-p')
-
-        until args.empty?
-          case arg = args.shift
-          when '-d'
-            options[:description] = args.shift
-          when '-h'
-            options[:homepage] = args.shift
-          else
-            puts "unexpected argument: #{arg}"
-            return
-          end
-        end
-
-        if repo_exists?(github_user)
-          puts "#{github_user}/#{repo_name} already exists on GitHub"
-          action = "set remote origin"
-        else
-          action = "created repository"
-          create_repo(options)
-        end
-
-        url = github_url(:private => true)
-
-        if remotes.first != 'origin'
-          args.replace %W"remote add -f origin #{url}"
-        else
-          args.replace %W"remote -v"
-        end
-
-        args.after { puts "#{action}: #{github_user}/#{repo_name}" }
-      end
-    rescue Net::HTTPExceptions
-      response = $!.response
-      warn "error creating repository: #{response.message} (HTTP #{response.code})"
-      exit 1
-    end
-
-    # $ hub push origin,staging cool-feature
-    # > git push origin cool-feature
-    # > git push staging cool-feature
-    def push(args)
-      return unless args[1] =~ /,/
-
-      branch  = args[2]
-      remotes = args[1].split(',')
-      args[1] = remotes.shift
-
-      remotes.each do |name|
-        args.after ['push', name, branch]
-      end
-    end
-
-    # $ hub browse
-    # > open https://github.com/CURRENT_REPO
-    #
-    # $ hub browse -- issues
-    # > open https://github.com/CURRENT_REPO/issues
-    #
-    # $ hub browse pjhyett/github-services
-    # > open https://github.com/pjhyett/github-services
-    #
-    # $ hub browse github-services
-    # > open https://github.com/YOUR_LOGIN/github-services
-    #
-    # $ hub browse github-services wiki
-    # > open https://github.com/YOUR_LOGIN/github-services/wiki
-    def browse(args)
-      args.shift
-      browse_command(args) do
-        user = repo = nil
-        dest = args.shift
-        dest = nil if dest == '--'
-
-        if dest
-          # $ hub browse pjhyett/github-services
-          # $ hub browse github-services
-          repo = dest
-        elsif repo_user
-          # $ hub browse
-          user = repo_user
-        else
-          abort "Usage: hub browse [<USER>/]<REPOSITORY>"
-        end
-
-        params = { :user => user, :repo => repo }
-
-        # $ hub browse -- wiki
-        case subpage = args.shift
-        when 'commits'
-          branch = (!dest && tracked_branch) || 'master'
-          params[:web] = "/commits/#{branch}"
-        when 'tree', NilClass
-          branch = !dest && tracked_branch
-          params[:web] = "/tree/#{branch}" if branch && branch != 'master'
-        else
-          params[:web] = "/#{subpage}"
-        end
-
-        params
-      end
-    end
-
-    # $ hub compare 1.0...fix
-    # > open https://github.com/CURRENT_REPO/compare/1.0...fix
-    # $ hub compare refactor
-    # > open https://github.com/CURRENT_REPO/compare/refactor
-    # $ hub compare myfork feature
-    # > open https://github.com/myfork/REPO/compare/feature
-    # $ hub compare -u 1.0...2.0
-    # "https://github.com/CURRENT_REPO/compare/1.0...2.0"
-    def compare(args)
-      args.shift
-      browse_command(args) do
-        if args.empty?
-          branch = tracked_branch
-          if branch && branch != 'master'
-            range, user = branch, repo_user
-          else
-            abort "Usage: hub compare [USER] [<START>...]<END>"
-          end
-        else
-          range = args.pop
-          user = args.pop || repo_user
-        end
-        { :user => user, :web => "/compare/#{range}" }
-      end
-    end
-
-    # $ hub hub standalone
-    # Prints the "standalone" version of hub for an easy, memorable
-    # installation sequence:
-    #
-    # $ gem install git-hub
-    # $ hub hub standalone > ~/bin/hub && chmod 755 ~/bin/hub
-    # $ gem uninstall git-hub
-    def hub(args)
-      return help(args) unless args[1] == 'standalone'
-      require 'hub/standalone'
-      puts Hub::Standalone.build
-      exit
-    rescue LoadError
-      abort "hub is running in standalone mode."
-    end
-
-    def alias(args)
-      shells = {
-        'sh'   => 'alias git=hub',
-        'bash' => 'alias git=hub',
-        'zsh'  => 'function git(){hub "$@"}',
-        'csh'  => 'alias git hub',
-        'fish' => 'alias git hub'
-      }
-
-      silent = args.delete('-s')
-
-      if shell = args[1]
-        if silent.nil?
-          puts "Run this in your shell to start using `hub` as `git`:"
-          print "  "
-        end
-      else
-        puts "usage: hub alias [-s] SHELL", ""
-        puts "You already have hub installed and available in your PATH,"
-        puts "but to get the full experience you'll want to alias it to"
-        puts "`git`.", ""
-        puts "To see how to accomplish this for your shell, run the alias"
-        puts "command again with the name of your shell.", ""
-        puts "Known shells:"
-        shells.map { |key, _| key }.sort.each do |key|
-          puts "  " + key
-        end
-        puts "", "Options:"
-        puts "  -s   Silent. Useful when using the output with eval, e.g."
-        puts "       $ eval `hub alias -s bash`"
-
-        exit
-      end
-
-      if shells[shell]
-        puts shells[shell]
-      else
-        abort "fatal: never heard of `#{shell}'"
-      end
-
-      exit
-    end
-
-    # $ hub version
-    # > git version
-    # (print hub version)
-    def version(args)
-      args.after do
-        puts "hub version %s" % Version
-      end
-    end
-    alias_method "--version", :version
-
-    # $ hub help
-    # (print improved help text)
-    def help(args)
-      command = args.grep(/^[^-]/)[1]
-
-      if command == 'hub'
-        puts hub_manpage
-        exit
-      elsif command.nil? && args.grep(/^--?a/).empty?
-        ENV['GIT_PAGER'] = '' if args.grep(/^-{1,2}p/).empty? # Use `cat`.
-        puts improved_help_text
-        exit
-      end
-    end
-    alias_method "--help", :help
-
-    # The text print when `hub help` is run, kept in its own method
-    # for the convenience of the author.
-    def improved_help_text
-      <<-help
-usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--html-path]
-    [-p|--paginate|--no-pager] [--bare] [--git-dir=GIT_DIR]
-    [--work-tree=GIT_WORK_TREE] [--help] COMMAND [ARGS]
-
-Basic Commands:
-   init       Create an empty git repository or reinitialize an existing one
-   add        Add new or modified files to the staging area
-   rm         Remove files from the working directory and staging area
-   mv         Move or rename a file, a directory, or a symlink
-   status     Show the status of the working directory and staging area
-   commit     Record changes to the repository
-
-History Commands:
-   log        Show the commit history log
-   diff       Show changes between commits, commit and working tree, etc
-   show       Show information about commits, tags or files
-
-Branching Commands:
-   branch     List, create, or delete branches
-   checkout   Switch the active branch to another branch
-   merge      Join two or more development histories (branches) together
-   tag        Create, list, delete, sign or verify a tag object
-
-Remote Commands:
-   clone      Clone a remote repository into a new directory
-   fetch      Download data, tags and branches from a remote repository
-   pull       Fetch from and merge with another repository or a local branch
-   push       Upload data, tags and branches to a remote repository
-   remote     View and manage a set of remote repositories
-
-Advanced commands:
-   reset      Reset your staging area or working directory to another point
-   rebase     Re-apply a series of patches in one branch onto another
-   bisect     Find by binary search the change that introduced a bug
-   grep       Print files with lines matching a pattern in your codebase
-
-See 'git help COMMAND' for more information on a specific command.
-help
-    end
-
-  private
-    #
-    # Helper methods are private so they cannot be invoked
-    # from the command line.
-    #
-
-    # 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} 2>/dev/null`
-      $?.success?
-    end
-
-    # Detects commands to launch the user's browser, checking $BROWSER
-    # first then falling back to a few common launchers. Aborts with
-    # an error if it can't find anything appropriate.
-    #
-    # Returns a launch command.
-    def browser_launcher
-      if ENV['BROWSER']
-        ENV['BROWSER']
-      elsif RUBY_PLATFORM.include?('darwin')
-        "open"
-      elsif command?("xdg-open")
-        "xdg-open"
-      elsif command?("cygstart")
-        "cygstart"
-      else
-        abort "Please set $BROWSER to a web launcher to use this command."
-      end
-    end
-
-    # Handles common functionality of browser commands like `browse`
-    # and `compare`. Yields a block that returns params for `github_url`.
-    def browse_command(args)
-      url_only = args.delete('-u')
-      $stderr.puts "Warning: the `-p` flag has no effect anymore" if args.delete('-p')
-      params = yield
-
-      args.executable = url_only ? 'echo' : browser_launcher
-      args.push github_url({:web => true, :private => true}.update(params))
-    end
-
-
-    # Returns the terminal-formatted manpage, ready to be printed to
-    # the screen.
-    def hub_manpage
-      return "** Can't find groff(1)" unless command?('groff')
-
-      require 'open3'
-      out = nil
-      Open3.popen3(groff_command) do |stdin, stdout, _|
-        stdin.puts hub_raw_manpage
-        stdin.close
-        out = stdout.read.strip
-      end
-      out
-    end
-
-    # The groff command complete with crazy arguments we need to run
-    # in order to turn our raw roff (manpage markup) into something
-    # readable on the terminal.
-    def groff_command
-      "groff -Wall -mtty-char -mandoc -Tascii"
-    end
-
-    # Returns the raw hub manpage. If we're not running in standalone
-    # mode, it's a file sitting at the root under the `man`
-    # directory.
-    #
-    # If we are running in standalone mode the manpage will be
-    # included after the __END__ of the file so we can grab it using
-    # DATA.
-    def hub_raw_manpage
-      if File.exists? file = File.dirname(__FILE__) + '/../../man/hub.1'
-        File.read(file)
-      else
-        DATA.read
-      end
-    end
-
-    # All calls to `puts` in after hooks or commands are paged,
-    # git-style.
-    def puts(*args)
-      page_stdout
-      super
-    end
-
-    # http://nex-3.com/posts/73-git-style-automatic-paging-in-ruby
-    def page_stdout
-      return unless $stdout.tty?
-
-      read, write = IO.pipe
-
-      if Kernel.fork
-        # Parent process, become pager
-        $stdin.reopen(read)
-        read.close
-        write.close
-
-        # Don't page if the input is short enough
-        ENV['LESS'] = 'FSRX'
-
-        # Wait until we have input before we start the pager
-        Kernel.select [STDIN]
-
-        pager = ENV['GIT_PAGER'] ||
-          `git config --get-all core.pager`.split.first || ENV['PAGER'] ||
-          'less -isr'
-
-        pager = 'cat' if pager.empty?
-
-        exec pager rescue exec "/bin/sh", "-c", pager
-      else
-        # Child process
-        $stdout.reopen(write)
-        $stderr.reopen(write) if $stderr.tty?
-        read.close
-        write.close
-      end
-    end
-
-    # Determines whether a user has a fork of the current repo on GitHub.
-    def repo_exists?(user)
-      require 'net/http'
-      url = API_REPO % [user, repo_name]
-      Net::HTTPSuccess === Net::HTTP.get_response(URI(url))
-    end
-
-    # Forks the current repo using the GitHub API.
-    #
-    # Returns nothing.
-    def fork_repo
-      url = API_FORK % [repo_owner, repo_name]
-      response = Net::HTTP.post_form(URI(url), 'login' => github_user, 'token' => github_token)
-      response.error! unless Net::HTTPSuccess === response
-    end
-
-    # Creates a new repo using the GitHub API.
-    #
-    # Returns nothing.
-    def create_repo(options = {})
-      url = API_CREATE
-      params = {'login' => github_user, 'token' => github_token, 'name' => repo_name}
-      params['public'] = '0' if options[:private]
-      params['description'] = options[:description] if options[:description]
-      params['homepage'] = options[:homepage] if options[:homepage]
-
-      response = Net::HTTP.post_form(URI(url), params)
-      response.error! unless Net::HTTPSuccess === response
-    end
-
-    def expand_alias(cmd)
-      if expanded = git_alias_for(cmd)
-        if expanded.index('!') != 0
-          require 'shellwords' unless expanded.respond_to? :shellsplit
-          expanded.shellsplit
-        end
-      end
-    end
-
-  end
-end