autobuild 1.19.0 → 1.22.1

data/lib/autobuild/import/archive.rb

@@ -106,6 +106,7 @@ module Autobuild
         @auto_update = (ENV['AUTOBUILD_ARCHIVE_AUTOUPDATE'] == '1')
 
         attr_writer :update_cached_file
+
         def update_cached_file?
             @update_cached_file
         end
@@ -118,15 +119,16 @@ module Autobuild
 
             Net::HTTP.start(
                 uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-
                 http.request(request) do |resp|
                     case resp
                     when Net::HTTPNotModified
                         return false
                     when Net::HTTPSuccess
-                        if current_time && (last_modified = resp['last-modified'])
-                            return false if current_time >= Time.rfc2822(last_modified)
+                        if current_time && (last_modified = resp['last-modified']) &&
+                           (current_time >= Time.rfc2822(last_modified))
+                           return false
                         end
+
                         if (length = resp['Content-Length'])
                             length = Integer(length)
                             expected_size = "/#{Autobuild.human_readable_size(length)}"
@@ -158,11 +160,12 @@ module Autobuild
                         end
 
                         return download_http(package, URI(redirect_uri), filename,
-                            user: user, password: password, current_time: current_time)
+                                             user: user, password: password,
+                                             current_time: current_time)
                     else
                         raise PackageException.new(package, 'import'),
-                            "failed download of #{package.name} from #{uri}: "\
-                            "#{resp.class}"
+                              "failed download of #{package.name} from #{uri}: "\
+                              "#{resp.class}"
                     end
                 end
             end
@@ -204,19 +207,19 @@ module Autobuild
             end
 
             if mtime && size
-                return size != cached_size || mtime > cached_mtime
+                size != cached_size || mtime > cached_mtime
             elsif mtime
                 package.warn "%s: archive size is not available for #{@url}, "\
                     "relying on modification time"
-                return mtime > cached_mtime
+                mtime > cached_mtime
             elsif size
                 package.warn "%s: archive modification time "\
                     "is not available for #{@url}, relying on size"
-                return size != cached_size
+                size != cached_size
             else
                 package.warn "%s: neither the archive size nor its modification time "\
                     "are available for #{@url}, will always update"
-                return true
+                true
             end
         end
 
@@ -231,8 +234,8 @@ module Autobuild
                     end
 
                     updated = download_http(package, @url, "#{cachefile}.partial",
-                        user: @user, password: @password,
-                        current_time: cached_mtime)
+                                            user: @user, password: @password,
+                                            current_time: cached_mtime)
                     return false unless updated
                 elsif Autobuild.bsd?
                     return false unless update_needed?(package)
@@ -250,8 +253,8 @@ module Autobuild
                         additional_options << "--tries" << retries
                     end
                     package.run(:import, Autobuild.tool('wget'), '-q', '-P', cachedir,
-                        *additional_options, @url, '-O', "#{cachefile}.partial",
-                        retry: true)
+                                *additional_options, @url, '-O', "#{cachefile}.partial",
+                                retry: true)
                 end
             rescue Exception
                 FileUtils.rm_f "#{cachefile}.partial"
@@ -264,13 +267,15 @@ module Autobuild
         # Updates the downloaded file in cache only if it is needed
         #
         # @return [Boolean] true if a new file was downloaded, false otherwise
-        # @raises ConfigException if a expected digest was given in the source.yml file and it doesn't match
+        # @raises ConfigException if a expected digest was given in the
+        #   source.yml file and it doesn't match
         def update_cache(package)
             updated = download_from_url(package)
             @cachefile_digest = read_cachefile_digest
 
             if @expected_digest && @expected_digest != @cachefile_digest
-                raise ConfigException, "The archive #{@url.to_s} does not match the digest provided"
+                raise ConfigException,
+                      "The archive #{@url} does not match the digest provided"
             end
 
             updated
@@ -279,11 +284,11 @@ module Autobuild
         def read_cachefile_digest
             Digest::SHA1.hexdigest File.read(cachefile)
         end
-        
+
         # Fingerprint for archive importer, we are using
         # its digest whether is calculated or expected
         # @raises ConfigException if no digest is present
-        def vcs_fingerprint(package)
+        def vcs_fingerprint(_package)
             if @cachefile_digest
                 @cachefile_digest
             elsif File.file?(cachefile)
@@ -291,7 +296,9 @@ module Autobuild
             elsif @expected_digest
                 @expected_digest
             else
