git-hub 1.4.1 → 1.5.0

data/README.md

@@ -30,7 +30,7 @@ Install
 
 `hub` is most easily installed as a standalone script:
 
-    curl -s http://defunkt.github.com/hub/standalone > ~/bin/hub &&
+    curl http://chriswanstrath.com/hub/standalone -sLo ~/bin/hub &&
     chmod 755 ~/bin/hub
 
 Assuming `~/bin/` is in your `$PATH`, you're ready to roll:
@@ -191,39 +191,33 @@ Creates a new public github repository and adds the remote `origin` at
 ### git browse
 
     $ git browse
-    > open http://github.com/CURRENT_REPO
+    > open https://github.com/CURRENT_REPO
 
     $ git browse -- issues
-    > open http://github.com/CURRENT_REPO/issues
+    > open https://github.com/CURRENT_REPO/issues
 
     $ git browse schacon/ticgit
-    > open http://github.com/schacon/ticgit
-
-    $ git browse -p schacon/ticgit
     > open https://github.com/schacon/ticgit
 
     $ git browse resque
-    > open http://github.com/YOUR_USER/resque
+    > open https://github.com/YOUR_USER/resque
 
     $ git browse resque network
-    > open http://github.com/YOUR_USER/resque/network
-
-    $ git browse -p resque
-    > open https://github.com:YOUR_USER/resque
+    > open https://github.com/YOUR_USER/resque/network
 
 ### git compare
 
     $ git compare refactor
-    > open http://github.com/CURRENT_REPO/compare/refactor
+    > open https://github.com/CURRENT_REPO/compare/refactor
 
     $ git compare 1.0...1.1
-    > open http://github.com/CURRENT_REPO/compare/1.0...1.1
+    > open https://github.com/CURRENT_REPO/compare/1.0...1.1
 
     $ git compare -u fix
