autobuild 1.8.3 → 1.9.0.b1

data/lib/autobuild/import/cvs.rb

@@ -16,7 +16,6 @@ module Autobuild
                 raise ArgumentError, "no module given"
             end
 
-            @program    = Autobuild.tool('cvs')
             @options_up = cvsopts[:cvsup] || '-dP'
             @options_up = Array[*@options_up]
             @options_co = cvsopts[:cvsco] || '-P'
@@ -34,31 +33,32 @@ module Autobuild
 
         private
 
-        def update(package,only_local=false) # :nodoc:
-            if only_local
-                Autobuild.warn "The importer #{self.class} does not support local updates, skipping #{self}"
+        def update(package, options = Hash.new) # :nodoc:
+            if options[:only_local]
+                package.warn "%s: the CVS importer does not support local updates, skipping"
                 return
             end
-            Dir.chdir(package.srcdir) do
-		if !File.exists?("#{package.srcdir}/CVS/Root")
-		    raise ConfigException.new(package, 'import'), "#{package.srcdir} is not a CVS working copy"
-		end
 
-		root = File.open("#{package.srcdir}/CVS/Root") { |io| io.read }.chomp
-		mod  = File.open("#{package.srcdir}/CVS/Repository") { |io| io.read }.chomp
+            if !File.exist?("#{package.srcdir}/CVS/Root")
+                raise ConfigException.new(package, 'import'), "#{package.srcdir} is not a CVS working copy"
+            end
+
+            root = File.open("#{package.srcdir}/CVS/Root") { |io| io.read }.chomp
+            mod  = File.open("#{package.srcdir}/CVS/Repository") { |io| io.read }.chomp
 
-		# Remove any :ext: in front of the root
-		root = root.gsub /^:ext:/, ''
-		expected_root = @root.gsub /^:ext:/, ''
-		# Remove the optional ':' between the host and the path
-		root = root.gsub /:/, ''
-		expected_root = expected_root.gsub /:/, ''
+            # Remove any :ext: in front of the root
+            root = root.gsub(/^:ext:/, '')
+            expected_root = @root.gsub(/^:ext:/, '')
+            # Remove the optional ':' between the host and the path
+            root = root.gsub(/:/, '')
+            expected_root = expected_root.gsub(/:/, '')
 
-		if root != expected_root || mod != @module
-		    raise ConfigException.new(package, 'import'), "checkout in #{package.srcdir} is from #{root}:#{mod}, was expecting #{expected_root}:#{@module}"
-		end
-                Subprocess.run(package, :import, @program, 'up', *@options_up)
-	    end
+            if root != expected_root || mod != @module
+                raise ConfigException.new(package, 'import'),
+                    "checkout in #{package.srcdir} is from #{root}:#{mod}, was expecting #{expected_root}:#{@module}"
+            end
+            package.run(:import, Autobuild.tool(:cvs), 'up', *@options_up,
+                        retry: true, working_directory: package.importdir)
         end
 
         def checkout(package) # :nodoc:
@@ -66,21 +66,19 @@ module Autobuild
             cvsroot = @root
                
             FileUtils.mkdir_p(head) if !File.directory?(head)
-            Dir.chdir(head) do
-                options = [ @program, '-d', cvsroot, 'co', '-d', tail ] + @options_co + [ modulename ]
-                Subprocess.run(package, :import, *options)
-	    end
+            package.run(:import, Autobuild.tool(:cvs), '-d', cvsroot, 'co', '-d', tail, *@options_co, modulename,
+                retry: true, working_directory: head)
         end
     end
 
     # Returns the CVS importer which will get the +name+ module in repository
     # +repo+. The allowed values in +options+ are described in CVSImporter.new.    
-    def self.cvs(module_name, options = {}, backward_compatibility = nil)
+    def self.cvs(root, options = {}, backward_compatibility = nil)
         if backward_compatibility
             backward_compatibility[:module] = options
-            CVSImporter.new(module_name, backward_compatibility)
+            CVSImporter.new(root, backward_compatibility)
         else
-            CVSImporter.new(module_name, options)
+            CVSImporter.new(root, options)
         end
     end
 end

data/lib/autobuild/import/darcs.rb

@@ -22,17 +22,18 @@ module Autobuild
         
         private
 
-        def update(package,only_local=false) # :nodoc:
-            if only_local
-                Autobuild.warn "The importer #{self.class} does not support local updates, skipping #{self}"
+        def update(package, options = Hash.new) # :nodoc:
+            if options[:only_local]
+                package.warn "%s: the darcs importer does not support local updates, skipping"
                 return
             end
 	    if !File.directory?( File.join(package.srcdir, '_darcs') )