-                raise ConfigException, "There is no digest for archive #{@url.to_s}, make sure cache directories are configured correctly"
+                raise ConfigException,
+                      "There is no digest for archive #{@url}, make sure "\
+                      "cache directories are configured correctly"
             end
         end
 
@@ -378,9 +385,11 @@ module Autobuild
         # [:mode] The unpack mode: one of Zip, Bzip, Gzip or Plain, this is
         #       usually automatically inferred from the filename
         def initialize(url, options = Hash.new)
-            sourceopts, options = Kernel.filter_options options,
+            sourceopts, options = Kernel.filter_options(
+                options,
                 :source_id, :repository_id, :filename, :mode, :update_cached_file,
                 :user, :password, :expected_digest
+            )
             super(options)
 
             @filename = nil
@@ -452,7 +461,7 @@ module Autobuild
             end
 
             if needs_update || archive_changed?(package)
-                return checkout(package, allow_interactive: options[:allow_interactive])
+                checkout(package, allow_interactive: options[:allow_interactive])
             else
                 false
             end
@@ -477,7 +486,7 @@ module Autobuild
 
         def checkout(package, options = Hash.new) # :nodoc:
             options = Kernel.validate_options options,
-                allow_interactive: true
+                                              allow_interactive: true
 
             update_cache(package)
 

data/lib/autobuild/import/cvs.rb

@@ -10,7 +10,7 @@ module Autobuild
         #   Autobuild.programs['cvs'] = 'my_cvs_tool'
         def initialize(root_name, options = {})
             cvsopts, common = Kernel.filter_options options,
-                module: nil, cvsup: '-dP', cvsco: '-P'
+                                                    module: nil, cvsup: '-dP', cvsco: '-P'
             @root   = root_name
             @module = cvsopts[:module]
             raise ArgumentError, "no module given" unless @module
@@ -41,7 +41,7 @@ module Autobuild
 
             unless File.exist?("#{package.srcdir}/CVS/Root")
                 raise ConfigException.new(package, 'import'),
-                    "#{package.srcdir} is not a CVS working copy"
+                      "#{package.srcdir} is not a CVS working copy"
             end
 
             root = File.open("#{package.srcdir}/CVS/Root", &:read).chomp
@@ -56,8 +56,8 @@ module Autobuild
 
             if root != expected_root || mod != @module
                 raise ConfigException.new(package, 'import'),
-                    "checkout in #{package.srcdir} is from #{root}:#{mod}, "\
-                    "was expecting #{expected_root}:#{@module}"
+                      "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)
@@ -72,8 +72,8 @@ module Autobuild
 
             FileUtils.mkdir_p(head) unless File.directory?(head)
             package.run(:import, Autobuild.tool(:cvs), '-d', cvsroot, 'co',
-                '-d', tail, *@options_co, modulename,
-                retry: true, working_directory: head)
+                        '-d', tail, *@options_co, modulename,
+                        retry: true, working_directory: head)
         end
     end
 

data/lib/autobuild/import/darcs.rb

@@ -28,12 +28,12 @@ module Autobuild
             end
             unless File.directory?(File.join(package.srcdir, '_darcs'))
                 raise ConfigException.new(package, 'import'),
-                    "#{package.srcdir} is not a Darcs repository"
+                      "#{package.srcdir} is not a Darcs repository"
             end
 
             package.run(:import, @program, 'pull', '--all',
-                "--repodir=#{package.srcdir}", '--set-scripts-executable',
-                @source, *@pull, retry: true)
+                        "--repodir=#{package.srcdir}", '--set-scripts-executable',
+                        @source, *@pull, retry: true)
             true # no easy to know if package was updated, keep previous behavior
         end
 
@@ -42,7 +42,7 @@ module Autobuild
             FileUtils.mkdir_p(basedir) unless File.directory?(basedir)
 
             package.run(:import, @program, 'get', '--set-scripts-executable',
-                @source, package.srcdir, *@get, retry: true)
+                        @source, package.srcdir, *@get, retry: true)
         end
     end
 

data/lib/autobuild/import/git-lfs.rb