-    > (http://github.com/CURRENT_REPO/compare/fix)
+    > (https://github.com/CURRENT_REPO/compare/fix)
 
     $ git compare other-user patch
-    > open http://github.com/other-user/REPO/compare/patch
+    > open https://github.com/other-user/REPO/compare/patch
 
 ### git submodule
 
@@ -249,7 +243,7 @@ GitHub Login
 ------------
 
 To get the most out of `hub`, you'll want to ensure your GitHub login
-is stored locally in your Git config.
+is stored locally in your Git config or environment variables.
 
 To test it run this:
 
@@ -262,6 +256,12 @@ If you see nothing, you need to set the config setting:
 For commands that require write access to GitHub (such as `fork`), you'll want to
 setup "github.token" as well. See [local GitHub config guide][2] for more information.
 
+Want to use environment variables instead of a local gitconfig?
+
+* `GITHUB_USER`  - If set, this will be used instead of the `github.user` config
+                   value to determine your GitHub username.
+* `GITHUB_TOKEN` - If set, this will be used instead of the `github.token` config
+                   value to determine your GitHub API token.
 
 Configuration
 -------------
@@ -315,7 +315,7 @@ contribute to `hub`:
 * `turn` (`gem install turn`)
 * `mg` (`gem install mg`)
 * `ronn` (`gem install ronn`)
-* `webhelper` (`gem install webhelper`)
+* `webmock` (`gem install webmock`)
 
 Meta
 ----
@@ -328,10 +328,10 @@ Meta
 * Gems: <http://gemcutter.org/gems/git-hub>
 
 
-Author
-------
+Authors
+-------
 
-Chris Wanstrath :: chris@ozmm.org :: @defunkt
+<https://github.com/defunkt/hub/contributors>
 
 [0]: http://help.github.com/forking/
 [1]: http://github.com/defunkt/hub/issues

data/lib/hub/args.rb

@@ -12,27 +12,33 @@ module Hub
       super
       @executable = ENV["GIT"] || "git"
       @after = nil
+      @skip = false
+      @original_args = args.first
+      @chain = [nil]
     end
 
-    # With no arguments, returns the `after` callback.
-    #
-    # With a single argument, sets the `after` callback.
-    # Can be set to a string or a proc.
-    #
-    # If proc:
-    #   The proc is executed after the git command is executed. For
-    #   example, the `hub version` command sets the following proc to
-    #   print its information after running `git version`:
-    #
-    #     after { puts "hub version #{version_number}" }
-    #
-    # If string:
-    #   The string is assumed to be a command and executed after the
-    #   git command is executed:
-    #
-    #     after "echo 'hub version #{version_number}'"
-    def after(command = nil, &block)
-      @after ||= block ? block : command
+    # 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.
@@ -45,15 +51,10 @@ module Hub
       @skip
     end
 
-    # Boolean indicating whether an `after` callback has been set.
-    def after?
-      !!@after
-    end
-
     # Array of `executable` followed by all args suitable as arguments
     # for `exec` or `system` calls.
-    def to_exec
-      [executable].concat self
+    def to_exec(args = self)
+      [executable].concat args
     end
 
     # All the words (as opposed to flags) contained in this argument
@@ -73,5 +74,26 @@ module Hub
     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

@@ -149,16 +149,16 @@ module Hub
       if args.include?('--multiple')
         names = args.words[1..-1]
       # $ hub fetch <name>
-      elsif name = args.words[1]
+      elsif remote_name = args.words[1]
         # $ hub fetch <name1>,<name2>,...
-        if name =~ /^\w+(,\w+)+$/
-          index = args.index(name)
-          args.delete(name)
-          names = name.split(',')
+        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 = [name]
+          names = [remote_name]
         end
       else
         names = []
@@ -170,11 +170,9 @@ module Hub
       }
 
       if names.any?
-        commands = names.map { |name| "git remote add #{name} #{github_url(:user => name)}" }
-        commands << args.to_exec.join(' ')
-        args.replace commands.shift.split(' ')
-        args.shift # don't want "git"
-        args.after commands.join('; ')
+        names.each do |name|
+          args.before ['remote', 'add', name, github_url(:user => name)]
+        end
       end
     end
 
@@ -192,40 +190,49 @@ module Hub
     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})}
-          scheme, user, repo, sha = $1, $2, $3, $4
+        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})$/
-          scheme, user, repo, sha = nil, $1, nil, $2
+          user, repo, sha = $1, nil, $2
           args[args.index(ref)] = sha
         else
           user = nil
         end
 
         if user
-          # cherry-pick comes after the fetch
-          args.after args.to_exec.join(' ')
-
           if user == repo_owner
             # fetch from origin if the repo belongs to the user
-            args.replace ['fetch', default_remote]
+            args.before ['fetch', default_remote]
           elsif remotes.include?(user)
-            args.replace ['fetch', user]
+            args.before ['fetch', user]
           else
-            secure = scheme == 'https:'
-            remote_url = github_url(:user => user, :repo => repo, :private => secure)
-            args.replace ['remote', 'add', '-f', user, remote_url]
+            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?://github\.com/} }
+        idx = args.index(url)
+        url += '.patch' unless File.extname(url) == '.patch'
+        patch_file = File.join(ENV['TMPDIR'], 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 => File.basename(Dir.pwd))
+        url = github_url(:private => true, :repo => current_dirname)
         args.after "git remote add origin #{url}"
       end
     end
@@ -306,35 +313,25 @@ module Hub
       remotes = args[1].split(',')
       args[1] = remotes.shift
 
-      after = "git push #{remotes.shift} #{branch}"
-
-      while remotes.length > 0
-        after += "; git push #{remotes.shift} #{branch}"
+      remotes.each do |name|
+        args.after ['push', name, branch]
       end
-
-      args.after after
     end
 
     # $ hub browse
-    # > open http://github.com/CURRENT_REPO
+    # > open https://github.com/CURRENT_REPO
     #
     # $ hub browse -- issues