-		raise ConfigException.new(package, 'import'), "#{package.srcdir} is not a Darcs repository"
+		raise ConfigException.new(package, 'import'),
+                    "#{package.srcdir} is not a Darcs repository"
 	    end
 
-	    Subprocess.run(package, :import, @program, 
-	       'pull', '--all', "--repodir=#{package.srcdir}", '--set-scripts-executable', @source, *@pull)
+	    package.run(:import, @program, 
+	       'pull', '--all', "--repodir=#{package.srcdir}", '--set-scripts-executable', @source, *@pull, retry: true)
         end
 
         def checkout(package) # :nodoc:
@@ -41,8 +42,8 @@ module Autobuild
 		FileUtils.mkdir_p(basedir)
 	    end
 
-	    Subprocess.run(package, :import, @program, 
-	       'get', '--set-scripts-executable', @source, package.srcdir, *@get)
+	    package.run(:import, @program, 
+	       'get', '--set-scripts-executable', @source, package.srcdir, *@get, retry: true)
         end
     end
 

data/lib/autobuild/import/git.rb

@@ -35,6 +35,46 @@ module Autobuild
             end
         end
 
+        # Returns the git version as a string
+        #
+        # @return [String]
+        def self.version
+            version = Subprocess.run('git', 'setup', Autobuild.tool(:git), '--version').first
+            if version =~ /^git version (\d[\d\.]+)/
+                $1.split(".").map { |i| Integer(i) }
+            else
+                raise ArgumentError, "cannot parse git version string #{version}, was expecting something looking like 'git version 2.1.0'"
+            end
+        end
+
+        # Helper method to compare two (partial) versions represented as array
+        # of integers
+        #
+        # @return [Integer] -1 if actual is greater than required, 
+        #   0 if equal, and 1 if actual is smaller than required
+        def self.compare_versions(actual, required)
+            if actual.size > required.size
+                return -compare_versions(required, actual)
+            end
+
+            actual += [0] * (required.size - actual.size)
+            actual.zip(required).each do |v_act, v_req|
+                if v_act > v_req then return -1
+                elsif v_act < v_req then return 1
+                end
+            end
+            0
+        end
+
+        # Tests the git version
+        #
+        # @param [Array<Integer>] version the git version as an array of integer
+        # @return [Boolean] true if the git version is at least the requested
+        #   one, and false otherwise
+        def self.at_least_version(*version)
+            compare_versions(self.version, version) <= 0
+        end
+
         # Creates an importer which tracks the given repository
         # and branch. +source+ is [repository, branch]
         #
@@ -47,8 +87,7 @@ module Autobuild
             @git_dir_cache = Array.new
 
             if branch.respond_to?(:to_hash)
-                options = branch.to_hash
-                branch = nil
+                branch, options = nil, branch.to_hash
             end
 
             if branch
@@ -64,27 +103,19 @@ module Autobuild
                 branch: nil,
                 tag: nil,
                 commit: nil,
+                repository_id: nil,
+                source_id: nil,
                 with_submodules: false
             if gitopts[:branch] && branch
                 raise ConfigException, "git branch specified with both the option hash and the explicit parameter"
             end
-
-            sourceopts, common = Kernel.filter_options common,
-                :repository_id, :source_id
+            gitopts[:branch] ||= branch
 
             super(common)
 
-            @push_to = gitopts[:push_to]
-            @with_submodules = gitopts[:with_submodules]
-            branch = gitopts[:branch] || branch
-            tag    = gitopts[:tag]
-            commit = gitopts[:commit]
-
-            @branch = branch || 'master'
-            @tag    = tag
-            @commit = commit
+            @with_submodules = gitopts.delete(:with_submodules)
             @remote_name = 'autobuild'
-            relocate(repository, sourceopts)
+            relocate(repository, gitopts)
         end
 
         # The name of the remote that should be set up by the importer
@@ -159,12 +190,12 @@ module Autobuild
         # The tag we are pointing to. It is a tag name.
         #
         # If set, both branch and commit have to be nil.
-        attr_reader :tag
+        attr_accessor :tag
 
         # The commit we are pointing to. It is a commit ID.
         #
         # If set, both branch and tag have to be nil.
-        attr_reader :commit
+        attr_accessor :commit
 
         # True if it is allowed to merge remote updates automatically. If false
         # (the default), the import will fail if the updates do not resolve as
@@ -192,7 +223,7 @@ module Autobuild
         #  :bare or :normal, or nil if path is not a git repository.
         def self.resolve_git_dir(path)
             dir = File.join(path, '.git')