@@ -10,26 +10,26 @@ module Autobuild
         if includes.empty?
             begin
                 importer.run_git_bare(package, 'config', '--local',
-                    '--unset', 'lfs.fetchinclude')
+                                      '--unset', 'lfs.fetchinclude')
             rescue SubcommandFailed => e
                 raise if e.status != 5
             end
         else
             importer.run_git_bare(package, 'config', '--local',
-                'lfs.fetchinclude', includes)
+                                  'lfs.fetchinclude', includes)
         end
 
         excludes = importer.options.fetch(:lfs_exclude, '')
         if excludes.empty?
             begin
                 importer.run_git_bare(package, 'config', '--local',
-                    '--unset', 'lfs.fetchexclude')
+                                      '--unset', 'lfs.fetchexclude')
             rescue SubcommandFailed => e
                 raise if e.status != 5
             end
         else
             importer.run_git_bare(package, 'config', '--local',
-                'lfs.fetchexclude', excludes)
+                                  'lfs.fetchexclude', excludes)
         end
 
         if importer.options[:lfs] != false

data/lib/autobuild/import/git.rb

@@ -7,6 +7,9 @@ require 'English'
 
 module Autobuild
     class Git < Importer
+        # Exception raised when a network access is needed while only_local is true
+        class NetworkAccessNeeded < RuntimeError; end
+
         class << self
             # Sets the default alternates path used by all Git importers
             #
@@ -54,7 +57,7 @@ module Autobuild
         def self.version
             version = Subprocess.run('git', 'setup', Autobuild.tool(:git), '--version').
                 first
-            if version =~ /^git version (\d[\d\.]+)/
+            if version =~ /^git version (\d[\d.]+)/
                 $1.split(".").map { |i| Integer(i) }
             else
                 raise ArgumentError, "cannot parse git version string #{version}, "\
@@ -139,16 +142,16 @@ module Autobuild
             end
 
             gitopts, common = Kernel.filter_options options,
-                push_to: nil,
-                branch: nil,
-                local_branch: nil,
-                remote_branch: nil,
-                tag: nil,
-                commit: nil,
-                repository_id: nil,
-                source_id: nil,
-                with_submodules: false,
-                single_branch: false
+                                                    push_to: nil,
+                                                    branch: nil,
+                                                    local_branch: nil,
+                                                    remote_branch: nil,
+                                                    tag: nil,
+                                                    commit: nil,
+                                                    repository_id: nil,
+                                                    source_id: nil,
+                                                    with_submodules: false,
+                                                    single_branch: false
             if gitopts[:branch] && branch
                 raise ConfigException, "git branch specified with both the option hash "\
                     "and the explicit parameter"
@@ -293,6 +296,68 @@ module Autobuild
             git_dir(package, true)
         end
 
+        # Return the remote head branch from local copy if exists, if not return nil
+        #
+        # @param [Package] package
+        def try_resolve_remote_head_from_local(package)
+            ls_local_string = run_git_bare(
+                package, 'symbolic-ref',
+                "refs/remotes/#{@remote_name}/HEAD"
+            ).first.strip
+            local_remote_head = ls_local_string.match("refs/remotes/#{@remote_name}/(.*)")
+            local_remote_head ? local_remote_head[1] : nil
+        rescue Autobuild::SubcommandFailed # rubocop:disable Lint/SuppressedException
+        end
+
+        # Return the remote head branch from server if exists, if not return 'master'
+        #
+        # @param [Package] package
+        def try_resolve_remote_head_from_server(package)
+            ls_remote_string = package.run(
+                :import,
+                Autobuild.tool('git'), 'ls-remote', '--symref', repository
+            ).first.strip
+            server_remote_head =
+                ls_remote_string.match("ref:[^A-z]refs/heads/(.*)[^A-z]HEAD")
+            server_remote_head ? server_remote_head[1] : 'master'
+        end
+
+        # Return default local branch if exists, if not return the default remote branch
+        #
+        # @param [Package] package
+        def resolve_remote_head(package, only_local: false)
+            try_resolve_remote_head_from_local(package) ||
+                (!only_local && try_resolve_remote_head_from_server(package))
+        end
+
+        # Whether both the local and remote branches are known
+        #
+        # See documentation of {#resolve_all_branches}
+        def has_all_branches?
+            remote_branch && local_branch
+        end
+
+        # Resolve branches based on the remote's HEAD
+        #
+        # Since GitHub (and others) decided to change the name of the "default"
+        # branch, we can't assume that master is ... well ... master.
+        #
+        # For this reason, a Git importer does not have a built-in default.
+        # If the branch(es) are not provided explicitly, the importer will
+        # call this method to guess the name of the default branch instead.
+        #
+        # Call {#has_all_branches?} to determine whether it is necessary
+        def resolve_all_branches(package, only_local: false)
+            default_branch = resolve_remote_head(package, only_local: only_local)
+            unless default_branch
+                raise NetworkAccessNeeded,
+                      "determining the remote branch would require access to "\
+                      "the network, and only_local is true"
+            end
+
+            relocate(repository, default_branch: default_branch)
+        end
+
         # @api private
         #
         # Resolves the git directory associated with path, and tells whether it
