git-process 0.9.1.pre3

data/lib/git-process/git-process.rb

@@ -0,0 +1,194 @@
+require 'git-lib'
+require 'uncommitted-changes-error'
+require 'git-rebase-error'
+require 'git-merge-error'
+require 'parked-changes-error'
+require 'pull-request'
+require 'shellwords'
+require 'highline/import'
+
+
+module Git
+
+  class Process
+    attr_reader :lib
+
+    @@server_name = 'origin'
+    @@master_branch = 'master'
+
+    def initialize(dir = nil, gitlib = nil, options = {})
+      @lib = gitlib || Git::GitLib.new(dir, options)
+    end
+
+
+    def Process.remote_master_branch
+      "#{@@server_name}/#{@@master_branch}"
+    end
+
+
+    def Process.server_name
+      @@server_name
+    end
+
+
+    def Process.master_branch
+      @@master_branch
+    end
+
+
+    def rebase_to_master
+      raise UncommittedChangesError.new unless lib.status.clean?
+      raise ParkedChangesError.new(lib) if is_parked?
+
+      if lib.has_a_remote?
+        lib.fetch
+        rebase(Process::remote_master_branch)
+        lib.push(Process::server_name, lib.branches.current, Process::master_branch)
+        remove_feature_branch
+      else
+        rebase("master")
+      end
+    end
+
+
+    def sync_with_server(rebase, force)
+      raise UncommittedChangesError.new unless lib.status.clean?
+      raise ParkedChangesError.new(lib) if is_parked?
+
+      current_branch = lib.branches.current
+      remote_branch = "#{Process::server_name}/#{current_branch}"
+
+      lib.fetch
+
+      if rebase
+        rebase(Process::remote_master_branch)
+      else
+        merge(Process::remote_master_branch)
+      end
+
+      old_sha = lib.command('rev-parse', remote_branch) rescue ''
+
+      unless current_branch == Process::master_branch
+        lib.fetch
+        new_sha = lib.command('rev-parse', remote_branch) rescue ''
+        unless old_sha == new_sha
+          logger.warn("'#{current_branch}' changed on '#{Process::server_name}'"+
+                      " [#{old_sha[0..5]}->#{new_sha[0..5]}]; trying sync again.")
+          sync_with_server(rebase, force)
+        end
+        lib.push(Process::server_name, current_branch, current_branch, :force => rebase || force)
+      else
+        logger.warn("Not pushing to the server because the current branch is the master branch.")
+      end
+    end
+
+
+    def new_feature_branch(branch_name)
+      branches = lib.branches
+      on_parking = (branches.parking == branches.current)
+
+      if on_parking
+        new_branch = lib.checkout(branch_name, :new_branch => '_parking_')
+        branches.parking.delete
+        new_branch
+      else
+        lib.checkout(branch_name, :new_branch => 'origin/master')
+      end
+    end
+
+
+    def bad_parking_branch_msg
+      hl = HighLine.new
+      hl.color("\n***********************************************************************************************\n\n"+
+               "There is an old '_parking_' branch with unacounted changes in it.\n"+
+               "It has been renamed to '_parking_OLD_'.\n"+
+               "Please rename the branch to what the changes are about (`git branch -m _parking_OLD_ my_fb_name`),\n"+
+               " or remove it altogher (`git branch -D _parking_OLD_`).\n\n"+
+               "***********************************************************************************************\n", :red, :bold)
+    end
+
+
+    def remove_feature_branch
+      branches = lib.branches
+
+      remote_master = branches[Process::remote_master_branch]
+      current_branch = branches.current
+
+      unless remote_master.contains_all_of(current_branch.name)
+        raise GitProcessError.new("Branch '#{current_branch.name}' has not been merged into '#{Process::remote_master_branch}'")
+      end
+
+      parking_branch = branches['_parking_']
+      if parking_branch
+        if (parking_branch.is_ahead_of(remote_master.name) and
+            !current_branch.contains_all_of(parking_branch.name))
+
+          parking_branch.rename('_parking_OLD_')
+
+          logger.warn {bad_parking_branch_msg}
+        else
+          parking_branch.delete
+        end
+      end
+      remote_master.checkout_to_new('_parking_', :no_track => true)
+
+      current_branch.delete(true)
+      if branches["#{Process.server_name}/#{current_branch.name}"]
+        lib.push(Process.server_name, nil, nil, :delete => current_branch.name)
+      end
+    end
+
+
+    def is_parked?
+      branches = lib.branches
+      branches.parking == branches.current
+    end
+
+
+    def rebase(base)
+      begin
+        lib.rebase(base)
+      rescue Git::GitExecuteError => rebase_error
+        raise RebaseError.new(rebase_error.message, lib)
+      end
+    end
+
+
+    def merge(base)
+      begin
+        lib.merge(base)
+      rescue Git::GitExecuteError => merge_error
+        raise MergeError.new(merge_error.message, lib)
+      end
+    end
+
+
+    def pull_request(repo_name, base, head, title, body, opts = {})
+      repo_name ||= lib.repo_name
+      base ||= @@master_branch
+      head ||= lib.branches.current
+      title ||= ask_for_pull_title
+      body ||= ask_for_pull_body
+      GitHub::PullRequest.new(lib, repo_name, opts).pull_request(base, head, title, body)
+    end
+
+
+    def ask_for_pull_title
+      ask("What <%= color('title', [:bold]) %> do you want to give the pull request? ") do |q|
+        q.validate = /^\w+.*/
+      end
+    end
+
+
+    def ask_for_pull_body
+      ask("What <%= color('description', [:bold]) %> do you want to give the pull request? ")
+    end
+
+
+    def logger
+      @lib.logger
+    end
+
+  end
+
+end