-    # > open http://github.com/CURRENT_REPO/issues
+    # > open https://github.com/CURRENT_REPO/issues
     #
     # $ hub browse pjhyett/github-services
-    # > open http://github.com/pjhyett/github-services
-    #
-    # $ hub browse -p pjhyett/github-fi
-    # > open https://github.com/pjhyett/github-fi
+    # > open https://github.com/pjhyett/github-services
     #
     # $ hub browse github-services
-    # > open http://github.com/YOUR_LOGIN/github-services
+    # > open https://github.com/YOUR_LOGIN/github-services
     #
     # $ hub browse github-services wiki
-    # > open http://wiki.github.com/YOUR_LOGIN/github-services
-    #
-    # $ hub browse -p github-fi
-    # > open https://github.com/YOUR_LOGIN/github-fi
+    # > open https://github.com/YOUR_LOGIN/github-services/wiki
     def browse(args)
       args.shift
       browse_command(args) do
@@ -357,8 +354,6 @@ module Hub
 
         # $ hub browse -- wiki
         case subpage = args.shift
-        when 'wiki'
-          params[:web] = 'wiki'
         when 'commits'
           branch = (!dest && tracked_branch) || 'master'
           params[:web] = "/commits/#{branch}"
@@ -374,15 +369,13 @@ module Hub
     end
 
     # $ hub compare 1.0...fix
-    # > open http://github.com/CURRENT_REPO/compare/1.0...fix
+    # > open https://github.com/CURRENT_REPO/compare/1.0...fix
     # $ hub compare refactor
-    # > open http://github.com/CURRENT_REPO/compare/refactor
+    # > open https://github.com/CURRENT_REPO/compare/refactor
     # $ hub compare myfork feature
-    # > open http://github.com/myfork/REPO/compare/feature
-    # $ hub compare -p myfork topsecret
-    # > open https://github.com/myfork/REPO/compare/topsecret
+    # > open https://github.com/myfork/REPO/compare/feature
     # $ hub compare -u 1.0...2.0
-    # prints "http://github.com/CURRENT_REPO/compare/1.0...2.0"
+    # "https://github.com/CURRENT_REPO/compare/1.0...2.0"
     def compare(args)
       args.shift
       browse_command(args) do
@@ -569,11 +562,11 @@ help
     # and `compare`. Yields a block that returns params for `github_url`.
     def browse_command(args)
       url_only = args.delete('-u')
-      secure = args.delete('-p')
+      $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 => secure}.update(params))
+      args.push github_url({:web => true, :private => true}.update(params))
     end
 
 

data/lib/hub/context.rb

@@ -2,6 +2,8 @@ module Hub
   # Provides methods for inspecting the environment, such as GitHub user/token
   # settings, repository info, and similar.
   module Context