@@ -366,12 +431,12 @@ module Autobuild
         def self.validate_git_dir(package, require_working_copy, _dir, style)
             if !style
                 raise ConfigException.new(package, 'import', retry: false),
-                    "while importing #{package.name}, #{package.importdir} "\
-                    "does not point to a git repository"
+                      "while importing #{package.name}, #{package.importdir} "\
+                      "does not point to a git repository"
             elsif require_working_copy && (style == :bare)
                 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"
+                      "while importing #{package.name}, #{package.importdir} "\
+                      "points to a bare git repository but a working copy was required"
             end
         end
 
@@ -476,22 +541,28 @@ module Autobuild
         # @api private
         #
         # Set a remote up in the repositorie's configuration
-        def setup_remote(package, remote_name, repository, push_to = repository)
+        def setup_remote(
+            package, remote_name, repository, push_to = repository,
+            only_local: true
+        )
+            resolve_all_branches(package, only_local: only_local) unless has_all_branches?
+
             run_git_bare(package, 'config', '--replace-all',
-                "remote.#{remote_name}.url", repository)
+                         "remote.#{remote_name}.url", repository)
             run_git_bare(package, 'config', '--replace-all',
-                "remote.#{remote_name}.pushurl", push_to || repository)
+                         "remote.#{remote_name}.pushurl", push_to || repository)
             run_git_bare(package, 'config', '--replace-all',
-                "remote.#{remote_name}.fetch",
-                "+refs/heads/*:refs/remotes/#{remote_name}/*")
+                         "remote.#{remote_name}.fetch",
+                         "+refs/heads/*:refs/remotes/#{remote_name}/*")
 
             if remote_branch && local_branch
+                remote_ref = remote_branch_to_ref(remote_branch)
                 run_git_bare(package, 'config', '--replace-all',
-                    "remote.#{remote_name}.push",
-                    "refs/heads/#{local_branch}:#{remote_branch_to_ref(remote_branch)}")
+                             "remote.#{remote_name}.push",
+                             "refs/heads/#{local_branch}:#{remote_ref}")
             else
                 run_git_bare(package, 'config', '--replace-all',
-                    "remote.#{remote_name}.push", "refs/heads/*:refs/heads/*")
+                             "remote.#{remote_name}.push", "refs/heads/*:refs/heads/*")
             end
         end
 
@@ -510,23 +581,24 @@ module Autobuild
         # @api private
         #
         # Updates the git repository's configuration for the target remote
-        def update_remotes_configuration(package)
+        def update_remotes_configuration(package, only_local: true)
             each_configured_remote do |*args|
-                setup_remote(package, *args)
+                setup_remote(package, *args, only_local: only_local)
             end
 
             if local_branch
                 run_git_bare(package, 'config', '--replace-all',
-                    "branch.#{local_branch}.remote", remote_name)
+                             "branch.#{local_branch}.remote", remote_name)
                 run_git_bare(package, 'config', '--replace-all',
-                    "branch.#{local_branch}.merge", remote_branch_to_ref(local_branch))
+                             "branch.#{local_branch}.merge",
+                             remote_branch_to_ref(local_branch))
             end
         end
 
         # Resolve a commit ref to a tag or commit ID
         def describe_rev(package, rev)
             tag = run_git_bare(package, 'describe',
-                '--tags', '--exact-match', rev).first.strip
+                               '--tags', '--exact-match', rev).first.strip
             [true, tag.encode('UTF-8')]
         rescue Autobuild::SubcommandFailed
             commit = rev_parse(package, rev)
@@ -584,7 +656,7 @@ module Autobuild
                 refspec.zip(fetched_commits).each do |spec, commit_id|
                     if spec =~ %r{^refs/heads/(.*)$}
                         run_git_bare(package, 'update-ref', "-m", "updated by autobuild",
-                            "refs/remotes/#{remote_name}/#{$1}", commit_id)
+                                     "refs/remotes/#{remote_name}/#{$1}", commit_id)
                     end
                 end
 
