git-review 2.0.0.alpha → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49d9d8f5c8209622227ccaecb90dbb9db6549f06
+  data.tar.gz: f8041155345b3f1afd104904a64401295fa4bb6f
+SHA512:
+  metadata.gz: 5e6eca5b975528044e599608d58f4d90adb9d466fbe22e9d3da6b21ba53bbe16a49f21e85cd361d3bb3a804c4cacdb1af71b4d04f714fd98c99f4b0943f35b05
+  data.tar.gz: 05ac7231034a1b309e434b1257645c5df10f7a9dd8126a9efadcfba6b0808520860c28fc682b161c6fcf119adaf93d77a84eaeddf81ab6407cf69e85b7b5274c

data/bin/git-review

@@ -7,23 +7,23 @@ require 'git-review'
 require 'gli'
 
 include GLI::App
-
 program_desc 'Manage review workflow for Github projects (using pull requests).'
 
 # Pre-hook before a command is executed
 pre do |global, cmd, opts, args|
-  github = ::GitReview::Github.instance
-  if github.configure_github_access && github.source_repo
-    github.update unless cmd == 'clean'
+  server = ::GitReview::Server.instance
+  if server.configure_access && server.source_repo
+    server.update unless cmd == 'clean'
   end
-  true  # return true to explicitly pass precondition
+
+  true # return true to explicitly pass precondition
 end
 
 desc 'List all pending requests'
 command :list do |c|
   c.switch [:r, :reverse]
   c.action do |global, opts, args|
-  ::GitReview::Commands.list(opts[:reverse])
+    ::GitReview::Commands.list(opts[:reverse])
   end
 end
 
@@ -46,7 +46,7 @@ end
 
 desc 'Checkout a request\'s changes to local repo'
 command :checkout do |c|
-  c.switch [:b, :branch]
+  c.switch [:b, :branch], default_value: true
   c.action do |global, opts, args|
     help_now!('Request number is required.') if args.empty?
     ::GitReview::Commands.checkout(args.shift, opts[:branch])
@@ -81,7 +81,7 @@ desc 'Create a new local branch for a request'
 command :prepare do |c|
   c.switch [:n, :new]
   c.action do |global, opts, args|
-    ::GitReview::Commands.prepare(opts[:new], args.shift)
+    ::GitReview::Commands.prepare(opts[:new], args.empty? ? nil : args.join(' '))
   end
 end
 
@@ -100,7 +100,16 @@ command :clean do |c|
   c.action do |global, opts, args|
     help_now!('Request number is required.') if args.empty? && !opts[:all]
     number = args.empty? ? nil : args.shift
-    ::GitReview::Commands.clean(number, opts[:force], opts[:all])
+    ::GitReview::Commands.clean(args.shift, opts[:force], opts[:all])
+  end
+end
+
+if ::GitReview::Settings.instance.review_mode == 'debug' || ENV['DEBUG']
+  desc 'Console session for debugging'
+  command :console do |c|
+    c.action do |global, opts, args|
+      ::GitReview::Commands.console(args.shift)
+    end
   end
 end
 

data/lib/git-review.rb

@@ -1,28 +1,51 @@
+### Dependencies
+
+## External Dependencies
+
 # Provide access to GitHub's API.
 require 'octokit'
 # Open a browser in 'browse' command.
 require 'launchy'
 # Parse time strings from git back into Time objects.
 require 'time'
-# Use temporary files to allow editing a request's title and body.
+# Use temporary files to allow editing a request's.
 require 'tempfile'
 
-## Our own dependencies
+## Internal dependencies
 
-# Include all helper functions to make GitReview work as expected.
-require_relative 'git-review/internals'
-# Deal with current git repository.
-require_relative 'git-review/local'
-# Communicate with Github via API.
-require_relative 'git-review/github'
-# Read and write settings from/to the filesystem.
-require_relative 'git-review/settings'
+# Include helper functions to make it work as expected.
+require_relative 'git-review/helpers'
 # Provide available commands.
 require_relative 'git-review/commands'
+# Read and write settings from/to the filesystem.
+require_relative 'git-review/settings'
+# Deal with local git repository.
+require_relative 'git-review/local'
 # Include all kinds of custom-defined errors.
 require_relative 'git-review/errors'
+# Factory to get git API client..
+require_relative 'git-review/server'
+# Generic base class for shared provider methods.
+require_relative 'git-review/provider/base'
+# Communicate with Github via API.
+require_relative 'git-review/provider/github'
+# Communicate with Bitbucket via API.
+require_relative 'git-review/provider/bitbucket'
 