data/lib/git-process/git-pull-request-options.rb

@@ -0,0 +1,42 @@
+require 'git-process-options'
+
+module Git
+
+  class Process
+
+    class PullRequestOptions
+      include GitProcessOptions
+
+      attr_reader :user, :password, :description, :title, :filename
+
+      def initialize(filename, argv)
+        @filename = filename
+        parse(filename, argv)
+      end
+
+      def extend_opts(opts)
+        opts.banner = "Usage: #{filename} [ options ] [pull_request_title]"
+
+        opts.on("-u", "--user name", String, "GitHub account username") do |user|
+          @user = user
+        end
+
+        opts.on("-p", "--password pw", String, "GitHub account password") do |password|
+          @password = password
+        end
+
+        opts.on(nil, "--desc description", String, "Description of the changes.") do |desc|
+          @description = desc
+        end
+      end
+
+
+      def extend_args(argv)
+        @title = argv.pop unless argv.empty?
+      end
+
+    end
+
+  end
+
+end

data/lib/git-process/git-rebase-error.rb

@@ -0,0 +1,31 @@
+require 'git-process-error'
+require 'git-abstract-merge-error-builder'
+
+module Git
+
+  class Process
+
+    class RebaseError < GitProcessError
+      include Git::AbstractMergeErrorBuilder
+
+      attr_reader :error_message, :lib
+
+      def initialize(rebase_error_message, lib)
+        @lib = lib
+        @error_message = rebase_error_message
+
+        msg = build_message
+
+        super(msg)
+      end
+
+
+      def continue_command
+        'git rebase --continue'
+      end
+
+    end
+
+  end
+
+end

data/lib/git-process/git-status.rb

@@ -0,0 +1,72 @@
+module Git
+
+  #
+  # The status of the Git repository.
+  #
+  # @!attribute [r] unmerged
+  #   @return [Enumerable] a sorted list of unmerged files
+  # @!attribute [r] modified
+  #   @return [Enumerable] a sorted list of modified files
+  # @!attribute [r] deleted
+  #   @return [Enumerable] a sorted list of deleted files
+  # @!attribute [r] added
+  #   @return [Enumerable] a sorted list of files that have been added
+  # @!attribute [r] unknown
+  #   @return [Enumerable] a sorted list of unknown files
+  class GitStatus
+    attr_reader :unmerged, :modified, :deleted, :added, :unknown
+
+    def initialize(lib)
+      unmerged = []
+      modified = []
+      deleted = []
+      added = []
+      unknown = []
+
+      stats = lib.porcelain_status.split("\n")
+
+      stats.each do |s|
+        stat = s[0..1]
+        file = s[3..-1]
+        #puts "stat #{stat} - #{file}"
+        case stat
+        when 'U ', ' U'
+          unmerged << file
+        when 'UU'
+          unmerged << file
+          modified << file
+        when 'M ', ' M'
+          modified << file
+        when 'D ', ' D'
+          deleted << file
+        when 'DU', 'UD'
+          deleted << file
+          unmerged << file
+        when 'A ', ' A'
+          added << file
+        when 'AA'
+          added << file
+          unmerged << file
+        when '??'
+          unknown << file
+        else
+          raise "Do not know what to do with status #{stat} - #{file}"
+        end
+      end
+
+      @unmerged = unmerged.sort.uniq.freeze
+      @modified = modified.sort.uniq.freeze
+      @deleted = deleted.sort.uniq.freeze
+      @added = added.sort.uniq.freeze
+      @unknown = unknown.sort.uniq.freeze
+    end
+
+
+    # @return [Boolean] are there any changes in the index or working directory?
+    def clean?
+      @unmerged.empty? and @modified.empty? and @deleted.empty? and @added.empty? and @unknown.empty?
+    end
+
+  end
+
+end