@@ -641,7 +713,7 @@ module Autobuild
                     run_git_bare(package, 'show-ref', '-s', refspec).first.strip
                 rescue SubcommandFailed
                     raise PackageException.new(package, "import"),
-                        "cannot resolve #{refspec}"
+                          "cannot resolve #{refspec}"
                 end
             else
                 refspec =
@@ -650,7 +722,7 @@ module Autobuild
                     remote_branch_to_ref(remote_branch)
                 begin fetch_remote(package, refspec: refspec)
                 rescue Exception => e
-                    return fallback(e, package, :status, package, only_local)
+                    fallback(e, package, :status, package, only_local)
                 end
             end
         end
@@ -666,6 +738,8 @@ module Autobuild
                 end
 
             validate_importdir(package)
+            resolve_all_branches(package, only_local: only_local) unless has_all_branches?
+
             _pinned_state, target_commit, = determine_target_state(
                 package, only_local: only_local)
 
@@ -696,7 +770,7 @@ module Autobuild
 
         def has_branch?(package, branch_name)
             run_git_bare(package, 'show-ref', '-q', '--verify',
-                remote_branch_to_ref(branch_name))
+                         remote_branch_to_ref(branch_name))
             true
         rescue SubcommandFailed => e
             if e.status == 1
@@ -706,7 +780,7 @@ module Autobuild
         end
 
         def has_local_branch?(package)
-            has_branch?(package, local_branch)
+            has_branch?(package, local_branch) if local_branch
         end
 
         def detached_head?(package)
@@ -714,6 +788,8 @@ module Autobuild
         end
 
         private def remote_branch_to_ref(branch)
+            return unless branch
+
             if branch.start_with?("refs/")
                 branch
             else
@@ -750,9 +826,7 @@ module Autobuild
         #
         # This is the value returned by {Git#status}
         class Status < Importer::Status
-            attr_reader :fetch_commit
-            attr_reader :head_commit
-            attr_reader :common_commit
+            attr_reader :fetch_commit, :head_commit, :common_commit
 
             def initialize(package, status, remote_commit, local_commit, common_commit)
                 super()
@@ -797,8 +871,8 @@ module Autobuild
             run_git_bare(package, 'rev-parse', '-q', '--verify', name).first
         rescue Autobuild::SubcommandFailed
             raise PackageException.new(package, 'import'),
-                "failed to resolve #{name}. "\
-                "Are you sure this commit, branch or tag exists ?"
+                  "failed to resolve #{name}. "\
+                  "Are you sure this commit, branch or tag exists ?"
         end
 
         # Returns the file's conents at a certain commit
@@ -811,7 +885,7 @@ module Autobuild
             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}"
+                  "failed to either resolve commit #{commit} or file #{path}"
         end
 
         # Tests whether a commit is already present in a given history
@@ -845,7 +919,7 @@ module Autobuild
         def describe_commit_on_remote(package, rev = 'HEAD', options = Hash.new)
             rev = rev.to_str
             options = Kernel.validate_options options,
-                tags: true
+                                              tags: true
 
             commit_id = rev_parse(package, rev)
 
@@ -875,15 +949,13 @@ module Autobuild
             end
 
             remote_refs.delete_if do |rev_name, rev_id|
-                begin
                     if commit_present_in?(package, commit_id, rev_id)
                         return rev_name
                     else
                         true
                     end
-                rescue PackageException
+            rescue PackageException
                     false
-                end
             end
 
             unless remote_refs.empty?
@@ -909,7 +981,7 @@ module Autobuild
         def merge_status(package, fetch_commit, reference_commit = "HEAD")
             begin
                 common_commit = run_git_bare(package, 'merge-base',
-                    reference_commit, fetch_commit).first.strip
+                                             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}. "\
@@ -942,7 +1014,7 @@ module Autobuild
         # @return [void]
         def update_alternates(package)
             alternates_path = File.join(git_dir(package, false),
-                'objects', 'info', 'alternates')
+                                        'objects', 'info', 'alternates')
             current_alternates =
                 if File.file?(alternates_path)
                     File.readlines(alternates_path)
