git-process-lib 2.0.0

data/lib/git-process/syncer.rb

@@ -0,0 +1,157 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'git-process/git_lib'
+require 'git-process/git_process'
+require 'git-process/parked_changes_error'
+require 'git-process/uncommitted_changes_error'
+require 'git-process/changed_file_helper'
+
+
+module GitProc
+
+  class Syncer
+
+    class << self
+
+      def do_sync(gitlib, opts)
+        if !opts[:merge].nil? and opts[:merge] == opts[:rebase]
+          raise ArgumentError.new(":merge = #{opts[:merge]} and :rebase = #{opts[:rebase]}")
+        end
+
+        local = opts[:local]
+
+        branch_name = opts[:branch_name]
+        checkout_branch(gitlib, branch_name) unless branch_name.nil?
+
+        if do_rebase?(gitlib, opts)
+          rebase_sync(gitlib, local)
+        else
+          merge_sync(gitlib, opts[:force], local)
+        end
+      end
+
+
+      def merge_sync(gitlib, force, local)
+        gitlib.logger.info 'Doing merge-based sync'
+        gitlib.proc_merge(gitlib.config.integration_branch)
+
+        current_branch = gitlib.branches.current
+        remote_branch = "#{gitlib.remote.name}/#{current_branch}"
+
+        runner = lambda { merge_sync(gitlib, force, local) }
+        push_to_server(gitlib, current_branch, remote_branch, force, local, runner)
+      end
+
+
+      def rebase_sync(gitlib, stay_local)
+        gitlib.logger.info 'Doing rebase-based sync'
+
+        current_branch = gitlib.branches.current
+        remote_branch = "#{gitlib.remote.name}/#{current_branch}"
+
+        runner = lambda { rebase_sync(gitlib, stay_local) }
+
+        # if the remote branch has changed, bring in those changes in
+        remote_sha = gitlib.previous_remote_sha(current_branch, remote_branch)
+        if remote_sha.nil?
+          gitlib.logger.debug 'There were no changes on the remote branch.'
+        else
+          handle_remote_rebase_changes(current_branch, gitlib, remote_branch, remote_sha, runner, stay_local)
+        end
+
+        gitlib.proc_rebase(gitlib.config.integration_branch)
+
+        push_to_server(gitlib, current_branch, remote_branch, true, stay_local, runner)
+      end
+
+
+      private
+
+
+      def checkout_branch(gitlib, branch_name)
+        unless gitlib.remote.exists?
+          raise GitProc::GitProcessError.new("Specifying '#{branch_name}' does not make sense without a remote")
+        end
+
+        gitlib.fetch_remote_changes
+
+        remote_branch = "#{gitlib.remote.name}/#{branch_name}"
+
+        unless gitlib.branches.include?(remote_branch)
+          raise GitProc::GitProcessError.new("There is not a remote branch for '#{branch_name}'")
+        end
+
+        if gitlib.branches.include?(branch_name)
+          handle_existing_branch(gitlib, branch_name, remote_branch)
+        else
+          gitlib.logger.debug { "There is not already a local branch named #{branch_name}" }
+          gitlib.checkout(branch_name, :new_branch => remote_branch, :no_track => true)
+        end
+
+        gitlib.branches[branch_name].upstream(gitlib.config.integration_branch)
+      end
+
+
+      def handle_existing_branch(gitlib, branch_name, remote_branch)
+        if gitlib.branches[remote_branch].contains_all_of(branch_name)
+          gitlib.logger.info "There is already a local branch named #{branch_name} and it is fully subsumed by #{remote_branch}"
+          gitlib.checkout(branch_name)
+        else
+          raise GitProc::GitProcessError.new("There is already a local branch named #{branch_name} that is not fully subsumed by #{remote_branch}")
+        end
+      end
+
+
+      def handle_remote_rebase_changes(current_branch, gitlib, remote_branch, remote_sha, runner, stay_local)
+        gitlib.logger.info 'There have been changes on the remote branch, so will bring them in.'
+        gitlib.proc_rebase(remote_branch, :oldbase => remote_sha)
+
+        push_to_server(gitlib, current_branch, remote_branch, true, stay_local, runner)
+      end
+
+
+      def do_rebase?(gitlib, opts)
+        if opts[:rebase].nil?
+          gitlib.config.default_rebase_sync?
+        else
+          opts[:rebase]
+        end
+      end
+
+
+      def push_to_server(gitlib, current_branch, remote_branch, force, local, runner)
+        gitlib.push_to_server(current_branch, current_branch,
+                              :local => local,
+                              :force => force,
+                              :prepush => lambda { handle_remote_changed(gitlib, current_branch, remote_branch, runner) },
+                              :postpush => lambda { gitlib.write_sync_control_file(current_branch) }
+        )
+      end
+
+
+      def handle_remote_changed(gitlib, current_branch, remote_branch, runner)
+        old_sha = gitlib.remote_branch_sha(remote_branch)
+        gitlib.fetch_remote_changes
+        new_sha = gitlib.remote_branch_sha(remote_branch)
+
+        if old_sha != new_sha
+          gitlib.logger.warn("'#{current_branch}' changed on '#{gitlib.remote.name}'; trying sync again.")
+          runner.call # try again
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/git-process/uncommitted_changes_error.rb