+# Allow easy string colorization in the console.
+require_relative 'mixins/colorizable'
+# Allow to access a model's attributes in various ways (feels railsy).
+require_relative 'mixins/accessible'
+# Allow to nest models in other model's attributes.
+require_relative 'mixins/nestable'
 
-module GitReview
+# Include custom string helpers.
+require_relative 'mixins/string'
+# Include custom time helpers.
+require_relative 'mixins/time'
 
-end
+# Add some POROs to get some structure into the entities git-review deals with.
+require_relative 'models/repository'
+require_relative 'models/user'
+require_relative 'models/commit'
+require_relative 'models/request'

data/lib/git-review/commands.rb

@@ -2,66 +2,81 @@ module GitReview
 
   module Commands
 
-    include ::GitReview::Internals
+    include ::GitReview::Helpers
     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
+    def list(reverse = false)
+      requests = server.current_requests_full.reject do |request|
+        # Find only pending (= unmerged) requests and output summary.
+        # Explicitly look for local changes git does not yet know about.
+        # TODO: Isn't this a bit confusing? Maybe display pending pushes?
+        local.merged? request.head.sha
+      end
       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) }
+        puts "ID      Updated    Comments  Title".pink
+        print_requests(requests, reverse)
       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
+    def show(number, full = false)
+      request = server.get_request_by_number(number)
+      # Determine whether to show full diff or stats only.
       option = full ? '' : '--stat '
       diff = "diff --color=always #{option}HEAD...#{request.head.sha}"
-      print_request_details(request)
+      # TODO: Refactor into using Request model.
+      print_request_details request
       puts git_call(diff)
-      print_request_discussions(request)
+      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)
+      request = server.get_request_by_number(number)
+      # FIXME: Use request.html_url as soon as we are using our Request model.
+      Launchy.open request._links.html.href
     end
 
     # Checkout a specified request's changes to your local repository.
-    def checkout(number, branch=false)
-      request = get_request_by_number(number)
+    def checkout(number, branch = true)
+      request = server.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 '  git checkout master'.pink
       puts
+      # Ensure we are looking at the right remote.
+      remote = local.remote_for_request(request)
+      git_call "fetch #{remote}"
+      # Checkout the right branch.
+      branch_name = request.head.ref
       if branch
-        git_call("checkout #{request.head.ref}")
+        if local.branch_exists?(:local, branch_name)
+          if local.source_branch == branch_name
+            puts "On branch #{branch_name}."
+          else
+            git_call "checkout #{branch_name}"
+          end
+        else
+          git_call "checkout --track -b #{branch_name} #{remote}/#{branch_name}"
+        end
       else
-        git_call("checkout pr/#{request.number}")
+        git_call "checkout #{remote}/#{branch_name}"
       end
     end
 
     # Add an approving comment to the request.
     def approve(number)
-      request = get_request_by_number(number)
-      repo = github.source_repo
+      request = server.get_request_by_number(number)
+      repo = server.source_repo
       # TODO: Make this configurable.
       comment = 'Reviewed and approved.'
-      response = github.add_comment(repo, request.number, comment)
+      response = server.add_comment(repo, request.number, comment)
       if response[:body] == comment
         puts 'Successfully approved request.'
       else
@@ -71,7 +86,7 @@ module GitReview
 
     # Accept a specified request by merging it into master.
     def merge(number)
-      request = get_request_by_number(number)
+      request = server.get_request_by_number(number)
       if request.head.repo
         message = "Accept request ##{request.number} " +
             "and merge changes into \"#{local.target}\""
@@ -85,108 +100,144 @@ module GitReview
         puts
         puts git_call(command)
       else
-        print_repo_deleted(request)
+        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)
+      request = server.get_request_by_number(number)
+      repo = server.source_repo
+      server.close_issue(repo, request.number)
+      unless server.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)
+    # NOTE:
+    #   People should work on local branches, but especially for single commit
+    #   changes, more often than not, they don't. Therefore this is called
+    #   automatically before creating a pull request, such that we create a
+    #   proper feature branch for them, to be able to use code review the way it
+    #   is intended.
+    def prepare(force_new_branch = false, feature_name = nil)
+      current_branch = local.source_branch
+      if force_new_branch || !local.on_feature_branch?
+        feature_name ||= get_branch_name
+        feature_branch = move_local_changes(
+          current_branch, local.sanitize_branch_name(feature_name)
+        )
       else
-        local_branch = original_branch
+        feature_branch = current_branch
       end
-      [original_branch, local_branch]
+      [current_branch, feature_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
+    def create(upstream = false)
+      # Prepare original_branch and local_branch.
+      # TODO: Allow to use the same switches and parameters that prepare takes.
       original_branch, local_branch = prepare
-      # don't create request with uncommitted changes in current branch
-      unless git_call('diff HEAD').empty?
+      # Don't create request with uncommitted changes in current branch.
+      if local.uncommitted_changes?
         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)
