autobuild 1.21.0 → 1.22.0

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,66 @@ 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(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 +429,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
 
@@ -477,21 +540,24 @@ module Autobuild
         #
         # Set a remote up in the repositorie's configuration
         def setup_remote(package, remote_name, repository, push_to = repository)
+            resolve_all_branches(package, only_local: true) 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
 
@@ -517,16 +583,17 @@ module Autobuild
 
             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 +651,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 +708,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 +717,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 +733,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 +765,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 +775,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 +783,8 @@ module Autobuild
         end
 
         private def remote_branch_to_ref(branch)
+            return unless branch
+
             if branch.start_with?("refs/")
                 branch
             else
@@ -750,9 +821,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 +866,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 +880,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 +914,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 +944,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 +976,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 +1009,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 +1074,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 +1096,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 +1132,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 +1154,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 +1178,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,28 +1266,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: :force)
-            run_git(package, "submodule", "update", '--init') if with_submodules?
+            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