@@ -0,0 +1,23 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'git-process/git_process_error'
+
+module GitProc
+
+  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

data/lib/git-process/version.rb

@@ -0,0 +1,22 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module GitProc
+  module Version
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
+    BUILD = nil
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/local-build.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require File.expand_path('../lib/git-process/version', __FILE__)
+
+gems = %w(git-process-lib git-sync git-to-master git-new-fb git-pull-request git-process)
+
+%x[rake manpage 2>&1]
+
+for gem in gems.reverse
+  %x[gem uninstall #{gem} -x -v #{GitProc::Version::STRING} 2>&1]
+end
+
+for gem in gems
+  puts %x(a2x -f manpage -D man docs/#{gem}.1.adoc)
+  SystemExit.new($?) if $?.exitstatus
+
+  %x[gem build #{gem}.gemspec]
+  SystemExit.new($?) if $?.exitstatus
+end
+
+puts %x(gem install ./git-process-#{GitProc::Version::STRING}.gem -l -u)
+SystemExit.new($?) if $?.exitstatus
+
+puts %x(gem push ./git-process-#{GitProc::Version::STRING}.gem -l -u)
+SystemExit.new($?) if $?.exitstatus

data/spec/FileHelpers.rb

@@ -0,0 +1,19 @@
+require 'tmpdir'
+include FileUtils
+
+module FileHelpers
+  TEST_DIR = File.dirname(__FILE__)
+
+
+  def dir_files(dir)
+    Dir.entries(dir).grep(/^[^.]/)
+  end
+
+
+  def compare_files(file1name, file2name)
+    str1 = IO.read(file1name)
+    str2 = IO.read(file2name)
+    str1.should == str2
+  end
+
+end

data/spec/GitRepoHelper.rb

@@ -0,0 +1,123 @@
+require 'tmpdir'
+require 'FileHelpers'
+require 'git-process/git_process'
+include GitProc
+
+module GitRepoHelper
+
+  def gitprocess
+    if @gitprocess.nil? and respond_to?(:create_process)
+      @gitprocess = create_process(gitlib, :log_level => log_level)
+    end
+    @gitprocess
+  end
+
+
+  def gitlib
+    if @gitlib.nil?
+      if @gitprocess.nil?
+        @gitlib = create_gitlib(Dir.mktmpdir, :log_level => log_level)
+      else
+        @gitlib = gitprocess.gitlib
+      end
+    end
+    @gitlib
+  end
+
+
+  def config
+    gitlib.config
+  end
+
+
+  def remote
+    gitlib.remote
+  end
+
+
+  def commit_count
+    gitlib.log_count
+  end
+
+
+  def log_level
+    Logger::ERROR
+  end
+
+
+  def logger
+    gitlib.logger
+  end
+
+
+  def create_files(file_names)
+    GitRepoHelper.create_files gitlib, file_names
+  end
+
+
+  def self.create_files(gitlib, file_names)
+    Dir.chdir(gitlib.workdir) do |dir|
+      file_names.each do |fn|
+        gitlib.logger.debug { "Creating #{dir}/#{fn}" }
+        FileUtils.touch fn
+      end
+    end
+    gitlib.add(file_names)
+  end
+
+
+  def change_file(filename, contents, lib = gitlib)
+    Dir.chdir(lib.workdir) do
+      File.open(filename, 'w') { |f| f.puts contents }
+    end
+  end
+
+
+  def change_file_and_add(filename, contents, lib = gitlib)
+    change_file(filename, contents, lib)
+    lib.add(filename)
+  end
+
+
+  def change_file_and_commit(filename, contents, lib = gitlib)
+    change_file_and_add(filename, contents, lib)
+    lib.commit("#{filename} - #{contents}")
+  end
+
+
+  def create_gitlib(dir, opts)
+    git_lib = GitLib.new(dir, opts)
+    git_lib.config['user.email'] = 'test.user@test.com'
+    git_lib.config['user.name'] = 'test user'
+    git_lib
+  end
+
+
+  def clone_repo(branch='master', remote_name = 'origin', &block)
+    td = Dir.mktmpdir
+
+    logger.debug { "Cloning '#{gitlib.workdir}' to '#{td}'" }
+
+    gl = create_gitlib(td, :log_level => logger.level)
+    gl.remote.add(remote_name, "file://#{gitlib.workdir}")
+    gl.fetch(remote_name)
+
+    if branch == 'master'
+      gl.reset("#{remote_name}/#{branch}", :hard => true)
+    else
+      gl.checkout(branch, :new_branch => "#{remote_name}/#{branch}")
+    end
+
+    if block_given?
+      begin
+        block.arity < 1 ? gl.instance_eval(&block) : block.call(gl)
+      ensure
+        rm_rf(gl.workdir)
+      end
+      nil
+    else
+      gl
+    end
+  end
+
+end

data/spec/changed_file_helper_spec.rb

@@ -0,0 +1,127 @@
+require 'git-process/sync_process'
+include GitProc
+
+describe ChangeFileHelper, :git_repo_helper do
+
+  def log_level
+    Logger::ERROR
+  end
+
+
+  #noinspection RubyUnusedLocalVariable
+  def create_process(dir, opts)
+    nil
+  end
+
+
+  describe 'uncommitted changes' do
+
+    it 'should fail when there are unmerged files' do
+      change_file_and_commit('modified file.txt', 'start')
+
+      clone_repo do |gl|
+        change_file_and_commit('modified file.txt', 'changed', gl)
+        change_file_and_commit('modified file.txt', 'conflict', gitlib)
+        gl.fetch
+
+        gl.merge('origin/master') rescue ''
+
+        change_file_helper = ChangeFileHelper.new(gl)
+        expect { change_file_helper.offer_to_help_uncommitted_changes }.to raise_error GitProc::UncommittedChangesError
+      end
+    end
+
+
+    def change_file_helper
+      @change_file_helper ||= ChangeFileHelper.new(gitlib)
+    end
+
+
+    describe "using 'unknown' file" do
+
+      before(:each) do
+        change_file('unknown file.txt', '')
+        change_file_helper.stub(:say)
+      end
+
+
+      it 'should then add it' do
+        ChangeFileHelper.stub(:ask_how_to_handle_unknown_files).and_return(:add)
+        change_file_helper.gitlib.should_receive(:add).with(['unknown file.txt'])
+
+        change_file_helper.offer_to_help_uncommitted_changes
+      end
+
+
+      it 'should ignore the file' do
+        ChangeFileHelper.stub(:ask_how_to_handle_unknown_files).and_return(:ignore)
+        change_file_helper.should_not_receive(:add)
+
+        change_file_helper.offer_to_help_uncommitted_changes
+      end
+
+    end
+
+
+    describe "using changed files" do
+
+      before(:each) do
+        change_file_and_commit('modified file.txt', 'start')
+        change_file_and_commit('modified file2.txt', 'start')
+        change_file_and_commit('modified file3.txt', 'start')
+        change_file_and_commit('modified file4.txt', 'start')
+        change_file_and_commit('removed file.txt', 'content')
+        change_file_and_add('added file.txt', '')
+        change_file('modified file.txt', 'modified')
+        change_file_and_add('modified file2.txt', 'modified')
+        change_file_and_add('modified file3.txt', 'modified')
+        change_file('modified file2.txt', 'modified again')
+        change_file_and_add('removed file2.txt', 'content')
+        change_file_and_add('modified file4.txt', 'content')
+        File.delete(File.join(gitlib.workdir, 'removed file.txt'))
+        File.delete(File.join(gitlib.workdir, 'removed file2.txt'))
+        File.delete(File.join(gitlib.workdir, 'modified file3.txt'))
+
+        # End state of the above is:
+        # A  "added file.txt"
+        #  M "modified file.txt"
+        # MM "modified file2.txt"
+        # MD "modified file3.txt"
+        # M  "modified file4.txt"
+        #  D "removed file.txt"
+        # AD "removed file2.txt"
+
+        change_file_helper.stub(:say)
+      end
+
+
+      it 'should ask about modified files, then commit them' do
+        ChangeFileHelper.stub(:ask_how_to_handle_changed_files).and_return(:commit)
+        gitlib.should_receive(:add).with(["added file.txt", "modified file.txt", "modified file2.txt", "modified file4.txt"])
+        gitlib.should_receive(:remove).with(["modified file3.txt", "removed file.txt", "removed file2.txt"])
+        gitlib.should_receive(:commit).with(nil)
+
+        change_file_helper.offer_to_help_uncommitted_changes
+      end
+
+
+      it 'should ask about modified files, then stash them' do
+        ChangeFileHelper.stub(:ask_how_to_handle_changed_files).and_return(:stash)
+
+        change_file_helper.offer_to_help_uncommitted_changes
+
+        gitlib.status.clean?.should be_true
+
+        gitlib.stash_pop
+
+        stat = gitlib.status
+        stat.added.should == ["added file.txt", "removed file2.txt"]
+        stat.modified.should == ["modified file.txt", "modified file2.txt", "modified file4.txt"]
+        stat.deleted.should == ["modified file3.txt", "removed file.txt"]
+      end
+
+    end
+
+  end
+
+end