git-review 1.1.6 → 1.1.7

data/lib/git-review/commands.rb

@@ -0,0 +1,331 @@
+module GitReview
+
+  module Commands
+
+    include ::GitReview::Internals
+    extend self
+
+    # List all pending requests.
+    def list(reverse=false)
+      requests = github.current_requests_full.reject { |request|
+        # find only pending (= unmerged) requests and output summary
+        # explicitly look for local changes Github does not yet know about
+        local.merged?(request.head.sha)
+      }
+      requests.reverse! if reverse
+      source = local.source
+      if requests.empty?
+        puts "No pending requests for '#{source}'."
+      else
+        puts "Pending requests for '#{source}':"
+        puts "ID      Updated    Comments  Title"
+        requests.each { |request| print_request(request) }
+      end
+    end
+
+    # Show details for a single request.
+    def show(number, full=false)
+      request = get_request_by_number(number)
+      # determine whether to show full diff or just stats
+      option = full ? '' : '--stat '
+      diff = "diff --color=always #{option}HEAD...#{request.head.sha}"
+      print_request_details(request)
+      puts git_call(diff)
+      print_request_discussions(request)
+    end
+
+    # Open a browser window and review a specified request.
+    def browse(number)
+      request = get_request_by_number(number)
+      Launchy.open(request.html_url)
+    end
+
+    # Checkout a specified request's changes to your local repository.
+    def checkout(number, branch=false)
+      request = get_request_by_number(number)
+      puts 'Checking out changes to your local repository.'
+      puts 'To get back to your original state, just run:'
+      puts
+      puts '  git checkout master'
+      puts
+      if branch
+        git_call("checkout #{request.head.ref}")
+      else
+        git_call("checkout pr/#{request.number}")
+      end
+    end
+
+    # Add an approving comment to the request.
+    def approve(number)
+      request = get_request_by_number(number)
+      repo = github.source_repo
+      # TODO: Make this configurable.
+      comment = 'Reviewed and approved.'
+      response = github.add_comment(repo, request.number, comment)
+      if response[:body] == comment
+        puts 'Successfully approved request.'
+      else
+        puts response[:message]
+      end
+    end
+
+    # Accept a specified request by merging it into master.
+    def merge(number)
+      request = get_request_by_number(number)
+      if request.head.repo
+        message = "Accept request ##{request.number} " +
+            "and merge changes into \"#{local.target}\""
+        command = "merge -m '#{message}' #{request.head.sha}"
+        puts
+        puts "Request title:"
+        puts "  #{request.title}"
+        puts
+        puts "Merge command:"
+        puts "  git #{command}"
+        puts
+        puts git_call(command)
+      else
+        print_repo_deleted(request)
+      end
+    end
+
+    # Close a specified request.
+    def close(number)
+      request = get_request_by_number(number)
+      repo = github.source_repo
+      github.close_issue(repo, request.number)
+      unless github.request_exists?('open', request.number)
+        puts 'Successfully closed request.'
+      end
+    end
+
+    # Prepare local repository to create a new request.
+    # People should work on local branches, but especially for single commit
+    #   changes, more often than not, they don't. Therefore we create a branch
+    #   for them, to be able to use code review the way it is intended.
+    # @return [Array(String, String)] the original branch and the local branch
+    def prepare(new=false, name=nil)
+      # remember original branch the user was currently working on
+      original_branch = local.source_branch
+      if new || !local.on_feature_branch?
+        local_branch = move_uncommitted_changes(local.target_branch, name)
+      else
+        local_branch = original_branch
+      end
+      [original_branch, local_branch]
+    end
+
+    # Create a new request.
+    # TODO: Support creating requests to other repositories and branches (like
+    #   the original repo, this has been forked from).
+    def create(upstream=false)
+      # prepare original_branch and local_branch
+      original_branch, local_branch = prepare
+      # don't create request with uncommitted changes in current branch
+      unless git_call('diff HEAD').empty?
+        puts 'You have uncommitted changes.'
+        puts 'Please stash or commit before creating the request.'
+        return
+      end
+      if git_call("cherry #{local.target_branch}").empty?
+        puts 'Nothing to push to remote yet. Commit something first.'
+      else
+        if github.request_exists_for_branch?(upstream)
+          puts 'A pull request already exists for this branch.'
+          puts 'Please update the request directly using `git push`.'
+          return
+        end
+        # push latest commits to the remote branch (create if necessary)
+        git_call("push --set-upstream origin #{local_branch}", debug_mode, true)
+        create_pull_request(upstream)
+        # return to the user's original branch
+        # FIXME: keep track of original branch etc
+        git_call("checkout #{original_branch}")
+      end
+    end
+
+    # delete obsolete branches (left over from already closed requests)
+    def clean(number=nil, force=false, all=false)
+      # pruning is needed to remove deleted branches from your local track
+      git_call('remote prune origin')
+      # determine strategy to clean.
+      if all
+        local.clean_all
+      else
+        local.clean_single(number, force)
+      end
+    end
+
+    # Start a console session (used for debugging)
+    def console
+      puts 'Entering debug console.'
+      if RUBY_VERSION == '2.0.0'
+        require 'byebug'
+        byebug
+      else
+        require 'ruby-debug'
+        Debugger.start
+        debugger
+      end
+      puts 'Leaving debug console.'
+    end
+
+  private
+
+    def print_request(request)
+      date_string = format_time(request.updated_at)
+      comments_count = request.comments.to_i + request.review_comments.to_i
+      line = format_text(request.number, 8)
+      line << format_text(date_string, 11)
+      line << format_text(comments_count, 10)
+      line << format_text(request.title, 91)
+      puts line
+    end
+
+    def print_request_details(request)
+      comments_count = request.comments.to_i + request.review_comments.to_i
+      puts 'ID        : ' + request.number.to_s
+      puts 'Label     : ' + request.head.label
+      puts 'Updated   : ' + format_time(request.updated_at)
+      puts 'Comments  : ' + comments_count.to_s
+      puts
+      puts request.title
+      puts
+      unless request.body.empty?
+        puts request.body
+        puts
+      end
+    end
+
+    def print_request_discussions(request)
+      puts 'Progress  :'
+      puts
+      puts github.discussion(request.number)
+    end
+
+    # someone deleted the source repo
+    def print_repo_deleted(request)
+      user = request.head.user.login
+      url = request.patch_url
+      puts "Sorry, #{user} deleted the source repository."
+      puts "git-review doesn't support this."
+      puts "Tell the contributor not to do this."
+      puts
+      puts "You can still manually patch your repo by running:"
+      puts
+      puts "  curl #{url} | git am"
+      puts
+    end
+
+    # ask for branch name if not provided
+    # @return [String] sanitized branch name
+    def get_branch_name
+      puts 'Please provide a name for the branch:'
+      branch_name = gets.chomp
+      branch_name.gsub(/\W+/, '_').downcase
+    end
+
+    # move uncommitted changes from target branch to local branch
+    # @return [String] the new local branch uncommitted changes are moved to
+    def move_uncommitted_changes(target_branch, new_branch)
+      new_branch ||= get_branch_name
+      local_branch = "review_#{Time.now.strftime("%y%m%d")}_#{new_branch}"
+      git_call("checkout -b #{local_branch}")
+      # make sure we are on the feature branch
+      if local.source_branch == local_branch
+        # stash any uncommitted changes
+        save_uncommitted_changes = local.uncommitted_changes?
+        git_call('stash') if save_uncommitted_changes
+        # go back to target and get rid of pending commits
+        git_call("checkout #{target_branch}")
+        git_call("reset --hard origin/#{target_branch}")
+        git_call("checkout #{local_branch}")
+        git_call('stash pop') if save_uncommitted_changes
+        local_branch
+      end
+    end
+
+    def create_pull_request(to_upstream=false)
+      target_repo = local.target_repo(to_upstream)
+      head = local.head
+      base = local.target_branch
+      title, body = create_title_and_body(base)
+
+      # gather information before creating pull request
+      lastest_number = github.latest_request_number(target_repo)
+
+      # create the actual pull request
+      github.create_pull_request(target_repo, base, head, title, body)
+      # switch back to target_branch and check for success
+      git_call("checkout #{base}")
+
+      # make sure the new pull request is indeed created
+      new_number = github.request_number_by_title(title, target_repo)
+      if new_number && new_number > lastest_number
+        puts "Successfully created new request ##{new_number}"
+        puts "https://github.com/#{target_repo}/pull/#{new_number}"
+      else
+        puts "Pull request was not created for #{target_repo}."
+      end
+    end
+
+
+    # @return [Array(String, String)] the title and the body of pull request
+    def create_title_and_body(target_branch)
+      source = local.source
+      login = github.github.login
+      commits = git_call("log --format='%H' HEAD...#{target_branch}").
+          lines.count
+      puts "commits: #{commits}"
+      if commits == 1
+        # we can create a really specific title and body
+        title = git_call("log --format='%s' HEAD...#{target_branch}").chomp
+        body  = git_call("log --format='%b' HEAD...#{target_branch}").chomp
+      else
+        title = "[Review] Request from '#{login}' @ '#{source}'"
+        body  = "Please review the following changes:\n"
+        body += git_call("log --oneline HEAD...#{target_branch}").
+            lines.map{|l| "  * #{l.chomp}"}.join("\n")
+      end
+      edit_title_and_body(title, body)
+    end
+
+    # TODO: refactor
+    def edit_title_and_body(title, body)
+      tmpfile = Tempfile.new('git-review')
+      tmpfile.write(title + "\n\n" + body)
+      tmpfile.flush
+      editor = ENV['TERM_EDITOR'] || ENV['EDITOR']
+      unless editor
+        warn 'Please set $EDITOR or $TERM_EDITOR in your .bash_profile.'
+      end
+
+      system("#{editor || 'open'} #{tmpfile.path}")
+
+      tmpfile.rewind
+      lines = tmpfile.read.lines.to_a
+      puts lines.inspect
+      title = lines.shift.chomp
+      lines.shift if lines[0].chomp.empty?
+      body = lines.join
+      tmpfile.unlink
+      [title, body]
+    end
+
+    def github
+      @github ||= ::GitReview::Github.instance
+    end
+
+    def local
+      @local ||= ::GitReview::Local.instance
+    end
+
+    def get_request_by_number(request_number)
+      request = github.request_exists?(request_number)
+      request || (raise ::GitReview::InvalidRequestIDError)
+    end
+
+  end
+
+end
+