-            if !File.exists?(dir)
+            if !File.exist?(dir)
                 dir = path
             end
 
@@ -213,74 +244,108 @@ module Autobuild
             end
 
             @git_dir_cache = [package.importdir, dir, style]
+            self.class.validate_git_dir(package, require_working_copy, dir, style)
+            dir
+        end
+
+        def self.git_dir(package, require_working_copy)
+            dir, style = Git.resolve_git_dir(package.importdir)
+            validate_git_dir(package, require_working_copy, dir, style)
+            dir
+        end
+
+        # Validates the return value of {resolve_git_dir}
+        #
+        # @param [Package] package the package we are working on
+        # @param [Boolean] require_working_copy if false, a bare repository will
+        #   be considered as valid, otherwise not
+        # @param [String,nil] dir the path to the repository's git directory, or nil
+        #   if the target is not a valid repository (see the documentation of
+        #   {resolve_git_dir}
+        # @param [Symbol,nil] style either :normal for a git checkout with
+        #   working copy, :bare for a bare repository or nil if {resolve_git_dir}
+        #   did not detect a git repository
+        #
+        # @return [void]
+        # @raise ConfigException if dir/style are nil, or if
+        #   require_working_copy is true and style is :bare
+        def self.validate_git_dir(package, require_working_copy, dir, style)
             if !style
-                raise ConfigException.new(package, 'import'), "while importing #{package.name}, #{package.importdir} does not point to a git repository"
+                raise ConfigException.new(package, 'import', retry: false),
+                    "while importing #{package.name}, #{package.importdir} does not point to a git repository"
             elsif require_working_copy && (style == :bare)
-                raise ConfigException.new(package, 'import'), "while importing #{package.name}, #{package.importdir} points to a bare git repository but a working copy was required"
-            else
-                return dir
+                raise ConfigException.new(package, 'import', retry: false),
+                    "while importing #{package.name}, #{package.importdir} points to a bare git repository but a working copy was required"
             end
         end
 
         # Computes the merge status for this package between two existing tags
         # Raises if a tag is unknown
         def delta_between_tags(package, from_tag, to_tag)
-            Dir.chdir(package.importdir) do
-                pkg_tags = tags(package)
-                if not pkg_tags.has_key?(from_tag)
-                    raise ArgumentError, "tag '#{from_tag}' is unknown to #{package.name} -- known tags are: #{pkg_tags.keys}"
-                end
-                if not pkg_tags.has_key?(to_tag)
-                    raise ArgumentError, "tag '#{to_tag}' is unknown to #{package.name} -- known tags are: #{pkg_tags.keys}"
-                end
+            pkg_tags = tags(package)
+            if not pkg_tags.has_key?(from_tag)
+                raise ArgumentError, "tag '#{from_tag}' is unknown to #{package.name} -- known tags are: #{pkg_tags.keys}"
+            end
+            if not pkg_tags.has_key?(to_tag)
+                raise ArgumentError, "tag '#{to_tag}' is unknown to #{package.name} -- known tags are: #{pkg_tags.keys}"
+            end
 
-                from_commit = pkg_tags[from_tag]
-                to_commit = pkg_tags[to_tag]
+            from_commit = pkg_tags[from_tag]
+            to_commit = pkg_tags[to_tag]
 
-                merge_status(package, to_commit, from_commit)
-           end
+            merge_status(package, to_commit, from_commit)
         end
 
         # Retrieve the tags of this packages as a hash mapping to the commit id
         def tags(package)
-            Dir.chdir(package.importdir) do
-                `git fetch --tags -q`
-                tag_list = `git show-ref --tags`
-                tag_list = tag_list.split("\n")
-                @tags ||= Hash.new
-                tag_list.each do |entry|
-                    commit_to_tag = entry.split(" ")
-                    @tags[commit_to_tag[1].sub("refs/tags/","")] = commit_to_tag[0]
-                end
-                @tags
+            run_git_bare(package, 'fetch', '--tags')
+            tag_list = run_git_bare(package, 'show-ref', '--tags').map(&:strip)
+            tags = Hash.new
+            tag_list.each do |entry|
+                commit_to_tag = entry.split(" ")
+                tags[commit_to_tag[1].sub("refs/tags/","")] = commit_to_tag[0]
+            end
+            tags
+        end
+
+        def run_git(package, *args)
+            self.class.run_git(package, *args)
+        end
+
+        def self.run_git(package, *args)
+            options = Hash.new
+            if args.last.kind_of?(Hash)
+                options = args.pop
             end