+      if local.new_commits?(upstream)
+        # Feature branch differs from local or upstream master.
+        if server.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}")
+        # Push latest commits to the remote branch (create if necessary).
+        remote = local.remote_for_branch(local_branch) || 'origin'
+        git_call(
+          "push --set-upstream #{remote} #{local_branch}", debug_mode, true
+        )
+        server.send_pull_request upstream
+        # Return to the user's original branch.
+        git_call "checkout #{original_branch}"
+      else
+        puts 'Nothing to push to remote yet. Commit something first.'
       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.
+    # Remove remotes with 'review' prefix (left over from previous reviews).
+    # Prune all existing remotes and delete obsolete branches (left over from
+    # already closed requests).
+    def clean(number = nil, force = false, all = false)
+      git_call "checkout #{local.target_branch}"
+      local.prune_remotes
+      # Determine strategy to clean.
       if all
         local.clean_all
       else
         local.clean_single(number, force)
       end
+      # Remove al review remotes without existing local branches.
+      local.clean_remotes
     end
 
     # Start a console session (used for debugging)
-    def console
+    def console(number = nil)
       puts 'Entering debug console.'
-      if RUBY_VERSION == '2.0.0'
-        require 'byebug'
-        byebug
+      request = server.get_request_by_number(number) if number
+
+      if RUBY_VERSION.to_f >= 2
+        begin
+          require 'byebug'
+          byebug
+        rescue LoadError => e
+          puts
+          puts 'Missing debugger, please install byebug:'
+          puts '  gem install byebug'
+          puts
+        end
       else
-        require 'ruby-debug'
-        Debugger.start
-        debugger
+        begin
+          require 'ruby-debug'
+          Debugger.start
+          debugger
+        rescue LoadError => e
+          puts
+          puts 'Missing debugger, please install ruby-debug:'
+          puts '  gem install ruby-debug'
+          puts
+        end
       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
+    private
+
+    def request_summary(request)
+      line = request.number.to_s.review_ljust(8)
+      line << request.updated_at.review_time.review_ljust(11)
+      line << server.comments_count(request).to_s.review_ljust(10)
+      line << request.title.review_ljust(91)
+      line
+    end
+
+    def print_requests(requests, reverse=false)
+      # put all output lines in a hash first, keyed by request number
+      # this is to make sure the order is still correct even if we use
+      #   multi-threading to retrieve the requests
+      output = {}
+      requests.each { |req| output[req.number] = request_summary(req) }
+      numbers = output.keys.sort
+      numbers.reverse! if reverse
+      numbers.each { |n| puts output[n] }
     end
 
     def print_request_details(request)
-      comments_count = request.comments.to_i + request.review_comments.to_i
+      comments_count = server.comments_count(request)
       puts 'ID        : ' + request.number.to_s
       puts 'Label     : ' + request.head.label
-      puts 'Updated   : ' + format_time(request.updated_at)
+      puts 'Updated   : ' + request.updated_at.review_time
       puts 'Comments  : ' + comments_count.to_s
       puts
       puts request.title
@@ -200,7 +251,7 @@ module GitReview
     def print_request_discussions(request)
       puts 'Progress  :'
       puts
-      puts github.discussion(request.number)
+      puts server.discussion(request.number)
     end
 
     # someone deleted the source repo
@@ -221,111 +272,45 @@ module GitReview
     # @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
+      local.sanitize_branch_name gets.chomp
+    end
+
+    # @return [String] the complete feature branch name
+    def create_feature_name(new_branch)
+      "review_#{Time.now.strftime("%y%m%d")}_#{new_branch}"
     end
 
-    # move uncommitted changes from target branch to local branch
+    # Move uncommitted changes from original_branch to a feature_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
+    def move_local_changes(original_branch, feature_name)
+      feature_branch = create_feature_name(feature_name)
+      # By checking out the feature branch, the commits on the original branch
+      # are copied over. That way we only need to remove pending (local) commits
+      # from the original branch.
+      git_call "checkout -b #{feature_branch}"
+      if local.source_branch == feature_branch
+        # Save any uncommitted changes, to be able to reapply them later.
         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}")
+        # Go back to original branch and get rid of pending (local) commits.
+        git_call("checkout #{original_branch}")
+        remote = local.remote_for_branch(original_branch)
+        remote += '/' if remote
+        git_call("reset --hard #{remote}#{original_branch}")
+        git_call("checkout #{feature_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")
+        feature_branch
       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
+    def server
+      @server ||= ::GitReview::Server.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
-