@@ -1007,18 +1079,18 @@ module Autobuild
                 # changes
                 unless commit_present_in?(package, current_head, fetch_commit)
                     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 lose some stuff. Update"\
-                        " the remote branch in your overrides, push your"\
-                        " changes or reset to the remote commit manually"\
-                        " before trying again"
+                          "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 lose some stuff. Update"\
+                          " the remote branch in your overrides, push your"\
+                          " changes or reset to the remote commit manually"\
+                          " before trying again"
                 end
             end
 
             package.message format("  %%s: resetting branch %<branch>s to %<commit>s",
-                branch: local_branch, commit: target_commit)
+                                   branch: local_branch, commit: target_commit)
             # 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
@@ -1029,7 +1101,7 @@ module Autobuild
             begin
                 run_git(package, 'checkout', target_commit)
                 run_git(package, 'update-ref', "refs/heads/#{local_branch}",
-                    resolved_target_commit)
+                        resolved_target_commit)
                 run_git(package, 'symbolic-ref', "HEAD", "refs/heads/#{local_branch}")
             rescue ::Exception
                 run_git(package, 'symbolic-ref', "HEAD", target_commit)
@@ -1065,6 +1137,9 @@ module Autobuild
         # @option (see Package#update)
         def update(package, options = Hash.new)
             validate_importdir(package)
+
+            resolve_all_branches(package) unless has_all_branches?
+
             only_local = options.fetch(:only_local, false)
             reset = options.fetch(:reset, false)
 
@@ -1084,20 +1159,21 @@ module Autobuild
             end
 
             unless pin_is_uptodate
-                fetch_commit ||= current_remote_commit(package,
-                    only_local: only_local,
-                    refspec: [remote_branch_to_ref(remote_branch), tag])
+                fetch_commit ||= current_remote_commit(
+                    package, only_local: only_local,
+                             refspec: [remote_branch_to_ref(remote_branch), tag]
+                )
                 did_update =
                     if reset
                         reset_head_to_commit(package, target_commit, fetch_commit,
-                             force: (reset == :force))
+                                             force: (reset == :force))
                     else
                         merge_if_simple(package, target_commit)
                     end
             end
 
             if !only_local && with_submodules?
-                run_git(package, "submodule", "update", '--init')
+                run_git(package, "submodule", "update", '--init', '--recursive')
                 did_update = true
             end
 
@@ -1107,12 +1183,12 @@ module Autobuild
         private def ensure_on_local_branch(package, target_commit)
             if !has_local_branch?(package)
                 package.message format("%%s: checking out branch %<branch>s",
-                    branch: local_branch)
+                                       branch: local_branch)
                 run_git(package, 'checkout', '-b', local_branch, target_commit)
                 true
             elsif !on_local_branch?(package)
                 package.message format("%%s: switching to branch %<branch>s",
-                    branch: local_branch)
+                                       branch: local_branch)
                 run_git(package, 'checkout', local_branch)
                 true
             else
@@ -1195,27 +1271,30 @@ module Autobuild
                 clone_options << "--config=#{key}=#{value}"
             end
             package.run(:import,
-                Autobuild.tool('git'), 'clone', '-o', remote_name, *clone_options,
-                    repository, package.importdir, retry: true)
+                        Autobuild.tool('git'), 'clone', '-o', remote_name, *clone_options,
+                        repository, package.importdir, retry: true)
 
             update_remotes_configuration(package)
-            update(package, only_local: !remote_branch.start_with?("refs/"), reset: true)
-            run_git(package, "submodule", "update", '--init') if with_submodules?
+            update(package, only_local: !remote_branch.start_with?("refs/"),
+                            reset: :force)
+            if with_submodules?
+                run_git(package, "submodule", "update", '--init', '--recursive')
+            end
         end
 
         # Changes the repository this importer is pointing to
         def relocate(repository, options = Hash.new)
-            options = Hash[options.map { |k, v| [k.to_sym, v] }]
+            options = options.transform_keys(&:to_sym)
 
             local_branch  =
                 options[:local_branch] || options[:branch] ||
-                self.local_branch || 'master'
+                self.local_branch || options[:default_branch] || nil
             remote_branch =
                 options[:remote_branch] || options[:branch] ||
-                self.remote_branch || 'master'
-            if local_branch.start_with?("refs/")
+                self.remote_branch || options[:default_branch] || nil
+            if local_branch&.start_with?("refs/")
                 raise ArgumentError, "you cannot provide a full ref for"\
-                  " the local branch, only for the remote branch"
+                    " the local branch, only for the remote branch"
             end
 
             @push_to = options[:push_to] || @push_to