+
+            working_directory = File.dirname(git_dir(package, true))
+            package.run(:import, Autobuild.tool(:git), *args,
+                        Hash[working_directory: working_directory].merge(options))
+        end
+
+        def run_git_bare(package, *args)
+            self.class.run_git_bare(package, *args)
         end
 
-        def update_cache(package, cache_dir, phase)
-            remote_name = package.name.gsub(/[^\w]/, '_')
-            Subprocess.run(*git, "remote.#{remote_name}.url", repository)
-            Subprocess.run(*git, "remote.#{remote_name}.fetch",  "+refs/heads/*:refs/remotes/#{remote_name}/*")
-            Subprocess.run(*git, 'fetch', '--tags', remote_name)
+        def self.run_git_bare(package, *args)
+            package.run(:import, Autobuild.tool(:git), '--git-dir', git_dir(package, false), *args)
         end
 
         # Updates the git repository's configuration for the target remote
-        def update_remotes_configuration(package, phase)
-            git = [package, phase, Autobuild.tool(:git), '--git-dir', git_dir(package, false), 'config', '--replace-all']
-            Subprocess.run(*git, "remote.#{remote_name}.url", repository)
-            if push_to
-                Subprocess.run(*git, "remote.#{remote_name}.pushurl", push_to)
-            end
-            Subprocess.run(*git, "remote.#{remote_name}.fetch",  "+refs/heads/*:refs/remotes/#{remote_name}/*")
+        def update_remotes_configuration(package)
+            run_git_bare(package, 'config', '--replace-all', "remote.#{remote_name}.url", repository)
+            run_git_bare(package, 'config', '--replace-all', "remote.#{remote_name}.pushurl", push_to || repository)
+            run_git_bare(package, 'config', '--replace-all', "remote.#{remote_name}.fetch",  "+refs/heads/*:refs/remotes/#{remote_name}/*")
 
             if remote_branch && local_branch
-                Subprocess.run(*git, "remote.#{remote_name}.push",  "refs/heads/#{local_branch}:refs/heads/#{remote_branch}")
+                run_git_bare(package, 'config', '--replace-all', "remote.#{remote_name}.push",  "refs/heads/#{local_branch}:refs/heads/#{remote_branch}")
             else
-                Subprocess.run(*git, "remote.#{remote_name}.push",  "refs/heads/*:refs/heads/*")
+                run_git_bare(package, 'config', '--replace-all', "remote.#{remote_name}.push",  "refs/heads/*:refs/heads/*")
             end
 
             if local_branch
-                Subprocess.run(*git, "branch.#{local_branch}.remote",  remote_name)
-                Subprocess.run(*git, "branch.#{local_branch}.merge", "refs/heads/#{local_branch}")
+                run_git_bare(package, 'config', '--replace-all', "branch.#{local_branch}.remote",  remote_name)
+                run_git_bare(package, 'config', '--replace-all', "branch.#{local_branch}.merge", "refs/heads/#{local_branch}")
             end
         end
 
@@ -290,7 +355,6 @@ module Autobuild
         def fetch_remote(package)
             validate_importdir(package)
             git_dir = git_dir(package, false)
-            git = [package, :import, Autobuild.tool('git'), '--git-dir', git_dir]
 
             # If we are checking out a specific commit, we don't know which
             # branch to refer to in git fetch. So, we have to set up the
@@ -303,9 +367,9 @@ module Autobuild
             # configuration parameters only if the repository and branch are
             # OK (i.e. we keep old working configuration instead)
             refspec = [branch || tag].compact
-            Subprocess.run(*git, 'fetch', '--tags', repository, *refspec)
+            run_git_bare(package, 'fetch', '--tags', repository, *refspec, retry: true)
 
-            update_remotes_configuration(package, :import)
+            update_remotes_configuration(package)
 
             # Now get the actual commit ID from the FETCH_HEAD file, and
             # return it
@@ -319,85 +383,117 @@ module Autobuild
 
             # Update the remote tag if needs be
             if branch && commit_id
-                Subprocess.run(*git, 'update-ref',
-                               "-m", "updated by autobuild", "refs/remotes/#{remote_name}/#{remote_branch}", commit_id)
+                run_git_bare(package, 'update-ref', "-m", "updated by autobuild", "refs/remotes/#{remote_name}/#{remote_branch}", commit_id)
             end
 
             commit_id
         end
 
         def self.has_uncommitted_changes?(package, with_untracked_files = false)
-            Dir.chdir(package.importdir) do
-                status = `git status --porcelain`.split("\n").map(&:strip)
-                if with_untracked_files
-                    !status.empty?
-                else
-                    status.any? { |l| l[0, 2] !~ /^\?\?|^  / }
+            status = run_git(package, 'status', '--porcelain').map(&:strip)
+            if with_untracked_files
+                !status.empty?
+            else
+                status.any? { |l| l[0, 2] !~ /^\?\?|^  / }
+            end
+        end
+
+        # Returns the commit ID of what we should consider being the remote
+        # commit
+        #
+        # @param [Package] package
+        # @param [Boolean] only_local if true, no remote access should be
+        #   performed, in which case the current known state of the remote will be
+        #   used. If false, we access the remote repository to fetch the actual
+        #   commit ID
+        # @return [String] the commit ID as a string
+        def current_remote_commit(package, only_local = false)
+            if only_local
+                begin
+                    run_git_bare(package, 'show-ref', '-s', "refs/remotes/#{remote_name}/#{remote_branch}").first.strip
+                rescue SubcommandFailed
+                    raise PackageException.new(package, "import"), "cannot resolve remote HEAD #{remote_name}/#{remote_branch}"
+                end
+            else	
+                begin fetch_remote(package)
+                rescue Exception => e
+                    return fallback(e, package, :status, package, only_local)
                 end
             end
         end
 
+
         # Returns a Importer::Status object that represents the status of this
         # package w.r.t. the root repository
         def status(package, only_local = false)
-            Dir.chdir(package.importdir) do
-                validate_importdir(package)
-                remote_commit = nil
-                if only_local
-                    remote_commit = `git show-ref -s refs/remotes/#{remote_name}/#{remote_branch}`.chomp
-                else	
-                    remote_commit =
-                        begin fetch_remote(package)
-                        rescue Exception => e
-                            return fallback(e, package, :status, package, only_local)
-                        end
-
-                    if !remote_commit
-                        return
-                    end
-                end
+            validate_importdir(package)
+            remote_commit = current_remote_commit(package, only_local)
+            status = merge_status(package, remote_commit)
+            status.uncommitted_code = self.class.has_uncommitted_changes?(package)
+            status
+        end
 
-                status = merge_status(package, remote_commit)
-                status.uncommitted_code = self.class.has_uncommitted_changes?(package)
-                status
+        def has_commit?(package, commit_id)
+            run_git_bare(package, 'rev-parse', '-q', '--verify', "#{commit_id}^{commit}")
+            true
+        rescue SubcommandFailed => e
+            if e.status == 1
+                false
+            else raise
             end
+        end
 
+        def has_branch?(package, branch_name)
+            run_git_bare(package, 'show-ref', '-q', '--verify', "refs/heads/#{branch_name}")
+            true
+        rescue SubcommandFailed => e
+            if e.status == 1
+                false
+            else raise
+            end
         end
 
-        def has_local_branch?
-            `git show-ref -q --verify refs/heads/#{local_branch}`
-            $?.exitstatus == 0
+        def has_local_branch?(package)
+            has_branch?(package, local_branch)
         end
 
-        def detached_head?
-            `git symbolic-ref HEAD -q`
-            return ($?.exitstatus != 0)
+        def detached_head?(package)
+            current_branch(package).nil?
         end
 
-        def current_branch
-            current_branch = `git symbolic-ref HEAD -q`.chomp
-            if $?.exitstatus != 0
-                # HEAD cannot be resolved as a symbol. We are probably on a
-                # detached HEAD
+        # Returns the branch HEAD is pointing to
+        #
+        # @return [String,nil] the full ref HEAD is pointing to (i.e.
+        #   refs/heads/master), or nil if HEAD is detached
+        # @raises SubcommandFailed if git failed
+        def current_branch(package)
+            run_git_bare(package, 'symbolic-ref', 'HEAD', '-q').first.strip
+        rescue SubcommandFailed => e
+            if e.status == 1
                 return
+            else raise
             end
-            return current_branch
         end
 
         # Checks if the current branch is the target branch. Expects that the
         # current directory is the package's directory
-        def on_target_branch?
-            if current_branch = self.current_branch
+        def on_local_branch?(package)
+            if current_branch = self.current_branch(package)
                 current_branch == "refs/heads/#{local_branch}"
             end
         end
 
+        # @deprecated use on_local_branch? instead
+        def on_target_branch?(package)
+            on_local_branch?(package)
+        end
+
         class Status < Importer::Status
             attr_reader :fetch_commit
             attr_reader :head_commit
             attr_reader :common_commit
 
-            def initialize(status, remote_commit, local_commit, common_commit)
+            def initialize(package, status, remote_commit, local_commit, common_commit)
                 super()
                 @status        = status
                 @fetch_commit  = fetch_commit
@@ -405,10 +501,10 @@ module Autobuild
                 @common_commit = common_commit
 
                 if remote_commit != common_commit
-                    @remote_commits = log(common_commit, remote_commit)
+                    @remote_commits = log(package, common_commit, remote_commit)
                 end
                 if local_commit != common_commit
-                    @local_commits = log(common_commit, local_commit)
+                    @local_commits = log(package, common_commit, local_commit)
                 end
             end
 
@@ -416,26 +512,42 @@ module Autobuild
                 status == Status::NEEDS_MERGE || status == Status::SIMPLE_UPDATE
             end
 
-            def log(from, to)
-                log = `git log --encoding=UTF-8 --pretty=format:"%h %cr %cn %s" #{from}..#{to}`.chomp
-
-                if log.respond_to?(:encode)
-                    log = log.encode
-                end
-
-                encodings = ['UTF-8', 'iso8859-1']
-                begin
-                    log.split("\n")
-                rescue
-                    if encodings.empty?
-                        return "[some log messages have invalid characters, cannot display/parse them]"
-                    end
-                    log.force_encoding(encodings.pop)
-                    retry
+            def log(package, from, to)
+                log = package.importer.run_git_bare(package, 'log', '--encoding=UTF-8', "--pretty=format:%h %cr %cn %s", "#{from}..#{to}")
+                log.map do |line|
+                    line.strip.encode
                 end
             end
         end
 
+        def rev_parse(package, name)
+            run_git_bare(package, 'rev-parse', name).first
+        rescue Autobuild::SubcommandFailed
+            raise PackageException.new(package, 'import'), "failed to resolve #{name}. Are you sure this commit, branch or tag exists ?"
+        end
+
+        def show(package, commit, path)
+            run_git_bare(package, 'show', "#{commit}:#{path}").join("\n")
+        rescue Autobuild::SubcommandFailed
+            raise PackageException.new(package, 'import'), "failed to either resolve commit #{commit} or file #{path}"
+        end
+
+        # Tests whether a commit is already present in a given history
+        #
+        # @param [Package] the package we are working on
+        # @param [String] commit the commit ID we want to verify the presence of
+        # @param [String] reference the reference commit. The method tests that
+        #   'commit' is present in the history of 'reference'
+        #
+        # @return [Boolean]
+        def commit_present_in?(package, commit, reference)
+            merge_base = run_git_bare(package, 'merge-base', commit, reference).first
+            merge_base == commit
+            
+        rescue Exception
+            raise PackageException.new(package, 'import'), "failed to find the merge-base between #{commit} and #{reference}. Are you sure these commits exist ?"
+        end
+
         # Computes the update status to update a branch whose tip is at
         # reference_commit (which can be a symbolic reference) using the
         # fetch_commit commit
@@ -446,16 +558,15 @@ module Autobuild
         #   git merge fetch_commit
         #
         def merge_status(package, fetch_commit, reference_commit = "HEAD")
-            common_commit = `git merge-base #{reference_commit} #{fetch_commit}`.chomp
-            if $?.exitstatus != 0
+            begin
+                common_commit = run_git_bare(package, 'merge-base', reference_commit, fetch_commit).first.strip
+            rescue Exception
                 raise PackageException.new(package, 'import'), "failed to find the merge-base between #{reference_commit} and #{fetch_commit}. Are you sure these commits exist ?"
             end
-            head_commit   = `git rev-parse #{reference_commit}`.chomp
-            if $?.exitstatus != 0
-                raise PackageException.new(package, 'import'), "failed to resolve #{reference_commit}. Are you sure this commit, branch or tag exists ?"
-            end
+            remote_commit = rev_parse(package, fetch_commit)
+            head_commit   = rev_parse(package, reference_commit)
 
-            status = if common_commit != fetch_commit
+            status = if common_commit != remote_commit
                          if common_commit == head_commit
                              Status::SIMPLE_UPDATE
                          else
@@ -469,7 +580,7 @@ module Autobuild
                          end
                      end
 
-            Status.new(status, fetch_commit, head_commit, common_commit)
+            Status.new(package, status, fetch_commit, head_commit, common_commit)
         end
 
         # Updates the git alternates file in the already checked out package to
@@ -506,78 +617,96 @@ module Autobuild
             end
         end
 