data/lib/git-process/git-sync-options.rb

@@ -0,0 +1,34 @@
+require 'optparse'
+require 'git-process-options'
+
+module Git
+
+  class Process
+
+    class SyncOptions
+      include GitProcessOptions
+
+      attr_reader :rebase, :force
+
+
+      def initialize(filename, argv)
+        @rebase = false
+        @force = false
+        parse(filename, argv)
+      end
+
+
+      def extend_opts(opts)
+        opts.on("-r", "--rebase", "Rebase instead of merge") do |v|
+          @rebase = true
+        end
+
+        opts.on("-f", "--force", "Force the push") do |v|
+          @force = true
+        end
+      end
+    end
+
+  end
+
+end

data/lib/git-process/git-to-master-options.rb

@@ -0,0 +1,18 @@
+require 'optparse'
+require 'git-process-options'
+
+module Git
+
+  class Process
+
+    class ToMasterOptions
+      include GitProcessOptions
+
+      def initialize(filename, argv)
+        parse(filename, argv)
+      end
+    end
+
+  end
+
+end

data/lib/git-process/github-client.rb

@@ -0,0 +1,73 @@
+require 'octokit'
+
+module Octokit
+
+  module Connection
+
+    #
+    # Unfortunately, there's no way to change the URL except by completely replacing
+    # this method.
+    #
+    def connection(authenticate=true, raw=false, version=3, force_urlencoded=false)
+      if site
+        url = site
+      else
+        case version
+        when 2
+          url = "https://github.com"
+        when 3
+          url = "https://api.github.com"
+        end
+      end
+
+      options = {
+        :proxy => proxy,
+        :ssl => { :verify => false },
+        :url => url,
+      }
+
+      options.merge!(:params => {:access_token => oauth_token}) if oauthed? && !authenticated?
+
+      connection = Faraday.new(options) do |builder|
+        if version >= 3 && !force_urlencoded
+          builder.request :json
+        else
+          builder.request :url_encoded
+        end
+        builder.use Faraday::Response::RaiseOctokitError
+        unless raw
+          builder.use FaradayMiddleware::Mashify
+          builder.use FaradayMiddleware::ParseJson
+        end
+        builder.adapter(adapter)
+      end
+      connection.basic_auth authentication[:login], authentication[:password] if authenticate and authenticated?
+      connection
+    end
+  end
+
+end
+
+
+class GitHubClient < Octokit::Client
+
+  def site
+    @site
+  end
+
+
+  def site=(new_site)
+    @site = new_site
+  end
+
+
+  alias :old_request :request
+
+  def request(method, path, options, version, authenticate, raw, force_urlencoded)
+    if /api.github.com/ !~ site
+      path = "/api/v3#{path}"
+    end
+    old_request(method, path, options, version, authenticate, raw, force_urlencoded)
+  end
+
+end

data/lib/git-process/github-service.rb

@@ -0,0 +1,156 @@
+require 'highline/import'
+require 'github-client'
+require 'uri'
+
+
+module GitHubService
+
+  def client
+    unless @client
+      auth_token
+      logger.debug { "Creating GitHub client for user #{user} using token '#{auth_token}'" }
+      @client = GitHubClient.new(:login => user, :oauth_token=> auth_token)
+      @client.site = site
+    end
+    @client
+  end
+
+
+  def site(opts = {})
+    @site ||= compute_site(opts)
+  end
+
+
+  def compute_site(opts = {})
+    origin_url = lib.config('remote.origin.url')
+
+    raise GitHubService::NoRemoteRepository.new("There is no value set for 'remote.origin.url'") if origin_url.empty?
+
+    if /^git\@/ =~ origin_url
+      host = origin_url.sub(/^git\@(.*?):.*$/, '\1')
+      site = host_to_site(host, false)
+    else
+      uri = URI.parse(origin_url)
+      host = uri.host
+      scheme = uri.scheme
+
+      raise URI::InvalidURIError.new("Need a scheme in URI: '#{origin_url}'") unless scheme
+
+      unless host
+        # assume that the 'scheme' is the named configuration in ~/.ssh/config
+        host = hostname_from_ssh_config(scheme, opts[:ssh_config_file] ||= "#{ENV['HOME']}/.ssh/config")
+      end
+
+      site = host_to_site(host, scheme == 'https')
+    end
+    site
+  end
+
+
+  def hostname_from_ssh_config(host_alias, config_file)
+    config_lines = File.new(config_file).readlines
+
+    in_host_section = false
+    host_name = nil
+
+    sections = config_lines.each do |line|
+      line.chop!
+      if /^\s*Host\s+#{host_alias}\s*$/ =~ line
+          in_host_section = true
+        next
+      end
+      if in_host_section and (/^\s*HostName\s+\S+\s*$/ =~ line)
+        host_name = line.sub(/^\s*HostName\s+(\S+)\s*$/, '\1')
+        break
+      end
+    end
+    host_name
+  end
+
+
+  def host_to_site(host, ssl)
+    if /github.com$/ =~ host
+      'https://api.github.com'
+    else
+      "http#{ssl ? 's' : ''}://#{host}"
+    end
+  end
+
+
+  private :host_to_site, :compute_site
+
+
+  def pw_client
+    unless @pw_client
+      logger.debug { "Creating GitHub client for user #{user} using password #{password}" }
+      @pw_client = GitHubClient.new(:login => user, :password => password)
+      @pw_client.site = site
+    end
+    @pw_client
+  end
+
+
+  def user
+    unless @user
+      user = lib.config('github.user')
+      if user.empty?
+        user = ask("Your <%= color('GitHub', [:bold, :blue]) %> username: ") do |q|
+          q.validate = /^\w\w+$/
+        end
+        lib.config('github.user', user)
+      end
+      @user = user
+    end
+    @user
+  end
+
+
+  def password
+    unless @password
+      @password = ask("Your <%= color('GitHub', [:bold, :blue]) %> password: ") do |q|
+        q.validate = /^\w\w+$/
+        q.echo = 'x'
+      end
+    end
+    @password
+  end
+
+
+  def auth_token
+    @auth_token ||= config_auth_token || create_authorization
+  end
+
+
+  def create_authorization
+    logger.info("Authorizing this to work with your repos.")
+    auth = pw_client.create_authorization(:scopes => ['repo', 'user', 'gist'],
+                                          :note => 'Git-Process',
+                                          :note_url => 'http://jdigger.github.com/git-process')
+    config_auth_token = auth['token']
+    lib.config('gitProcess.github.authToken', config_auth_token)
+    config_auth_token
+  end
+
+
+  def config_auth_token
+    unless @auth_token
+      c_auth_token = lib.config('gitProcess.github.authToken')
+      @auth_token = c_auth_token.empty? ? nil : c_auth_token
+    end
+    @auth_token
+  end
+
+
+  def logger
+    @lib.logger
+  end
+
+
+  class GithubServiceError < StandardError
+  end
+
+
+  class NoRemoteRepository < GithubServiceError
+  end
+
+end

data/lib/git-process/parked-changes-error.rb

@@ -0,0 +1,32 @@
+require 'git-process-error'
+
+module Git
+
+  class Process
+
+    class ParkedChangesError < GitProcessError
+      include Git::AbstractErrorBuilder
+
+      attr_reader :error_message, :lib
+
+      def initialize(lib)
+        @lib = lib
+        msg = build_message
+        super(msg)
+      end
+
+
+      def human_message
+        "You made your changes on the the '_parking_' branch instead of a feature branch.\n"+"Please rename the branch to be a feature branch."
+      end
+
+
+      def build_commands
+        ['git branch -m _parking_ my_feature_branch']
+      end
+
+    end
+
+  end
+
+end

data/lib/git-process/pull-request.rb

@@ -0,0 +1,38 @@
+require 'github-service'
+require 'octokit'
+
+
+module GitHub
+
+  class PullRequest
+    include GitHubService
+
+    attr_reader :lib, :repo
+
+    def initialize(lib, repo, opts = {})
+      @lib = lib
+      @repo = repo
+      @user = opts[:user]
+      @password = opts[:password]
+    end
+
+
+    def pull_requests
+      @pull_requests ||= client.pull_requests(repo)
+    end
+
+
+    def create(base, head, title, body)
+      logger.info { "Creating a pull request asking for '#{head}' to be merged into '#{base}' on #{repo}." }
+      begin
+        client.create_pull_request(repo, base, head, title, body)
+      rescue Octokit::UnprocessableEntity => exp
+        pull = pull_requests.find {|p| p[:head][:ref] == head and p[:base][:ref] == base}
+        logger.warn { "Pull request already exists. See #{pull[:html_url]}" }
+        pull
+      end
+    end
+
+  end
+
+end

data/lib/git-process/uncommitted-changes-error.rb

@@ -0,0 +1,15 @@
+require 'git-process-error'
+
+module Git
+
+  class Process
+
+    class UncommittedChangesError < GitProcessError
+      def initialize()
+        super("There are uncommitted changes.\nPlease either commit your changes, or use 'git stash' to set them aside.")
+      end
+    end
+
+  end
+
+end