+    private
+
     # Caches output when shelling out to git
     GIT_CONFIG = Hash.new do |cache, cmd|
       result = %x{git #{cmd}}.chomp
@@ -11,9 +13,9 @@ module Hub
     # Parses URLs for git remotes and stores info
     REMOTES = Hash.new do |cache, remote|
       if remote
-        url = GIT_CONFIG["config remote.#{remote}.url"]
+        urls = GIT_CONFIG["config --get-all remote.#{remote}.url"].to_s.split("\n")
 
-        if url && url.to_s =~ %r{\bgithub\.com[:/](.+)/(.+).git$}
+        if urls.find { |u| u =~ %r{\bgithub\.com[:/](.+)/(.+).git$} } 
           cache[remote] = { :user => $1, :repo => $2 }
         else
           cache[remote] = { }
@@ -34,13 +36,13 @@ module Hub
     end
 
     def repo_name
-      REMOTES[default_remote][:repo] || File.basename(Dir.pwd)
+      REMOTES[default_remote][:repo] || current_dirname
     end
 
     # Either returns the GitHub user as set by git-config(1) or aborts
     # with an error message.
     def github_user(fatal = true)
-      if user = GIT_CONFIG['config github.user']
+      if user = ENV['GITHUB_USER'] || GIT_CONFIG['config github.user']
         user
       elsif fatal
         abort("** No GitHub user set. See #{LGHCONF}")
@@ -48,7 +50,7 @@ module Hub
     end
 
     def github_token(fatal = true)
-      if token = GIT_CONFIG['config github.token']
+      if token = ENV['GITHUB_TOKEN'] || GIT_CONFIG['config github.token']
         token
       elsif fatal
         abort("** No GitHub token set. See #{LGHCONF}")
@@ -119,10 +121,7 @@ module Hub
       repo ||= repo_name
       secure = options[:private]
 
-      if options[:web] == 'wiki'
-        scheme = secure ? 'https:' : 'http:'
-        '%s//wiki.github.com/%s/%s/' % [scheme, user, repo]
-      elsif options[:web]
+      if options[:web]
         scheme = secure ? 'https:' : 'http:'
         path = options[:web] == true ? '' : options[:web].to_s
         '%s//github.com/%s/%s%s' % [scheme, user, repo, path]
@@ -138,5 +137,11 @@ module Hub
         url % [user, repo]
       end
     end
+
+    DIRNAME = File.basename(Dir.pwd)
+
+    def current_dirname
+      DIRNAME
+    end
   end
 end

data/lib/hub/runner.rb

@@ -11,11 +11,11 @@ module Hub
       @args = Args.new(args)
 
       # Hack to emulate git-style
-      @args.unshift 'help' if @args.grep(/^[^-]|version/).empty?
+      @args.unshift 'help' if @args.grep(/^[^-]|version|exec-path$|html-path/).empty?
 
       # git commands can have dashes
       cmd = @args[0].sub(/(\w)-/, '\1_')
-      Commands.send(cmd, @args) if Commands.respond_to?(cmd)
+      Commands.send(cmd, @args) if Commands.method_defined?(cmd)
     end
 
     # Shortcut
@@ -23,22 +23,23 @@ module Hub
       new(*args).execute
     end
 
-    # Returns the current after callback, which (if set) is run after
-    # the target git command.
-    #
-    # See the `Hub::Args` class for more information on the `after`
-    # callback.
-    def after
-      args.after.to_s
-    end
-
-    # A string representation of the git command we would run if
-    # #execute were called.
+    # A string representation of the command that would run.
     def command
       if args.skip?
         ''
       else
-        args.to_exec.join(' ')
+        commands.join('; ')
+      end
+    end
+
+    # An array of all commands as strings.
+    def commands
+      args.commands.map do |cmd|
+        if cmd.respond_to?(:join)
+          cmd.map { |c| c.index(' ') ? "'#{c}'" : c }.join(' ')
+        else
+          cmd.to_s
+        end
       end
     end
 
@@ -50,25 +51,25 @@ module Hub
     # execution if they don't make sense.
     def execute
       unless args.skip?
-        if args.after?
-          execute_with_after_callback
+        if args.chained?
+          execute_command_chain
         else
           exec(*args.to_exec)
         end
       end
     end
 
-    # Runs the target git command then executes the `after` callback.
-    #
-    # See the `Hub::Args` class for more information on the `after`
-    # callback.
-    def execute_with_after_callback
-      after = args.after
-      if system(*args.to_exec)
-        after.respond_to?(:call) ? after.call : exec(after)
-        exit
-      else
-        exit 1
+    # Runs multiple commands in succession; exits at first failure.
+    def execute_command_chain
+      commands = args.commands
+      commands.each_with_index do |cmd, i|
+        if cmd.respond_to?(:call) then cmd.call
+        elsif i == commands.length - 1
+          # last command in chain
+          exec(*cmd)
+        else
+          exit($?.exitstatus) unless system(*cmd)
+        end
       end
     end
   end