-        def update(package,only_local = false)
+        def commit_pinning(package, target_commit, fetch_commit)
+            current_head = rev_parse(package, 'HEAD')
+
+            # Check whether the current HEAD is present on the remote
+            # repository. We'll refuse resetting if there are uncommitted
+            # changes
+            head_to_remote = merge_status(package, fetch_commit, current_head)
+            status_to_remote = head_to_remote.status
+            if status_to_remote == Status::ADVANCED || status_to_remote == Status::NEEDS_MERGE
+                raise ImporterCannotReset.new(package, 'import'), "branch #{local_branch} of #{package.name} contains commits that do not seem to be present on the branch #{remote_branch} of the remote repository. I can't go on as it could make you loose some stuff. Update the remote branch in your overrides, push your changes or reset to the remote commit manually before trying again"
+            end
+
+            head_to_target = merge_status(package, target_commit, current_head)
+            status_to_target = head_to_target.status
+            if status_to_target == Status::UP_TO_DATE
+                return
+            end
+
+            package.message "  %%s: resetting branch %s to %s" % [local_branch, target_commit.to_s]
+            # I don't use a reset --hard here as it would add even more
+            # restrictions on when we can do the operation (as we would refuse
+            # doing it if there are local changes). The checkout creates a
+            # detached HEAD, but makes sure that applying uncommitted changes is
+            # fine (it would abort otherwise). The rest then updates HEAD and
+            # the local_branch ref to match the required target commit
+            resolved_target_commit = rev_parse(package, "#{target_commit}^{commit}")
+            begin
+                run_git(package, 'checkout', target_commit)
+                run_git(package, 'update-ref', "refs/heads/#{local_branch}", resolved_target_commit)
+                run_git(package, 'symbolic-ref', "HEAD", "refs/heads/#{local_branch}")
+            rescue ::Exception
+                run_git(package, 'symbolic-ref', "HEAD", target_commit)
+                run_git(package, 'update-ref', "refs/heads/#{local_branch}", current_head)
+                run_git(package, 'checkout', local_branch)
+                raise
+            end
+        end
+
+        # @option (see Package#update)
+        def update(package, options = Hash.new)
             validate_importdir(package)
+            
             # This is really really a hack to workaround how broken the
             # importdir thing is
             if package.importdir == package.srcdir
                 update_alternates(package)
             end
-            Dir.chdir(package.importdir) do
-                #Checking if we should only merge our repro to remotes/HEAD without updateing from the remote side...
-                if !only_local
-                    fetch_commit = fetch_remote(package)
-                end
 
-                # If we are tracking a commit/tag, just check it out and return
-                if commit || tag
-                    target_commit = (commit || tag)
-                    status_to_head = merge_status(package, target_commit, "HEAD")
-                    if status_to_head.status == Status::UP_TO_DATE
-                        # Check if by any chance we could switch back to a
-                        # proper branch instead of having a detached HEAD
-                        if detached_head?
-                            status_to_remote = merge_status(package, target_commit, fetch_commit)
-                            if status_to_remote.status != Status::UP_TO_DATE
-                                package.message "  the package is on a detached HEAD because of commit pinning"
-                                return
-                            end
-                        else
-                            return
-                        end
-                    elsif status_to_head.status != Status::SIMPLE_UPDATE
-                        raise PackageException.new(package, 'import'), "checking out the specified commit #{target_commit} would be a non-simple operation (i.e. the current state of the repository is not a linear relationship with the specified commit), do it manually"
-                    end
-
-                    status_to_remote = merge_status(package, target_commit, fetch_commit)
-                    if status_to_remote.status != Status::UP_TO_DATE
-                        # Try very hard to avoid creating a detached HEAD
-                        if local_branch
-                            status_to_branch = merge_status(package, target_commit, local_branch)
-                            if status_to_branch.status == Status::UP_TO_DATE # Checkout the branch
-                                package.message "  checking out specific commit %s for %s. It will checkout branch %s." % [target_commit.to_s, package.name, local_branch]
-                                Subprocess.run(package, :import, Autobuild.tool('git'), 'checkout', local_branch)
-                                return
-                            end
-                        end
-                        package.message "  checking out specific commit %s for %s. This will create a detached HEAD." % [target_commit.to_s, package.name]
-                        Subprocess.run(package, :import, Autobuild.tool('git'), 'checkout', target_commit)
+            # Check whether we are already at the requested state
+            pinned_state = (commit || tag)
+            if pinned_state && has_commit?(package, pinned_state)
+                pinned_state = rev_parse(package, pinned_state)
+                current_head = rev_parse(package, 'HEAD')
+                if options[:reset]
+                    if current_head == pinned_state
                         return
                     end
-                end
-
-                if !fetch_commit
+                elsif commit_present_in?(package, pinned_state, current_head)
                     return
                 end
+            end
+            fetch_commit = current_remote_commit(package, options[:only_local])
 
-                if !on_target_branch?
-                    # Check if the target branch already exists. If it is the
-                    # case, check it out. Otherwise, create it.
-                    if system("git", "show-ref", "--verify", "--quiet", "refs/heads/#{local_branch}")
-                        package.message "  switching branch of %s to %s" % [package.name, local_branch]
-                        Subprocess.run(package, :import, Autobuild.tool('git'), 'checkout', local_branch)
-                    else
-                        package.message "  checking out branch %s for %s" % [local_branch, package.name]
-                        Subprocess.run(package, :import, Autobuild.tool('git'), 'checkout', '-b', local_branch, "FETCH_HEAD")
-                    end
+            target_commit =
+                if commit then commit
+                elsif tag then "refs/tags/#{tag}"
+                else fetch_commit
                 end
 
-                status = merge_status(package, fetch_commit)
+            # If we are tracking a commit/tag, just check it out and return
+            if !has_local_branch?(package)
+                package.message "%%s: checking out branch %s" % [local_branch]
+                run_git(package, 'checkout', '-b', local_branch, target_commit)
+                return
+            end
+
+            if !on_target_branch?(package)
+                package.message "%%s: switching to branch %s" % [local_branch]
+                run_git(package, 'checkout', local_branch)
+            end
+
+            if options[:reset]
+                commit_pinning(package, target_commit, fetch_commit)
+            else
+                status = merge_status(package, target_commit)
                 if status.needs_update?
                     if !merge? && status.status == Status::NEEDS_MERGE
                         raise PackageException.new(package, 'import'), "the local branch '#{local_branch}' and the remote branch #{branch} of #{package.name} have diverged, and I therefore refuse to update automatically. Go into #{package.importdir} and either reset the local branch or merge the remote changes"
                     end
-                    Subprocess.run(package, :import, Autobuild.tool('git'), 'merge', fetch_commit)
+                    run_git(package, 'merge', target_commit)
                 end
             end
         end
@@ -600,49 +729,27 @@ module Autobuild
                 FileUtils.mkdir_p base_dir
             end
 
-            clone_options = ['-o', remote_name]
-
+            clone_options = Array.new
             if with_submodules?
                 clone_options << '--recurse-submodules'
             end
             each_alternate_path(package) do |path|
                 clone_options << '--reference' << path
             end
-            Subprocess.run(package, :import,
-                Autobuild.tool('git'), 'clone', *clone_options, repository, package.importdir)
-
-            Dir.chdir(package.importdir) do
-                if push_to
-                    Subprocess.run(package, :import, Autobuild.tool('git'), 'config',
-                                   "--replace-all", "remote.#{remote_name}.pushurl", push_to)
-                end
-                if local_branch && remote_branch
-                    Subprocess.run(package, :import, Autobuild.tool('git'), 'config',
-                                   "--replace-all", "remote.#{remote_name}.push", "refs/heads/#{local_branch}:refs/heads/#{remote_branch}")
-                end
+            package.run(:import,
+                Autobuild.tool('git'), 'clone', '-o', remote_name, *clone_options, repository, package.importdir, retry: true)
 
-                # If we are tracking a commit/tag, just check it out
-                if commit || tag
-                    status = merge_status(package, commit || tag)
-                    if status.status != Status::UP_TO_DATE
-                        package.message "  checking out specific commit for %s. This will create a detached HEAD." % [package.name]
-                        Subprocess.run(package, :import, Autobuild.tool('git'), 'checkout', commit || tag)
-                    end
-                else
-                    current_branch = `git symbolic-ref HEAD`.chomp
-                    if current_branch == "refs/heads/#{local_branch}"
-                        Subprocess.run(package, :import, Autobuild.tool('git'),
-                            'reset', '--hard', "#{remote_name}/#{branch}")
-                    else
-                        Subprocess.run(package, :import, Autobuild.tool('git'),
-                            'checkout', '-b', local_branch, "#{remote_name}/#{branch}")
-                    end
-                end
-            end
+            update_remotes_configuration(package)
+            update(package, only_local: true)
         end
 
         # Changes the repository this importer is pointing to
         def relocate(repository, options = Hash.new)
+            @push_to = options[:push_to] || @push_to
+            @branch = options[:branch] || @branch || 'master'
+            @tag    = options[:tag] || @tag
+            @commit = options[:commit] || @commit
+
             @repository = repository.to_str
             @repository_id = options[:repository_id] ||
                 "git:#{@repository}"