data/lib/git-review/errors.rb

@@ -0,0 +1,34 @@
+module GitReview
+
+  class AuthenticationError < StandardError
+    def message
+      'You provided the wrong username/password, please try again.'
+    end
+  end
+
+  class InvalidGitRepositoryError < StandardError
+    def message
+      "It is not a valid git repository or doesn't have a valid remote url."
+    end
+  end
+
+  # A custom error to raise, if we know we can't go on.
+  class UnprocessableState < StandardError
+    def message
+      'Execution of git-review stopped.'
+    end
+  end
+
+  class InvalidArgumentError < StandardError
+    def message
+      'Please specify valid arguments. See --help for more information.'
+    end
+  end
+
+  class InvalidRequestIDError < StandardError
+    def message
+      'Please specify a valid request ID.'
+    end
+  end
+
+end

data/lib/git-review/github.rb

@@ -0,0 +1,289 @@
+require 'net/http'
+require 'net/https'
+# Used to handle json data
+require 'yajl'
+# Required to hide password
+require 'io/console'
+# Required by yajl for decoding
+require 'stringio'
+# Used to retrieve hostname
+require 'socket'
+
+
+module GitReview
+
+  class Github
+
+    include ::GitReview::Internals
+
+    attr_reader :github
+    attr_accessor :source_repo
+
+    # acts like a singleton class but it's actually not
+    # use ::GitReview::Github.instance everywhere except in tests
+    def self.instance
+      @instance ||= new
+    end
+
+    def initialize
+      configure_github_access
+    end
+
+    # setup connection with Github via OAuth
+    # @return [String] the username logged in
+    def configure_github_access
+      settings = ::GitReview::Settings.instance
+      if settings.oauth_token && settings.username
+        @github = Octokit::Client.new(
+          :login          => settings.username,
+          :access_token    => settings.oauth_token,
+          :auto_traversal => true
+        )
+        @github.login
+      else
+        configure_oauth
+        configure_github_access
+      end
+    end
+
+    # @return [Boolean, Hash] the specified request if exists, otherwise false.
+    #   Instead of true, the request itself is returned, so another round-trip
+    #   of pull_request can be avoided.
+    def request_exists?(number, state='open')
+      return false if number.nil?
+      request = @github.pull_request(source_repo, number)
+      request.state == state ? request : false
+    rescue Octokit::NotFound
+      false
+    end
+
+    def request_exists_for_branch?(upstream=false, branch=local.source_branch)
+      target_repo = local.target_repo(upstream)
+      @github.pull_requests(target_repo).any? { |r|
+        r.head.ref == branch
+      }
+    end
+
+    # an alias to pull_requests
+    def current_requests(repo=source_repo)
+      @github.pull_requests(repo)
+    end
+
+    # a more detailed collection of requests
+    def current_requests_full(repo=source_repo)
+      @github.pull_requests(repo).collect { |request|
+        @github.pull_request(repo, request.number)
+      }
+    end
+
+    def update
+      git_call('fetch origin')
+    end
+
+    # @return [Array(String, String)] user and repo name from local git config
+    def repo_info_from_config
+      git_config = local.config
+      url = git_config['remote.origin.url']
+      raise ::GitReview::InvalidGitRepositoryError if url.nil?
+
+      user, project = github_url_matching(url)
+      # if there are no results yet, look for 'insteadof' substitutions
+      #   in URL and try again
+      unless user && project
+        insteadof_url, true_url = github_insteadof_matching(git_config, url)
+        if insteadof_url and true_url
+          url = url.sub(insteadof_url, true_url)
+          user, project = github_url_matching(url)
+        end
+      end
+      [user, project]
+    end
+
+    # @return [String] the source repo
+    def source_repo
+      # cache source_repo
+      if @source_repo
+        @source_repo
+      else
+        user, repo = repo_info_from_config
+        @source_repo = "#{user}/#{repo}" if user && repo
+      end
+    end
+
+    def commit_discussion(number)
+      pull_commits = @github.pull_commits(source_repo, number)
+      repo = @github.pull_request(source_repo, number).head.repo.full_name
+      discussion = ["Commits on pull request:\n\n"]
+      discussion += pull_commits.collect { |commit|
+        # commit message
+        name = commit.committer.login
+        output = "\e[35m#{name}\e[m "
+        output << "committed \e[36m#{commit.sha[0..6]}\e[m "
+        output << "on #{format_time(commit.commit.committer.date)}"
+        output << ":\n#{''.rjust(output.length + 1, "-")}\n"
+        output << "#{commit.commit.message}"
+        output << "\n\n"
+        result = [output]
+
+        # comments on commit
+        comments = @github.commit_comments(repo, commit.sha)
+        result + comments.collect { |comment|
+          name = comment.user.login
+          output = "\e[35m#{name}\e[m "
+          output << "added a comment to \e[36m#{commit.sha[0..6]}\e[m"
+          output << " on #{format_time(comment.created_at)}"
+          unless comment.created_at == comment.updated_at
+            output << " (updated on #{format_time(comment.updated_at)})"
+          end
+          output << ":\n#{''.rjust(output.length + 1, "-")}\n"
+          output << comment.body
+          output << "\n\n"
+        }
+      }
+      discussion.compact.flatten unless discussion.empty?
+    end
+
+    def issue_discussion(number)
+      comments = @github.issue_comments(source_repo, number)
+      discussion = ["\nComments on pull request:\n\n"]
+      discussion += comments.collect { |comment|
+        name = comment.user.login
+        output = "\e[35m#{name}\e[m "
+        output << "added a comment to \e[36m#{comment.id}\e[m"
+        output << " on #{format_time(comment.created_at)}"
+        unless comment.created_at == comment.updated_at
+          output << " (updated on #{format_time(comment.updated_at)})"
+        end
+        output << ":\n#{''.rjust(output.length + 1, "-")}\n"
+        output << comment.body
+        output << "\n\n"
+      }
+      discussion.compact.flatten unless discussion.empty?
+    end
+
+    # show discussion for a request
+    def discussion(number)
+      commit_discussion(number) +
+      issue_discussion(number)
+    end
+
+    # show latest pull request number
+    def latest_request_number(repo=source_repo)
+      current_requests(repo).collect(&:number).sort.last.to_i
+    end
+
+    # get the number of the request that matches the title
+    def request_number_by_title(title, repo=source_repo)
+      request = current_requests(repo).find { |r| r.title == title }
+      request.number if request
+    end
+
+    # delegate methods that interact with Github to Octokit client
+    def method_missing(method, *args)
+      if @github.respond_to?(method)
+        @github.send(method, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      @github.respond_to?(method) || super
+    end
+
+  private
+
+    def configure_oauth
+      begin
+        prepare_username_and_password
+        prepare_description
+        authorize
+      rescue ::GitReview::AuthenticationError => e
+        warn e.message
+      rescue ::GitReview::UnprocessableState => e
+        warn e.message
+        exit 1
+      end
+    end
+
+    def prepare_username_and_password
+      puts "Requesting a OAuth token for git-review."
+      puts "This procedure will grant access to your public and private "\
+      "repositories."
+      puts "You can revoke this authorization by visiting the following page: "\
+      "https://github.com/settings/applications"
+      print "Please enter your GitHub's username: "
+      @username = STDIN.gets.chomp
+      print "Please enter your GitHub's password (it won't be stored anywhere): "
+      @password = STDIN.noecho(&:gets).chomp
+      print "\n"
+    end
+
+    def prepare_description(chosen_description=nil)
+      if chosen_description
+        @description = chosen_description
+      else
+        @description = "git-review - #{Socket.gethostname}"
+        puts "Please enter a description to associate to this token, it will "\
+        "make easier to find it inside of GitHub's application page."
+        puts "Press enter to accept the proposed description"
+        print "Description [#{@description}]:"
+        user_description = STDIN.gets.chomp
+        @description = user_description.empty? ? @description : user_description
+      end
+    end
+
+    def authorize
+      uri = URI('https://api.github.com/authorizations')
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      req = Net::HTTP::Post.new(uri.request_uri)
+      req.basic_auth(@username, @password)
+      req.body = Yajl::Encoder.encode(
+        {
+          :scopes => %w(repo),
+          :note   => @description
+        }
+      )
+      response = http.request(req)
+      if response.code == '201'
+        parser_response = Yajl::Parser.parse(response.body)
+        save_oauth_token(parser_response['token'])
+      elsif response.code == '401'
+        raise ::GitReview::AuthenticationError
+      else
+        raise ::GitReview::UnprocessableState, response.body
+      end
+    end
+
+    def save_oauth_token(token)
+      settings = ::GitReview::Settings.instance
+      settings.oauth_token = token
+      settings.username = @username
+      settings.save!
+      puts "OAuth token successfully created.\n"
+    end
+
+    # extract user and project name from GitHub URL.
+    def github_url_matching(url)
+      matches = /github\.com.(.*?)\/(.*)/.match(url)
+      matches ? [matches[1], matches[2].sub(/\.git\z/, '')] : [nil, nil]
+    end
+
+    # look for 'insteadof' substitutions in URL.
+    def github_insteadof_matching(config, url)
+      first_match = config.keys.collect { |key|
+        [config[key], /url\.(.*github\.com.*)\.insteadof/.match(key)]
+      }.find { |insteadof_url, true_url|
+        url.index(insteadof_url) and true_url != nil
+      }
+      first_match ? [first_match[0], first_match[1][1]] : [nil, nil]
+    end
+
+    def local
+      @local ||= ::GitReview::Local.instance
+    end
+
+  end
+
+end

data/lib/git-review/internals.rb

@@ -0,0 +1,47 @@
+module GitReview
+
+  module Internals
+
+    private
+
+    # System call to 'git'.
+    def git_call(command, verbose = debug_mode, enforce_success = false)
+      if verbose
+        puts
+        puts "  git #{command}"
+        puts
+      end
+      output = `git #{command}`
+      puts output if verbose and not output.empty?
+      # If we need sth. to succeed, but it doesn't, then stop right there.
+      if enforce_success and not last_command_successful?
+        puts output unless output.empty?
+        raise ::GitReview::UnprocessableState
+      end
+      output
+    end
+
+    # @return [Boolean] whether the last issued system call was successful
+    def last_command_successful?
+      $?.exitstatus == 0
+    end
+
+    def debug_mode
+      ::GitReview::Settings.instance.review_mode == 'debug'
+    end
+
+    # display helper to make output more configurable
+    def format_text(info, size)
+      info.to_s.gsub("\n", ' ')[0, size-1].ljust(size)
+    end
+
+    # display helper to unify time output
+    def format_time(time)
+      time = Time.parse(time) if time.is_a?(String)
+      time.strftime('%d-%b-%y')
+    end
+
+  end
+
+end
+

data/lib/git-review/local.rb

@@ -0,0 +1,227 @@
+module GitReview
+
+  # The local repository is where the git-review command is being called
+  # by default. It is (supposedly) able to handle systems other than Github.
+  # TODO: remove Github-dependency
+  class Local
+
+    include ::GitReview::Internals
+
+    attr_accessor :config
+
+    # acts like a singleton class but it's actually not
+    # use ::GitReview::Local.instance everywhere except in tests
+    def self.instance
+      @instance ||= new
+    end
+
+    def initialize
+      # find root git directory if currently in subdirectory
+      if git_call('rev-parse --show-toplevel').strip.empty?
+        raise ::GitReview::InvalidGitRepositoryError
+      else
+        add_pull_refspec
+        load_config
+      end
+    end
+
+    # @return [Array<String>] all existing branches
+    def all_branches
+      git_call('branch -a').split("\n").collect { |s| s.strip }
+    end
+
+    # @return [Array<String>] all open requests' branches shouldn't be deleted
+    def protected_branches
+      github.current_requests.collect { |r| r.head.ref }
+    end
+
+    # @return [Array<String>] all review branches with 'review_' prefix
+    def review_branches
+      all_branches.collect { |branch|
+        # only use uniq branch names (no matter if local or remote)
+        branch.split('/').last if branch.include?('review_')
+      }.compact.uniq
+    end
+
+    # clean a single request's obsolete branch
+    def clean_single(number, force=false)
+      request = github.pull_request(source_repo, number)
+      if request && request.state == 'closed'
+        # ensure there are no unmerged commits or '--force' flag has been set
+        branch_name = request.head.ref
+        if unmerged_commits?(branch_name) && !force
+          puts "Won't delete branches that contain unmerged commits."
+          puts "Use '--force' to override."
+        else
+          delete_branch(branch_name)
+        end
+      end
+    rescue Octokit::NotFound
+      false
+    end
+
+    # clean all obsolete branches
+    def clean_all
+      (review_branches - protected_branches).each do |branch_name|
+        # only clean up obsolete branches.
+        delete_branch(branch_name) unless unmerged_commits?(branch_name, false)
+      end
+    end
+
+    # delete local and remote branches that match a given name
+    # @param branch_name [String] name of the branch to delete
+    def delete_branch(branch_name)
+      delete_local_branch(branch_name)
+      delete_remote_branch(branch_name)
+    end
+
+    # delete local branch if it exists.
+    # @param (see #delete_branch)
+    def delete_local_branch(branch_name)
+      if branch_exists?(:local, branch_name)
+        git_call("branch -D #{branch_name}", true)
+      end
+    end
+
+    # delete remote branch if it exists.
+    # @param (see #delete_branch)
+    def delete_remote_branch(branch_name)
+      if branch_exists?(:remote, branch_name)
+        git_call("push origin :#{branch_name}", true)
+      end
+    end
+
+    # @param location [Symbol] location of the branch, `:remote` or `:local`
+    # @param branch_name [String] name of the branch
+    # @return [Boolean] whether a branch exists in a specified location
+    def branch_exists?(location, branch_name)
+      return false unless [:remote, :local].include?(location)
+      prefix = location == :remote ? 'remotes/origin/' : ''
+      all_branches.include?(prefix + branch_name)
+    end
+
+    # @return [Boolean] whether there are local changes not committed
+    def uncommitted_changes?
+      !git_call('diff HEAD').empty?
+    end
+
+    # @param branch_name [String] name of the branch
+    # @param verbose [Boolean] if verbose output
+    # @return [Boolean] whether there are unmerged commits on the local or
+    #   remote branch.
+    def unmerged_commits?(branch_name, verbose=true)
+      locations = []
+      locations << '' if branch_exists?(:local, branch_name)
+      locations << 'origin/' if branch_exists?(:remote, branch_name)
+      locations = locations.repeated_permutation(2).to_a
+      if locations.empty?
+        puts 'Nothing to do. All cleaned up already.' if verbose
+        return false
+      end
+      # compare remote and local branch with remote and local master
+      responses = locations.collect { |loc|
+        git_call "cherry #{loc.first}#{target_branch} #{loc.last}#{branch_name}"
+      }
+      # select commits (= non empty, not just an error message and not only
+      #   duplicate commits staring with '-').
+      unmerged_commits = responses.reject { |response|
+        response.empty? or response.include?('fatal: Unknown commit') or
+            response.split("\n").reject { |x| x.index('-') == 0 }.empty?
+      }
+      # if the array ain't empty, we got unmerged commits
+      if unmerged_commits.empty?
+        false
+      else
+        puts "Unmerged commits on branch '#{branch_name}'."
+        true
+      end
+    end
+
+    # @return [Boolean] whether a specified commit has already been merged.
+    def merged?(sha)
+      not git_call("rev-list #{sha} ^HEAD 2>&1").split("\n").size > 0
+    end
+
+    # @return [String] the source repo
+    def source_repo
+      github.source_repo
+    end
+
+    # @return [String] the current source branch
+    def source_branch
+      git_call('branch').chomp.match(/\*(.*)/)[0][2..-1]
+    end
+
+    # @return [String] combine source repo and branch
+    def source
+      "#{source_repo}/#{source_branch}"
+    end
+
+    # @return [String] the name of the target branch
+    def target_branch
+      # TODO: Manually override this and set arbitrary branches
+      ENV['TARGET_BRANCH'] || 'master'
+    end
+
+    # if to send a pull request to upstream repo, get the parent as target
+    # @return [String] the name of the target repo
+    def target_repo(upstream=false)
+      # TODO: Manually override this and set arbitrary repositories
+      if upstream
+        github.repository(source_repo).parent.full_name
+      else
+        source_repo
+      end
+    end
+
+    # @return [String] combine target repo and branch
+    def target
+      "#{target_repo}/#{target_branch}"
+    end
+
+    # @return [String] the head string used for pull requests
+    def head
+      # in the form of 'user:branch'
+      "#{github.github.login}:#{source_branch}"
+    end
+
+    # @return [Boolean] whether already on a feature branch
+    def on_feature_branch?
+      # If current and target are the same, we are not on a feature branch.
+      # If they are different, but we are on master, we should still to switch
+      # to a separate branch (since master makes for a poor feature branch).
+      source_branch != target_branch && source_branch != 'master'
+    end
+
+    # add remote.origin.fetch to check out pull request locally
+    # see {https://help.github.com/articles/checking-out-pull-requests-locally}
+    def add_pull_refspec
+      refspec = '+refs/pull/*/head:refs/remotes/origin/pr/*'
+      fetch_config = "config --local --add remote.origin.fetch #{refspec}"
+      git_call(fetch_config, false) unless config_list.include?(refspec)
+    end
+
+    def load_config
+      @config = {}
+      config_list.split("\n").each do |line|
+        key, value = line.split(/=/, 2)
+        if @config[key] && @config[key] != value
+          @config[key] = [@config[key]].flatten << value
+        else
+          @config[key] = value
+        end
+      end
+      @config
+    end
+
+    def config_list
+      git_call('config --list', false)
+    end
+
+    def github
+      @github ||= ::GitReview::Github.instance
+    end
+
+  end
+
+end

data/lib/git-review/settings.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+require 'yaml'
+
+module GitReview
+
+  class Settings
+
+    # acts like a singleton class but it's actually not
+    # use ::GitReview::Settings.instance everywhere except in tests
+    def self.instance
+      @instance ||= new
+    end
+
+    # Read settings from ~/.git_review.yml upon initialization.
+    def initialize
+      @config_file = File.join(Dir.home, '.git_review.yml')
+      @config = YAML.load_file(@config_file) if File.exists?(@config_file)
+      @config ||= {}
+    end
+
+    # Write settings back to file.
+    def save!
+      File.open(@config_file, 'w') do |file|
+        file.write(YAML.dump(@config))
+      end
+    end
+
+    # Allow to access config options.
+    def method_missing(method, *args)
+      # Determine whether to set or get an attribute.
+      if method.to_s =~ /(.*)=$/
+        @config[$1.to_sym] = args.shift
+      else
+        @config[method.to_sym]
+      end
+    end
+
+    def respond_to?(method)
+      if method.to_s =~ /(.*)=$/ ||  @config.keys.include?(method.to_sym)
+        true
+      else
+        super
+      end
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-review
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-05 00:00:00.000000000 Z
+date: 2013-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: launchy
@@ -32,17 +32,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.24.0
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -85,6 +85,12 @@ files:
 - LICENSE
 - lib/settings.rb
 - lib/git-review.rb
+- lib/git-review/settings.rb
+- lib/git-review/commands.rb
+- lib/git-review/errors.rb
+- lib/git-review/github.rb
+- lib/git-review/internals.rb
+- lib/git-review/local.rb
 - lib/oauth_helper.rb
 - bin/git-review
 homepage: http://github.com/b4mboo/git-review
@@ -112,3 +118,4 @@ signing_key:
 specification_version: 3
 summary: facilitates GitHub code reviews
 test_files: []
+has_rdoc: