git-review 2.0.0.alpha → 2.0.0

data/lib/git-review/errors.rb

@@ -6,6 +6,12 @@ module GitReview
     end
   end
 
+  class InvalidGitProviderError < StandardError
+    def message
+      "It is not a valid git provider."
+    end
+  end
+
   class InvalidGitRepositoryError < StandardError
     def message
       "It is not a valid git repository or doesn't have a valid remote url."

data/lib/git-review/helpers.rb

@@ -0,0 +1,38 @@
+module GitReview
+
+  module Helpers
+
+    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 enforce_success and not command_successful?
+        puts output unless output.empty?
+        raise ::GitReview::UnprocessableState
+      end
+
+      output
+    end
+
+    # @return [Boolean] Whether the last issued system call was successful
+    def command_successful?
+      $?.exitstatus == 0
+    end
+
+    # @return [Boolean] Whether we are running in debugging moder or not
+    def debug_mode
+      ::GitReview::Settings.instance.review_mode == 'debug'
+    end
+
+  end
+
+end

data/lib/git-review/local.rb

@@ -5,7 +5,7 @@ module GitReview
   # TODO: remove Github-dependency
   class Local
 
-    include ::GitReview::Internals
+    include ::GitReview::Helpers
 
     attr_accessor :config
 
@@ -20,32 +20,115 @@ module GitReview
       if git_call('rev-parse --show-toplevel').strip.empty?
         raise ::GitReview::InvalidGitRepositoryError
       else
-        add_pull_refspec
         load_config
       end
     end
 
+    # List all available remotes.
+    def remotes
+      git_call('remote').split("\n")
+    end
+
+    # Determine whether a remote with a given name exists?
+    def remote_exists?(name)
+      remotes.include? name
+    end
+
+    # Create a Hash with all remotes as keys and their urls as values.
+    def remotes_with_urls
+      result = {}
+      git_call('remote -vv').split("\n").each do |line|
+        entries = line.split("\t")
+        remote = entries.first
+        target_entry = entries.last.split(' ')
+        direction = target_entry.last[1..-2].to_sym
+        target_url = target_entry.first
+        result[remote] ||= {}
+        result[remote][direction] = target_url
+      end
+      result
+    end
+
+    # Collect all remotes for a given url.
+    def remotes_for_url(remote_url)
+      result = remotes_with_urls.collect do |remote, urls|
+        remote if urls.values.all? { |url| url == remote_url }
+      end
+      result.compact
+    end
+
+    # Find or create the correct remote for a fork with a given owner name.
+    def remote_for_request(request)
+      repo_owner = request.head.repo.owner.login
+      remote_url = server.remote_url_for(repo_owner)
+      remotes = remotes_for_url(remote_url)
+      if remotes.empty?
+        remote = "review_#{repo_owner}"
+        git_call("remote add #{remote} #{remote_url}", debug_mode, true)
+      else
+        remote = remotes.first
+      end
+      remote
+    end
+
+    # Remove obsolete remotes with review prefix.
+    def clean_remotes
+      protected_remotes = remotes_for_branches
+      remotes.each do |remote|
+        # Only remove review remotes that aren't referenced by current branches.
+        if remote.index('review_') == 0 && !protected_remotes.include?(remote)
+          git_call "remote remove #{remote}"
+        end
+      end
+    end
+
+    # Prune all configured remotes.
+    def prune_remotes
+      remotes.each { |remote| git_call "remote prune #{remote}" }
+    end
+
+    # Find all remotes which are currently referenced by local branches.
+    def remotes_for_branches
+      remotes = git_call('branch -lvv').gsub('* ', '').split("\n").map do |line|
+        line.split(' ')[2][1..-2].split('/').first
+      end
+      remotes.uniq
+    end
+
+    # Finds the correct remote for a given branch name.
+    def remote_for_branch(branch_name)
+      git_call('branch -lvv').gsub('* ', '').split("\n").each do |line|
+        entries = line.split(' ')
+        next unless entries.first == branch_name
+        # Return the remote name or nil for local branches.
+        match = entries[2].match(%r(\[(.*)(\]|:)))
+        return match[1].split('/').first if match
+      end
+      nil
+    end
+
     # @return [Array<String>] all existing branches
     def all_branches
-      git_call('branch -a').split("\n").collect { |s| s.strip }
+      git_call('branch -a').gsub('* ', '').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 }
+      server.current_requests.collect { |r| r.head.ref }
     end
 
     # @return [Array<String>] all review branches with 'review_' prefix
     def review_branches
-      all_branches.collect { |branch|
+      all_branches.collect { |entry|
         # only use uniq branch names (no matter if local or remote)
-        branch.split('/').last if branch.include?('review_')
+        branch_name = entry.split('/').last
+        branch_name if branch_name.index('review_') == 0
       }.compact.uniq
     end
 
     # clean a single request's obsolete branch
-    def clean_single(number, force=false)
-      request = github.pull_request(source_repo, number)
+    def clean_single(number, force = false)
+      request = server.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
@@ -137,14 +220,30 @@ module GitReview
       end
     end
 
+    # @return [Boolean] whether there are commits not in target branch yet
+    def new_commits?(upstream = false)
+      # Check if an upstream remote exists and create it if necessary.
+      remote_url = server.remote_url_for(*target_repo(upstream).split('/'))
+      remote = remotes_for_url(remote_url).first
+      unless remote
+        remote = 'upstream'
+        git_call "remote add #{remote} #{remote_url}"
+      end
+      git_call "fetch #{remote}"
+      target = upstream ? "#{remote}/#{target_branch}" : target_branch
+      not git_call("cherry #{target}").empty?
+    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
+      branches = git_call("branch --contains #{sha} 2>&1").split("\n").
+          collect { |b| b.delete('*').strip }
+      branches.include?(target_branch)
     end
 
     # @return [String] the source repo
     def source_repo
-      github.source_repo
+      server.source_repo
     end
 
     # @return [String] the current source branch
@@ -168,7 +267,7 @@ module GitReview
     def target_repo(upstream=false)
       # TODO: Manually override this and set arbitrary repositories
       if upstream
-        github.repository(source_repo).parent.full_name
+        server.repository(source_repo).parent.full_name
       else
         source_repo
       end
@@ -182,7 +281,7 @@ module GitReview
     # @return [String] the head string used for pull requests
     def head
       # in the form of 'user:branch'
-      "#{github.github.login}:#{source_branch}"
+      "#{source_repo.split('/').first}:#{source_branch}"
     end
 
     # @return [Boolean] whether already on a feature branch
@@ -193,12 +292,9 @@ module GitReview
       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)
+    # Remove all non word characters and turn them into underscores.
+    def sanitize_branch_name(name)
+      name.gsub(/\W+/, '_').downcase
     end
 
     def load_config
@@ -218,8 +314,49 @@ module GitReview
       git_call('config --list', false)
     end
 
-    def github
-      @github ||= ::GitReview::Github.instance
+    def server
+      @server ||= ::GitReview::Server.instance
+    end
+
+    # @return [Array(String, String)] the title and the body of pull request
+    def create_title_and_body(target_branch)
+      login = server.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
 
   end

data/lib/git-review/provider/base.rb

@@ -0,0 +1,85 @@
+module GitReview
+
+  module Provider
+
+    class Base
+
+      attr_reader :client
+      attr_accessor :source_repo
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def initialize
+        configure_access
+      end
+
+      def update
+        git_call('fetch origin')
+      end
+
+      # @return [String] Source repo name
+      def source_repo
+        @source_repo ||= begin
+          user, repo = repo_info_from_config
+          "#{user}/#{repo}"
+        end
+      end
+
+      # @return [String] Current username
+      def login
+        settings.username
+      end
+
+      # @return [Array(String, String)] User and repo name from git
+      def repo_info_from_config
+        url = local.config['remote.origin.url']
+        raise ::GitReview::InvalidGitRepositoryError if url.nil?
+
+        user, project = url_matching(url)
+
+        unless user && project
+          insteadof_url, true_url = insteadof_matching(local.config, url)
+
+          if insteadof_url and true_url
+            url = url.sub(insteadof_url, true_url)
+            user, project = url_matching(url)
+          end
+        end
+
+        [user, project]
+      end
+
+      # Ensure we find the right request
+      def get_request_by_number(request_number)
+        request_exists?(request_number) || (raise ::GitReview::InvalidRequestIDError)
+      end
+
+      def method_missing(method, *args)
+        if client.respond_to?(method)
+          client.send(method, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method)
+        client.respond_to?(method) || super
+      end
+
+      private
+
+      def local
+        @local ||= ::GitReview::Local.instance
+      end
+
+      def settings
+        @settings ||= ::GitReview::Settings.instance
+      end
+
+    end
+
+  end
+
+end

data/lib/git-review/provider/bitbucket.rb

@@ -0,0 +1,25 @@
+module GitReview
+
+  module Provider
+
+    class Bitbucket < Base
+
+      include ::GitReview::Helpers
+
+      attr_reader :bitbucket
+
+      def configure_access
+      end
+
+      def source_repo
+      end
+
+      def update
+        git_call('fetch origin')
+      end
+
+    end
+
+  end
+
+end

data/lib/git-review/provider/github.rb

@@ -0,0 +1,271 @@
+require 'net/http'
+require 'net/https'
+require 'yajl'
+require 'io/console'
+require 'stringio'
+require 'socket'
+
+module GitReview
+
+  module Provider
+
+    class Github < Base
+
+      include ::GitReview::Helpers
+
+      # @return [String] Authenticated username
+      def configure_access
+        if settings.oauth_token && settings.username
+          @client = Octokit::Client.new(
+            login: settings.username,
+            access_token: settings.oauth_token,
+            auto_traversal: true
+          )
+
+          @client.login
+        else
+          configure_oauth
+          configure_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 = client.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)
+        client.pull_requests(target_repo).any? { |r| r.head.ref == branch }
+      end
+
+      # an alias to pull_requests
+      def current_requests(repo=source_repo)
+        client.pull_requests(repo)
+      end
+
+      # a more detailed collection of requests
+      def current_requests_full(repo=source_repo)
+        threads = []
+        requests = []
+        client.pull_requests(repo).each do |req|
+          threads << Thread.new {
+            requests << client.pull_request(repo, req.number)
+          }
+        end
+        threads.each { |t| t.join }
+        requests
+      end
+
+      def send_pull_request(to_upstream = false)
+        target_repo = local.target_repo(to_upstream)
+        head = local.head
+        base = local.target_branch
+        title, body = local.create_title_and_body(base)
+
+        # gather information before creating pull request
+        latest_number = latest_request_number(target_repo)
+
+        # create the actual pull request
+        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 = request_number_by_title(title, target_repo)
+        if new_number && new_number > latest_number
+          puts "Successfully created new request ##{new_number}"
+          puts request_url_for target_repo, new_number
+        else
+          puts "Pull request was not created for #{target_repo}."
+        end
+      end
+
+      def commit_discussion(number)
+        pull_commits = client.pull_commits(source_repo, number)
+        repo = client.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 #{commit.commit.committer.date.review_time}"
+          output << ":\n#{''.rjust(output.length + 1, "-")}\n"
+          output << "#{commit.commit.message}"
+          output << "\n\n"
+          result = [output]
+
+          # comments on commit
+          comments = client.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 #{comment.created_at.review_time}"
+            unless comment.created_at == comment.updated_at
+              output << " (updated on #{comment.updated_at.review_time})"
+            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 = client.issue_comments(source_repo, number) +
+            client.review_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 #{comment.created_at.review_time}"
+          unless comment.created_at == comment.updated_at
+            output << " (updated on #{comment.updated_at.review_time})"
+          end
+          output << ":\n#{''.rjust(output.length + 1, "-")}\n"
+          output << comment.body
+          output << "\n\n"
+        }
+        discussion.compact.flatten unless discussion.empty?
+      end
+
+      # get the number of comments, including comments on commits
+      def comments_count(request)
+        issue_c = request.comments + request.review_comments
+        commits_c = client.pull_commits(source_repo, request.number).
+            inject(0) { |sum, c| sum + c.commit.comment_count }
+        issue_c + commits_c
+      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
+
+      # FIXME: Remove this method after merging create_pull_request from commands.rb, currently no specs
+      def request_url_for(target_repo, request_number)
+        "https://github.com/#{target_repo}/pull/#{request_number}"
+      end
+
+      # FIXME: Needs to be moved into Server class, as its result is dependent of
+      # the actual provider (i.e. GitHub or BitBucket).
+      def remote_url_for(user_name, repo_name = repo_info_from_config.last)
+        "git@github.com:#{user_name}/#{repo_name}.git"
+      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 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 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
+
+    end
+
+  end
+
+end