autobuild 1.17.0 → 1.21.0

data/lib/autobuild/import/hg.rb

@@ -10,13 +10,13 @@ class Hg < Importer
         #
         # This importer uses the 'hg' tool to perform the
         # import. It defaults to 'hg' and can be configured by
-        # doing 
+        # doing
         #   Autobuild.programs['hg'] = 'my_git_tool'
         #
         # @param [String] repository the repository URL
         # @option options [String] :branch (default) the branch to track
         def initialize(repository, options = {})
-            hgopts, common = Kernel.filter_options options,
+            hgopts, _common = Kernel.filter_options options,
                 branch: 'default'
             sourceopts, common = Kernel.filter_options options,
                 :repository_id, :source_id
@@ -29,10 +29,12 @@ def initialize(repository, options = {})
         # Changes the repository this importer is pointing to
         def relocate(repository, options = Hash.new)
             @repository = repository
-            @repository_id = options[:repository_id] ||
+            @repository_id =
+                options[:repository_id] ||
                 "hg:#{@repository}"
-            @source_id = options[:source_id] ||
-                "#{self.repository_id} branch=#{self.branch}"
+            @source_id =
+                options[:source_id] ||
+                "#{repository_id} branch=#{branch}"
         end
 
         # The remote repository URL.
@@ -44,38 +46,41 @@ def relocate(repository, options = Hash.new)
         # Raises ConfigException if the current directory is not a hg
         # repository
         def validate_importdir(package)
-            if !File.directory?(File.join(package.importdir, '.hg'))
-                raise ConfigException.new(package, 'import'), "while importing #{package.name}, #{package.importdir} is not a hg repository"
+            unless File.directory?(File.join(package.importdir, '.hg'))
+                raise ConfigException.new(package, 'import'),
+                    "while importing #{package.name}, "\
+                    "#{package.importdir} is not a hg repository"
             end
         end
 
         def update(package, options = Hash.new)
             if options[:only_local]
-                package.warn "%s: the Mercurial importer does not support local updates, skipping"
+                package.warn "%s: the Mercurial importer does not support "\
+                    "local updates, skipping"
                 return false
             end
             validate_importdir(package)
-            package.run(:import, Autobuild.tool('hg'), 'pull', repository, retry: true, working_directory: package.importdir)
-            package.run(:import, Autobuild.tool('hg'), 'update', branch, working_directory: package.importdir)
+            package.run(:import, Autobuild.tool('hg'), 'pull',
+                repository, retry: true, working_directory: package.importdir)
+            package.run(:import, Autobuild.tool('hg'), 'update',
+                branch, working_directory: package.importdir)
             true # no easy to know if package was updated, keep previous behavior
         end
 
-        def checkout(package, options = Hash.new)
+        def checkout(package, _options = Hash.new)
             base_dir = File.expand_path('..', package.importdir)
-            if !File.directory?(base_dir)
-                FileUtils.mkdir_p base_dir
-            end
+            FileUtils.mkdir_p(base_dir) unless File.directory?(base_dir)
 
-            package.run(:import, Autobuild.tool('hg'), 'clone', '-u', branch, repository, package.importdir, retry: true)
+            package.run(:import, Autobuild.tool('hg'), 'clone',
+                '-u', branch, repository, package.importdir, retry: true)
         end
     end
 
-    # Creates a hg importer which gets the source for the given repository and branch
-    # URL +source+.
+    # Creates a hg importer which gets the source for the given repository and
+    # branch URL +source+.
     #
     # @param (see Hg#initialize)
     def self.hg(repository, options = {})
         Hg.new(repository, options)
     end
 end
-

data/lib/autobuild/import/svn.rb

@@ -10,7 +10,7 @@ class SVN < Importer
         # [:svnco] options to give to 'svn co'
         #
         # This importer uses the 'svn' tool to perform the import. It defaults
-        # to 'svn' and can be configured by doing 
+        # to 'svn' and can be configured by doing
         #   Autobuild.programs['svn'] = 'my_svn_tool'
         def initialize(svnroot, options = {})
             svnroot = [*svnroot].join("/")
@@ -25,7 +25,9 @@ def initialize(svnroot, options = {})
         # @deprecated use {svnroot} instead
         #
         # @return [String]
-        def source; svnroot end
+        def source
+            svnroot
+        end
 
         # Returns the SVN root
         #
@@ -63,13 +65,23 @@ def relocate(root, options = Hash.new)
         def svn_revision(package)
             svninfo = svn_info(package)
             revision = svninfo.grep(/^Revision: /).first
-            if !revision
-                raise ConfigException.new(package, 'import'), "cannot get SVN information for #{package.importdir}"
+            unless revision
+                raise ConfigException.new(package, 'import'),
+                    "cannot get SVN information for #{package.importdir}"
             end
             revision =~ /Revision: (\d+)/
             Integer($1)
         end
 
+        # fingerprint method returns an unique hash to identify this package,
+        # for SVN the revision and URL will be used
+        # @param [Package] package
+        # @return [String]
+        # @raises (see svn_info)
+        def vcs_fingerprint(package)
+            Digest::SHA1.hexdigest(svn_info(package).grep(/^(URL|Revision):/).sort.join("\n"))
+        end
+
         # Returns the URL of the remote SVN repository
         #
         # @param [Package] package
@@ -79,8 +91,9 @@ def svn_revision(package)
         def svn_url(package)
             svninfo = svn_info(package)
             url = svninfo.grep(/^URL: /).first
-            if !url
-                raise ConfigException.new(package, 'import'), "cannot get SVN information for #{package.importdir}"
+            unless url
+                raise ConfigException.new(package, 'import'),
+                    "cannot get SVN information for #{package.importdir}"
             end
             url.chomp =~ /URL: (.+)/
             $1
@@ -97,10 +110,8 @@ def svn_url(package)
         def has_local_modifications?(package, with_untracked_files = false)
             status = run_svn(package, 'status', '--xml')
 
-            not_modified = %w{external ignored none normal}
-            if !with_untracked_files
-                not_modified << "unversioned"
-            end
+            not_modified = %w[external ignored none normal]
+            not_modified << "unversioned" unless with_untracked_files
 
             REXML::Document.new(status.join("")).
                 elements.enum_for(:each, '//wc-status').
@@ -126,13 +137,14 @@ def status(package, only_local = false)
             else
                 log = run_svn(package, 'log', '-r', 'BASE:HEAD', '--xml', '.')
                 log = REXML::Document.new(log.join("\n"))
-                missing_revisions = log.elements.enum_for(:each, 'log/logentry').map do |l|
-                    rev = l.attributes['revision']
-                    date = l.elements['date'].first.to_s
-                    author = l.elements['author'].first.to_s
-                    msg = l.elements['msg'].first.to_s.split("\n").first
-                    "#{rev} #{DateTime.parse(date)} #{author} #{msg}"
-                end
+                missing_revisions = log.elements.enum_for(:each, 'log/logentry').
+                    map do |l|
+                        rev = l.attributes['revision']
+                        date = l.elements['date'].first.to_s
+                        author = l.elements['author'].first.to_s
+                        msg = l.elements['msg'].first.to_s.split("\n").first
+                        "#{rev} #{DateTime.parse(date)} #{author} #{msg}"
+                    end
                 status.remote_commits = missing_revisions[1..-1]
                 status.status =
                     if missing_revisions.empty?
@@ -146,10 +158,13 @@ def status(package, only_local = false)
 
         # Helper method to run a SVN command on a package's working copy
         def run_svn(package, *args, &block)
-            options = Hash.new
-            if args.last.kind_of?(Hash)
-                options = args.pop
-            end
+            options =
+                if args.last.kind_of?(Hash)
+                    args.pop
+                else
+                    Hash.new
+                end
+
             options, other_options = Kernel.filter_options options,
                 working_directory: package.importdir, retry: true
             options = options.merge(other_options)
@@ -173,7 +188,8 @@ def validate_importdir(package)
         # @raises [ConfigException] if the working copy is not a subversion
         #   working copy
         def svn_info(package)
-            old_lang, ENV['LC_ALL'] = ENV['LC_ALL'], 'C'
+            old_lang = ENV['LC_ALL']
+            ENV['LC_ALL'] = 'C'
             begin
                 svninfo = run_svn(package, 'info')
             rescue SubcommandFailed => e
@@ -185,7 +201,7 @@ def svn_info(package)
                 end
             end
 
-            if !svninfo.grep(/is not a working copy/).empty?
+            unless svninfo.grep(/is not a working copy/).empty?
                 raise ConfigException.new(package, 'import'),
                     "#{package.importdir} does not appear to be a Subversion working copy"
             end
@@ -196,13 +212,16 @@ def svn_info(package)
 
         def update(package, options = Hash.new) # :nodoc:
             if options[:only_local]
-                package.warn "%s: the svn importer does not support local updates, skipping"
+                package.warn "%s: the svn importer does not support local updates, "\
+                    "skipping"
                 return false
             end
 
             url = svn_url(package)
             if url != svnroot
-                raise ConfigException.new(package, 'import'), "current checkout found at #{package.importdir} is from #{url}, was expecting #{svnroot}"
+                raise ConfigException.new(package, 'import'), "current checkout "\
+                    "found at #{package.importdir} is from #{url}, "\
+                    "was expecting #{svnroot}"
             end
 
             options_up = @options_up.dup
@@ -220,9 +239,10 @@ def update(package, options = Hash.new) # :nodoc:
             true
         end
 
-        def checkout(package, options = Hash.new) # :nodoc:
-            run_svn(package, 'co', "--non-interactive", *@options_co, svnroot, package.importdir,
-                    working_directory: nil)
+        def checkout(package, _options = Hash.new) # :nodoc:
+            run_svn(package, 'co', "--non-interactive", *@options_co,
+                svnroot, package.importdir,
+                working_directory: nil)
         end
     end
 
@@ -232,4 +252,3 @@ def self.svn(source, options = {})
         SVN.new(source, options)
     end
 end
-

data/lib/autobuild/importer.rb

@@ -5,595 +5,630 @@
 # various RCS into the package source directory. A list of patches to apply
 # after the import can be given in the +:patches+ option.
 module Autobuild
-class Importer
-    # call-seq:
-    #   Autobuild::Importer.fallback { |package, importer| ... }
-    #
-    # If called, registers the given block as a fallback mechanism for failing
-    # imports.
-    #
-    # Fallbacks are tried in reverse order with the failing importer object as
-    # argument. The first valid importer object that has been returned will be
-    # used instead.
-    #
-    # It is the responsibility of the fallback handler to make sure that it does
-    # not do infinite recursions and stuff like that.
-    def self.fallback(&block)
-        @fallback_handlers.unshift(block)
-    end
+    class Importer
+        # call-seq:
+        #   Autobuild::Importer.fallback { |package, importer| ... }
+        #
+        # If called, registers the given block as a fallback mechanism for failing
+        # imports.
+        #
+        # Fallbacks are tried in reverse order with the failing importer object as
+        # argument. The first valid importer object that has been returned will be
+        # used instead.
+        #
+        # It is the responsibility of the fallback handler to make sure that it does
+        # not do infinite recursions and stuff like that.
+        def self.fallback(&block)
+            @fallback_handlers.unshift(block)
+        end
 
-    class << self
-        # The set of handlers registered by Importer.fallback
-        attr_reader :fallback_handlers
-    end
+        class << self
+            # The set of handlers registered by Importer.fallback
+            attr_reader :fallback_handlers
+        end
+
+        @fallback_handlers = Array.new
+
+        # Instances of the Importer::Status class represent the status of a current
+        # checkout w.r.t. the remote repository.
+        class Status
+            # Remote and local are at the same point
+            UP_TO_DATE    = 0
+            # Local contains all data that remote has, but has new commits
+            ADVANCED      = 1
+            # Next update will require a merge
+            NEEDS_MERGE   = 2
+            # Next update will be simple (no merge)
+            SIMPLE_UPDATE = 3
+
+            # The update status
+            attr_accessor :status
+            # True if there is code in the working copy that is not committed
+            attr_accessor :uncommitted_code
+            # A list of messages describing differences between the local working
+            # copy and its expected state
+            #
+            # On git, it would for instance mention that currently checked out
+            # branch is not the one autoproj expects
+            #
+            # @return [Array<String>]
+            attr_reader :unexpected_working_copy_state
+
+            # An array of strings that represent commits that are in the remote
+            # repository and not in this one (would be merged by an update)
+            attr_accessor :remote_commits
+            # An array of strings that represent commits that are in the local
+            # repository and not in the remote one (would be pushed by an update)
+            attr_accessor :local_commits
+
+            def initialize(status = -1)
+                @status = status
+                @unexpected_working_copy_state = Array.new
+                @uncommitted_code = false
+                @remote_commits = Array.new
+                @local_commits  = Array.new
+            end
+        end
 
-    @fallback_handlers = Array.new
-
-    # Instances of the Importer::Status class represent the status of a current
-    # checkout w.r.t. the remote repository.
-    class Status
-        # Remote and local are at the same point
-        UP_TO_DATE    = 0
-        # Local contains all data that remote has, but has new commits
-        ADVANCED      = 1
-        # Next update will require a merge
-        NEEDS_MERGE   = 2
-        # Next update will be simple (no merge)
-        SIMPLE_UPDATE = 3
-
-        # The update status
-        attr_accessor :status
-        # True if there is code in the working copy that is not committed
-        attr_accessor :uncommitted_code
-        # A list of messages describing differences between the local working
-        # copy and its expected state
+        # The cache directories for the given importer type.
+        #
+        # This is used by some importers to save disk space and/or avoid downloading
+        # the same things over and over again
+        #
+        # The default global cache directory is initialized from the
+        # AUTOBUILD_CACHE_DIR environment variable. Per-importer cache directories
+        # can be overriden by setting AUTOBUILD_{TYPE}_CACHE_DIR (e.g.
+        # AUTOBUILD_GIT_CACHE_DIR)
+        #
+        # The following importers use caches:
+        # - the archive importer saves downloaded files in the cache. They are
+        #   saved under an archives/ subdirectory of the default cache if set, or to
+        #   the value of AUTOBUILD_ARCHIVES_CACHE_DIR
+        # - the git importer uses the cache directories as alternates for the git
+        #   checkouts
         #
-        # On git, it would for instance mention that currently checked out
-        # branch is not the one autoproj expects
+        # @param [String] type the importer type. If set, it Given a root cache
+        #   directory X, and importer specific cache is setup as a subdirectory of X
+        #   with e.g. X/git or X/archives. The subdirectory name is defined by this
+        #   argument
+        # @return [nil,Array<String>]
         #
-        # @return [Array<String>]
-        attr_reader :unexpected_working_copy_state
-
-        # An array of strings that represent commits that are in the remote
-        # repository and not in this one (would be merged by an update)
-        attr_accessor :remote_commits
-        # An array of strings that represent commits that are in the local
-        # repository and not in the remote one (would be pushed by an update)
-        attr_accessor :local_commits
-
-        def initialize(status = -1)
-            @status = status
-            @unexpected_working_copy_state = Array.new
-            @uncommitted_code = false
-            @remote_commits = Array.new
-            @local_commits  = Array.new
+        # @see .set_cache_dirs .default_cache_dirs .default_cache_dirs=
+        def self.cache_dirs(type)
+            if @cache_dirs[type] || (env = ENV["AUTOBUILD_#{type.upcase}_CACHE_DIR"])
+                @cache_dirs[type] ||= env.split(":")
+            elsif (dirs = default_cache_dirs)
+                dirs.map { |d| File.join(d, type) }
+            end
         end
-    end
 
-    # The cache directories for the given importer type.
-    #
-    # This is used by some importers to save disk space and/or avoid downloading
-    # the same things over and over again
-    #
-    # The default global cache directory is initialized from the
-    # AUTOBUILD_CACHE_DIR environment variable. Per-importer cache directories
-    # can be overriden by setting AUTOBUILD_{TYPE}_CACHE_DIR (e.g.
-    # AUTOBUILD_GIT_CACHE_DIR)
-    #
-    # The following importers use caches:
-    # - the archive importer saves downloaded files in the cache. They are
-    #   saved under an archives/ subdirectory of the default cache if set, or to
-    #   the value of AUTOBUILD_ARCHIVES_CACHE_DIR
-    # - the git importer uses the cache directories as alternates for the git
-    #   checkouts
-    #
-    # @param [String] type the importer type. If set, it Given a root cache
-    #   directory X, and importer specific cache is setup as a subdirectory of X
-    #   with e.g. X/git or X/archives. The subdirectory name is defined by this
-    #   argument
-    # @return [nil,Array<String>]
-    #
-    # @see .set_cache_dirs .default_cache_dirs .default_cache_dirs=
-    def self.cache_dirs(type)
-        if @cache_dirs[type] || (env = ENV["AUTOBUILD_#{type.upcase}_CACHE_DIR"])
-            @cache_dirs[type] ||= env.split(":")
-        elsif dirs = default_cache_dirs
-            dirs.map { |d| File.join(d, type) }
+        # Returns the default cache directory if there is one
+        #
+        # @return [Array<String>,nil]
+        # @see .cache_dirs
+        def self.default_cache_dirs
+            if @default_cache_dirs
+                @default_cache_dirs
+            elsif (from_env = ENV['AUTOBUILD_CACHE_DIR'])
+                @default_cache_dirs = [from_env]
+            end
         end
-    end
 
-    # Returns the default cache directory if there is one
-    #
-    # @return [Array<String>,nil]
-    # @see .cache_dirs
-    def self.default_cache_dirs
-        if @default_cache_dirs ||= ENV['AUTOBUILD_CACHE_DIR']
-            [@default_cache_dirs]
+        # Sets the cache directory for a given importer type
+        #
+        # @param [String] type the importer type
+        # @param [String] dir the cache directory
+        # @see .cache_dirs
+        def self.set_cache_dirs(type, *dirs)
+            @cache_dirs[type] = dirs
         end
-    end
 
-    # Sets the cache directory for a given importer type
-    #
-    # @param [String] type the importer type
-    # @param [String] dir the cache directory
-    # @see .cache_dirs
-    def self.set_cache_dirs(type, *dirs)
-        @cache_dirs[type] = dirs
-    end
+        # Sets the default cache directory
+        #
+        # @param [Array<String>,String] the directories
+        # @see .cache_dirs
+        def self.default_cache_dirs=(dirs)
+            @default_cache_dirs = Array(dirs)
+        end
 
-    # Sets the default cache directory
-    #
-    # @param [Array<String>,String] the directories
-    # @see .cache_dirs
-    def self.default_cache_dirs=(dirs)
-        @default_cache_dirs = Array(dirs)
-    end
+        # Unset all cache directories
+        def self.unset_cache_dirs
+            @cache_dirs = Hash.new
+            @default_cache_dirs = nil
+        end
 
-    # Unset all cache directories
-    def self.unset_cache_dirs
-        @cache_dirs = Hash.new
-        @default_cache_dirs = nil
-    end
+        unset_cache_dirs
 
-    unset_cache_dirs
-
-    # @return [Hash] the original option hash as given to #initialize
-    attr_reader :options
-
-    # Creates a new Importer object. The options known to Importer are:
-    # [:patches] a list of patch to apply after import
-    #
-    # More options are specific to each importer type.
-    def initialize(options)
-        @options = options.dup
-        @options[:retry_count] = Integer(@options[:retry_count] || 0)
-        @repository_id = options[:repository_id] || "#{self.class.name}:#{object_id}"
-        @interactive = options[:interactive]
-        @source_id = options[:source_id] || @repository_id
-        @post_hooks = Array.new
-    end
+        # @return [Hash] the original option hash as given to #initialize
+        attr_reader :options
 
-    # Returns a string that identifies the remote repository uniquely
-    #
-    # This can be used to check whether two importers are pointing to the same
-    # repository, regardless of e.g. the access protocol used.  For instance,
-    # two git importers that point to the same repository but different branches
-    # would have the same repository_id but different source_id
-    #
-    # @return [String]
-    # @see source_id
-    attr_reader :repository_id
-
-    # Returns a string that identifies the remote source uniquely
-    #
-    # This can be used to check whether two importers are pointing to the same
-    # code base inside the same repository. For instance, two git importers that
-    # point to the same repository but different branches would have the same
-    # repository_id but different source_id
-    #
-    # @return [String]
-    # @see repository_id
-    attr_reader :source_id
-
-    # Whether this importer will need interaction with the user, for instance to
-    # give credentials
-    def interactive?; !!@interactive end
-
-    # Changes whether this importer is interactive or not
-    def interactive=(value)
-        @interactive = !!value
-    end
+        # Creates a new Importer object. The options known to Importer are:
+        # [:patches] a list of patch to apply after import
+        #
+        # More options are specific to each importer type.
+        def initialize(options)
+            @options = options.dup
+            @options[:retry_count] = Integer(@options[:retry_count] || 0)
+            @repository_id = options[:repository_id] || "#{self.class.name}:#{object_id}"
+            @interactive = options[:interactive]
+            @source_id = options[:source_id] || @repository_id
+            @post_hooks = Array.new
+        end
 
-    # The number of times update / checkout should be retried before giving up.
-    # The default is 0 (do not retry)
-    #
-    # Set either with #retry_count= or by setting the :retry_count option when
-    # constructing this importer
-    def retry_count
-        @options[:retry_count] || 0
-    end
+        # Returns a string that identifies the remote repository uniquely
+        #
+        # This can be used to check whether two importers are pointing to the same
+        # repository, regardless of e.g. the access protocol used.  For instance,
+        # two git importers that point to the same repository but different branches
+        # would have the same repository_id but different source_id
+        #
+        # @return [String]
+        # @see source_id
+        attr_reader :repository_id
 
-    # Sets the number of times update / checkout should be retried before giving
-    # up. 0 (the default) disables retrying.
-    #
-    # See also #retry_count
-    def retry_count=(count)
-        @options[:retry_count] = Integer(count)
-    end
+        # Returns a string that identifies the remote source uniquely
+        #
+        # This can be used to check whether two importers are pointing to the same
+        # code base inside the same repository. For instance, two git importers that
+        # point to the same repository but different branches would have the same
+        # repository_id but different source_id
+        #
+        # @return [String]
+        # @see repository_id
+        attr_reader :source_id
+
+        # Whether this importer will need interaction with the user, for instance to
+        # give credentials
+        def interactive?
+            @interactive
+        end
 
-    def patches
-        patches =
-            if @options[:patches].respond_to?(:to_ary)
-                @options[:patches]
-            elsif !@options[:patches]
-                []
-            else
-                [[@options[:patches], 0]]
+        # Changes whether this importer is interactive or not
+        attr_writer :interactive
+
+        # The number of times update / checkout should be retried before giving up.
+        # The default is 0 (do not retry)
+        #
+        # Set either with #retry_count= or by setting the :retry_count option when
+        # constructing this importer
+        def retry_count
+            @options[:retry_count] || 0
+        end
+
+        # Returns a unique hash representing the state of the imported package
+        # as a whole unit, including its dependencies and patches
+        def fingerprint(package)
+            vcs_fingerprint_string = vcs_fingerprint(package)
+            return unless vcs_fingerprint_string
+
+            patches_fingerprint_string = patches_fingerprint(package)
+            if patches_fingerprint_string
+                Digest::SHA1.hexdigest(vcs_fingerprint_string + patches_fingerprint_string)
+            elsif patches.empty?
+                vcs_fingerprint_string
             end
+        end
+
+        # basic fingerprint of the package and its dependencies
+        def vcs_fingerprint(package)
+            #each importer type should implement its own 
+            Autoproj.warn "Fingerprint in #{package.name} has not been implemented for this type of packages, results should be discarded"
+            return nil
+        end
+
+        # fingerprint for patches associated to this package
+        def patches_fingerprint(package)
+            cur_patches = currently_applied_patches(package)
+            cur_patches.map(&:shift) #leave only level and source information
+            Digest::SHA1.hexdigest(cur_patches.sort.flatten.join("")) if !patches.empty? && cur_patches
+        end
 
-        if patches.size == 2 && patches[0].respond_to?(:to_str) && patches[1].respond_to?(:to_int)
-            patches = [patches]
-        else
-            patches = patches.map do |obj|
+        # Sets the number of times update / checkout should be retried before giving
+        # up. 0 (the default) disables retrying.
+        #
+        # See also #retry_count
+        def retry_count=(count)
+            @options[:retry_count] = Integer(count)
+        end
+
+        def patches
+            patches =
+                if @options[:patches].respond_to?(:to_ary)
+                    @options[:patches]
+                elsif !@options[:patches]
+                    []
+                else
+                    [[@options[:patches], 0]]
+                end
+
+            single_patch = (patches.size == 2 &&
+                patches[0].respond_to?(:to_str) &&
+                patches[1].respond_to?(:to_int))
+
+            patches = [patches] if single_patch
+            patches.map do |obj|
                 if obj.respond_to?(:to_str)
-                    [obj, 0]
+                    path  = obj
+                    level = 0
                 elsif obj.respond_to?(:to_ary)
-                    obj
+                    path, level = obj
                 else
                     raise Arguments, "wrong patch specification #{obj.inspect}"
-                    obj
                 end
+                [path, level, File.read(path)]
             end
         end
-        patches.map do |path, level|
-            [path, level, File.read(path)]
-        end
-    end
 
-    def update_retry_count(original_error, retry_count)
-        if !original_error.respond_to?(:retry?) ||
-            !original_error.retry?
-            return
+        def update_retry_count(original_error, retry_count)
+            return if !original_error.respond_to?(:retry?) || !original_error.retry?
+
+            retry_count += 1
+            retry_count if retry_count <= self.retry_count
         end
 
-        retry_count += 1
-        if retry_count <= self.retry_count
-            retry_count
+        # A list of hooks that are called after a successful checkout or update
+        #
+        # They are added either at the instance level with {#add_post_hook} or
+        # globally for all importers of a given type with {Importer.add_post_hook}
+        attr_reader :post_hooks
+
+        Hook = Struct.new :always, :callback
+
+        # Define a post-import hook for all instances of this class
+        #
+        # @yieldparam [Importer] importer the importer that finished
+        # @yieldparam [Package] package the package we're acting on
+        # @see Importer#add_post_hook
+        def self.add_post_hook(always: false, &hook)
+            @post_hooks ||= Array.new
+            @post_hooks << Hook.new(always, hook)
+            nil
         end
-    end
 
-    # A list of hooks that are called after a successful checkout or update
-    #
-    # They are added either at the instance level with {#add_post_hook} or
-    # globally for all importers of a given type with {Importer.add_post_hook}
-    attr_reader :post_hooks
-
-    Hook = Struct.new :always, :callback
-
-    # Define a post-import hook for all instances of this class
-    #
-    # @yieldparam [Importer] importer the importer that finished
-    # @yieldparam [Package] package the package we're acting on
-    # @see Importer#add_post_hook
-    def self.add_post_hook(always: false, &hook)
-        @post_hooks ||= Array.new
-        @post_hooks << Hook.new(always, hook)
-        nil
-    end
+        # Enumerate the post-import hooks defined for all instances of this class
+        def self.each_post_hook(error: false)
+            return enum_for(__method__) unless block_given?
 
-    # Enumerate the post-import hooks defined for all instances of this class
-    def self.each_post_hook(error: false)
-        return enum_for(__method__) if !block_given?
+            (@post_hooks ||= Array.new).each do |hook|
+                yield(hook.callback) if hook.always || !error
+            end
+        end
 
-        (@post_hooks ||= Array.new).each do |hook|
-            if hook.always || !error
-                yield(hook.callback)
+        # @api private
+        #
+        # Call the post-import hooks added with {#add_post_hook}
+        def execute_post_hooks(package, error: false)
+            each_post_hook(error: error) do |block|
+                block.call(self, package)
             end
         end
-    end
 
-    # @api private
-    #
-    # Call the post-import hooks added with {#add_post_hook}
-    def execute_post_hooks(package, error: false)
-        each_post_hook(error: error) do |block|
-            block.call(self, package)
+        # Add a block that should be called when the import has successfully
+        # finished
+        #
+        # @yieldparam [Importer] importer the importer that finished
+        # @yieldparam [Package] package the package we're acting on
+        # @see Importer.add_post_hook
+        def add_post_hook(always: false, &hook)
+            post_hooks << Hook.new(always, hook)
         end
-    end
 
-    # Add a block that should be called when the import has successfully
-    # finished
-    #
-    # @yieldparam [Importer] importer the importer that finished
-    # @yieldparam [Package] package the package we're acting on
-    # @see Importer.add_post_hook
-    def add_post_hook(always: false, &hook)
-        post_hooks << Hook.new(always, hook)
-    end
+        # Enumerate the post-import hooks for this importer
+        def each_post_hook(error: false)
+            return enum_for(__method__, error: false) unless block_given?
 
-    # Enumerate the post-import hooks for this importer
-    def each_post_hook(error: false, &hook)
-        return enum_for(__method__) if !block_given?
+            self.class.each_post_hook(error: error) do |callback|
+                yield(callback)
+            end
 
-        self.class.each_post_hook(error: error, &hook)
-        post_hooks.each do |hook|
-            if hook.always || !error
-                yield(hook.callback)
+            post_hooks.each do |hook|
+                yield(hook.callback) if hook.always || !error
             end
         end
-    end
 
-    def perform_update(package,only_local=false)
-        cur_patches    = currently_applied_patches(package)
-        needed_patches = self.patches
-        if cur_patches.map(&:last) != needed_patches.map(&:last)
-            patch(package, [])
-        end
+        def perform_update(package, only_local = false)
+            cur_patches    = currently_applied_patches(package)
+            needed_patches = patches
+            patch_changed = cur_patches.map(&:last) != needed_patches.map(&:last)
+            patch(package, []) if patch_changed
 
-        last_error = nil
-        retry_count = 0
-        package.progress_start "updating %s"
-        begin
+            last_error = nil
+            retry_count = 0
+            package.progress_start "updating %s"
             begin
-                did_update = update(package,only_local)
-                execute_post_hooks(package, error: false)
-            rescue ::Exception
-                execute_post_hooks(package, error: true)
-                raise
-            end
-
-            message = if did_update == false
-                          Autobuild.color('already up-to-date', :green)
-                      else
-                          Autobuild.color('updated', :yellow)
-                      end
-
-            did_update
-        rescue Interrupt
-            message = Autobuild.color('interrupted', :red)
-            if last_error
-                raise last_error
-            else raise
-            end
-        rescue ::Exception => original_error
-            message = Autobuild.color('update failed', :red)
-            last_error = original_error
-            # If the package is patched, it might be that the update
-            # failed because we needed to unpatch first. Try it out
-            #
-            # This assumes that importing data with conflict will
-            # make the import fail, but not make the patch
-            # un-appliable. Importers that do not follow this rule
-            # will have to unpatch by themselves.
-            cur_patches = currently_applied_patches(package)
-            if !cur_patches.empty?
-                package.progress_done
-                package.message "update failed and some patches are applied, removing all patches and retrying"
                 begin
-                    patch(package, [])
-                    return perform_update(package,only_local)
-                rescue Interrupt
-                    raise
+                    did_update = update(package, only_local)
+                    execute_post_hooks(package, error: false)
                 rescue ::Exception
-                    raise original_error
+                    execute_post_hooks(package, error: true)
+                    raise
                 end
-            end
 
-            retry_count = update_retry_count(original_error, retry_count)
-            raise if !retry_count
-            package.message "update failed in #{package.importdir}, retrying (#{retry_count}/#{self.retry_count})"
-            retry
-        ensure
-            package.progress_done "#{message} %s"
-        end
-
-        patch(package)
-        package.updated = true
-        did_update
-    rescue Autobuild::Exception => e
-        fallback(e, package, :import, package)
-    end
+                message = if did_update == false
+                              Autobuild.color('already up-to-date', :green)
+                          else
+                              Autobuild.color('updated', :yellow)
+                          end
 
-    def perform_checkout(package, options = Hash.new)
-        last_error = nil
-        package.progress_start "checking out %s", :done_message => 'checked out %s' do
-            retry_count = 0
-            begin
-                checkout(package, options)
-                execute_post_hooks(package)
+                did_update
             rescue Interrupt
-                if last_error then raise last_error
+                message = Autobuild.color('interrupted', :red)
+                if last_error
+                    raise last_error
                 else raise
                 end
             rescue ::Exception => original_error
+                message = Autobuild.color('update failed', :red)
                 last_error = original_error
-                retry_count = update_retry_count(original_error, retry_count)
-                if !retry_count
-                    raise
+                # If the package is patched, it might be that the update
+                # failed because we needed to unpatch first. Try it out
+                #
+                # This assumes that importing data with conflict will
+                # make the import fail, but not make the patch
+                # un-appliable. Importers that do not follow this rule
+                # will have to unpatch by themselves.
+                cur_patches = currently_applied_patches(package)
+                unless cur_patches.empty?
+                    package.progress_done
+                    package.message "update failed and some patches are applied, "\
+                        "removing all patches and retrying"
+                    begin
+                        patch(package, [])
+                        return perform_update(package, only_local)
+                    rescue Interrupt
+                        raise
+                    rescue ::Exception
+                        raise original_error
+                    end
                 end
-                package.message "checkout of %s failed, deleting the source directory #{package.importdir} and retrying (#{retry_count}/#{self.retry_count})"
-                FileUtils.rm_rf package.importdir
+
+                retry_count = update_retry_count(original_error, retry_count)
+                raise unless retry_count
+
+                package.message "update failed in #{package.importdir}, "\
+                    "retrying (#{retry_count}/#{self.retry_count})"
                 retry
+            ensure
+                package.progress_done "#{message} %s"
             end
+
+            patch(package)
+            package.updated = true
+            did_update
+        rescue Autobuild::Exception => e
+            fallback(e, package, :import, package)
         end
 
-        patch(package)
-        package.updated = true
-    rescue Interrupt
-        raise
-    rescue ::Exception
-        package.message "checkout of %s failed, deleting the source directory #{package.importdir}"
-        FileUtils.rm_rf package.importdir
-        raise
-    rescue Autobuild::Exception => e
-        FileUtils.rm_rf package.importdir
-        fallback(e, package, :import, package)
-    end
+        def perform_checkout(package, options = Hash.new)
+            last_error = nil
+            package.progress_start "checking out %s", :done_message => 'checked out %s' do
+                retry_count = 0
+                begin
+                    checkout(package, options)
+                    execute_post_hooks(package)
+                rescue Interrupt
+                    if last_error then raise last_error
+                    else raise
+                    end
+                rescue ::Exception => original_error
+                    last_error = original_error
+                    retry_count = update_retry_count(original_error, retry_count)
+                    raise unless retry_count
+
+                    package.message "checkout of %s failed, "\
+                        "deleting the source directory #{package.importdir} "\
+                        "and retrying (#{retry_count}/#{self.retry_count})"
+                    FileUtils.rm_rf package.importdir
+                    retry
+                end
+            end
 
-    # Imports the given package
-    #
-    # The importer will checkout or update code in package.importdir. No update
-    # will be done if {update?} returns false.
-    #
-    # @raises ConfigException if package.importdir exists and is not a directory
-    #
-    # @option options [Boolean] :checkout_only (false) if true, the importer
-    #   will not update an already checked-out package.
-    # @option options [Boolean] :only_local (false) if true, will only perform
-    #   actions that do not require network access. Importers that do not
-    #   support this mode will simply do nothing
-    # @option options [Boolean] :reset (false) if true, the importer's
-    #   configuration is interpreted as a hard state in which it should put the
-    #   working copy. Otherwise, it tries to update the local repository with
-    #   the remote information. For instance, a git importer for which a commit
-    #   ID is given will, in this mode, reset the repository to the requested ID
-    #   (if that does not involve losing commits). Otherwise, it will only
-    #   ensure that the requested commit ID is present in the current HEAD.
-    def import(package, options = Hash.new)
-        # Backward compatibility
-        if !options.kind_of?(Hash)
-            options = !!options
-            Autoproj.warn "calling #import with a boolean as second argument is deprecated, switch to the named argument interface instead"
-            Autoproj.warn "   e.g. call import(package, only_local: #{options})"
-            Autoproj.warn "   #{caller(1).first}"
-            options = Hash[only_local: !!options]
-        end
-
-        options = Kernel.validate_options options,
-            only_local: false,
-            reset: false,
-            checkout_only: false,
-            ignore_errors: false,
-            allow_interactive: true
-        ignore_errors = options.delete(:ignore_errors)
-
-        importdir = package.importdir
-        if File.directory?(importdir)
-            package.isolate_errors(mark_as_failed: false, ignore_errors: ignore_errors) do
-                if !options[:checkout_only] && package.update?
-                    perform_update(package, options)
-                else
-                    if Autobuild.verbose
+            patch(package)
+            package.updated = true
+        rescue Interrupt
+            raise
+        rescue ::Exception # rubocop:disable Lint/ShadowedException
+            package.message "checkout of %s failed, "\
+                "deleting the source directory #{package.importdir}"
+            FileUtils.rm_rf package.importdir
+            raise
+        rescue Autobuild::Exception => e
+            FileUtils.rm_rf package.importdir
+            fallback(e, package, :import, package)
+        end
+
+        # Imports the given package
+        #
+        # The importer will checkout or update code in package.importdir. No update
+        # will be done if {update?} returns false.
+        #
+        # @raises ConfigException if package.importdir exists and is not a directory
+        #
+        # @option options [Boolean] :checkout_only (false) if true, the importer
+        #   will not update an already checked-out package.
+        # @option options [Boolean] :only_local (false) if true, will only perform
+        #   actions that do not require network access. Importers that do not
+        #   support this mode will simply do nothing
+        # @option options [Boolean] :reset (false) if true, the importer's
+        #   configuration is interpreted as a hard state in which it should put the
+        #   working copy. Otherwise, it tries to update the local repository with
+        #   the remote information. For instance, a git importer for which a commit
+        #   ID is given will, in this mode, reset the repository to the requested ID
+        #   (if that does not involve losing commits). Otherwise, it will only
+        #   ensure that the requested commit ID is present in the current HEAD.
+        def import(package, options = Hash.new)
+            # Backward compatibility
+            unless options.kind_of?(Hash)
+                options = options
+                Autoproj.warn "calling #import with a boolean as second argument "\
+                    "is deprecated, switch to the named argument interface instead"
+                Autoproj.warn "   e.g. call import(package, only_local: #{options})"
+                Autoproj.warn "   #{caller(1..1).first}"
+                options = Hash[only_local: options]
+            end
+
+            options = Kernel.validate_options options,
+                only_local: false,
+                reset: false,
+                checkout_only: false,
+                ignore_errors: false,
+                allow_interactive: true
+            ignore_errors = options.delete(:ignore_errors)
+
+            importdir = package.importdir
+            if File.directory?(importdir)
+                package.isolate_errors(mark_as_failed: false,
+                                       ignore_errors: ignore_errors) do
+                    if !options[:checkout_only] && package.update?
+                        perform_update(package, options)
+                    elsif Autobuild.verbose
                         package.message "%s: not updating"
                     end
                 end
-            end
 
-        elsif File.exist?(importdir)
-            raise ConfigException.new(package, 'import'), "#{importdir} exists but is not a directory"
-        else
-            package.isolate_errors(mark_as_failed: true, ignore_errors: ignore_errors) do
-                perform_checkout(package, allow_interactive: options[:allow_interactive])
-                true
+            elsif File.exist?(importdir)
+                raise ConfigException.new(package, 'import'),
+                    "#{importdir} exists but is not a directory"
+            else
+                package.isolate_errors(mark_as_failed: true,
+                                       ignore_errors: ignore_errors) do
+                    perform_checkout(package,
+                        allow_interactive: options[:allow_interactive])
+                    true
+                end
             end
         end
-    end
 
-    # Tries to find a fallback importer because of the given error.
-    def fallback(error, package, *args, &block)
-        Importer.fallback_handlers.each do |handler|
-            fallback_importer = handler.call(package, self)
-            if fallback_importer.kind_of?(Importer)
-                begin
-                    return fallback_importer.send(*args, &block)
-                rescue Exception
-                    raise error
+        # Tries to find a fallback importer because of the given error.
+        def fallback(error, package, *args, &block)
+            Importer.fallback_handlers.each do |handler|
+                fallback_importer = handler.call(package, self)
+                if fallback_importer.kind_of?(Importer)
+                    begin
+                        return fallback_importer.send(*args, &block)
+                    rescue Exception
+                        raise error
+                    end
                 end
             end
+            raise error
         end
-        raise error
-    end
 
-    def patchdir(package)
-        File.join(package.importdir, ".autobuild-patches")
-    end
-    
-    # We assume that package.importdir already exists (checkout is supposed to
-    # have been called)
-    def patchlist(package)
-        File.join(patchdir(package), "list")
-    end
+        def patchdir(package)
+            File.join(package.importdir, ".autobuild-patches")
+        end
 
-    def call_patch(package, reverse, file, patch_level)
-        package.run(:patch, Autobuild.tool('patch'),
-                    "-p#{patch_level}", (reverse ? '-R' : nil), '--forward', input: file,
-                    working_directory: package.importdir)
-    end
+        # We assume that package.importdir already exists (checkout is supposed to
+        # have been called)
+        def patchlist(package)
+            File.join(patchdir(package), "list")
+        end
 
-    def apply(package, path, patch_level = 0);   call_patch(package, false, path, patch_level) end
-    def unapply(package, path, patch_level = 0); call_patch(package, true, path, patch_level)   end
+        def call_patch(package, reverse, file, patch_level)
+            package.run(:patch, Autobuild.tool('patch'),
+                        "-p#{patch_level}", (reverse ? '-R' : nil), '--forward',
+                        input: file, working_directory: package.importdir)
+        end
 
-    def parse_patch_list(package, patches_file)
-        File.readlines(patches_file).map do |line| 
-            line = line.rstrip
-            if line =~ /^(.*)\s+(\d+)$/
-                path = File.expand_path($1, package.srcdir)
-                level = Integer($2)
-            else
-                path = File.expand_path(line, package.srcdir)
-                level = 0
-            end
-            [path, level, File.read(path)]
+        def apply(package, path, patch_level = 0)
+            call_patch(package, false, path, patch_level)
         end
-    end
 
-    def currently_applied_patches(package)
-        patches_file = patchlist(package)
-        if File.exist?(patches_file)
-            return parse_patch_list(package, patches_file)
+        def unapply(package, path, patch_level = 0)
+            call_patch(package, true, path, patch_level)
         end
 
-        patches_file = File.join(package.importdir, "patches-autobuild-stamp")
-        if File.exist?(patches_file)
-            cur_patches = parse_patch_list(package, patches_file)
-            save_patch_state(package, cur_patches)
-            FileUtils.rm_f patches_file
-            return currently_applied_patches(package)
+        def parse_patch_list(package, patches_file)
+            File.readlines(patches_file).map do |line|
+                line = line.rstrip
+                if line =~ /^(.*)\s+(\d+)$/
+                    path = File.expand_path($1, package.srcdir)
+                    level = Integer($2)
+                else
+                    path = File.expand_path(line, package.srcdir)
+                    level = 0
+                end
+                [path, level, File.read(path)]
+            end
         end
 
-        return Array.new
-    end
+        def currently_applied_patches(package)
+            patches_file = patchlist(package)
+            return parse_patch_list(package, patches_file) if File.exist?(patches_file)
 
-    def patch(package, patches = self.patches)
-        # Get the list of already applied patches
-        cur_patches = currently_applied_patches(package)
-
-        cur_patches_state = cur_patches.map { |_, level, content| [level, content] }
-        patches_state     = patches.map { |_, level, content| [level, content] }
-        if cur_patches_state == patches_state
-            return false
-        end
-
-        # Do not be smart, remove all already applied patches
-        # and then apply the new ones
-        begin
-            apply_count = (patches - cur_patches).size
-            unapply_count = (cur_patches - patches).size
-            if apply_count > 0 && unapply_count > 0
-                package.message "patching %s: applying #{apply_count} and unapplying #{unapply_count} patch(es)"
-            elsif apply_count > 0
-                package.message "patching %s: applying #{apply_count} patch(es)"
-            elsif unapply_count > 0
-                package.message "patching %s: unapplying #{unapply_count} patch(es)"
+            patches_file = File.join(package.importdir, "patches-autobuild-stamp")
+            if File.exist?(patches_file)
+                cur_patches = parse_patch_list(package, patches_file)
+                save_patch_state(package, cur_patches)
+                FileUtils.rm_f patches_file
+                return currently_applied_patches(package)
             end
 
-            while p = cur_patches.last
-                p, level, _ = *p
-                unapply(package, p, level)
-                cur_patches.pop
-            end
+            []
+        end
 
-            patches.to_a.each do |new_patch, new_patch_level, content|
-                apply(package, new_patch, new_patch_level)
-                cur_patches << [new_patch, new_patch_level, content]
+        def patch(package, patches = self.patches)
+            # Get the list of already applied patches
+            cur_patches = currently_applied_patches(package)
+
+            cur_patches_state = cur_patches.map { |_, level, content| [level, content] }
+            patches_state     = patches.map { |_, level, content| [level, content] }
+            return false if cur_patches_state == patches_state
+
+            # Do not be smart, remove all already applied patches
+            # and then apply the new ones
+            begin
+                apply_count = (patches - cur_patches).size
+                unapply_count = (cur_patches - patches).size
+                if apply_count > 0 && unapply_count > 0
+                    package.message "patching %s: applying #{apply_count} and "\
+                        "unapplying #{unapply_count} patch(es)"
+                elsif apply_count > 0
+                    package.message "patching %s: applying #{apply_count} patch(es)"
+                elsif unapply_count > 0
+                    package.message "patching %s: unapplying #{unapply_count} patch(es)"
+                end
+
+                while (p = cur_patches.last)
+                    p, level, = *p
+                    unapply(package, p, level)
+                    cur_patches.pop
+                end
+
+                patches.to_a.each do |new_patch, new_patch_level, content|
+                    apply(package, new_patch, new_patch_level)
+                    cur_patches << [new_patch, new_patch_level, content]
+                end
+            ensure
+                save_patch_state(package, cur_patches)
             end
-        ensure
-            save_patch_state(package, cur_patches)
+
+            true
         end
 
-        return true
-    end
-    
-    def save_patch_state(package, cur_patches)
-        patch_dir = patchdir(package)
-        FileUtils.mkdir_p patch_dir
-        cur_patches = cur_patches.each_with_index.map do |(path, level, content), idx|
-            path = File.join(patch_dir, idx.to_s)
-            File.open(path, 'w') do |patch_io|
-                patch_io.write content
+        def save_patch_state(package, cur_patches)
+            patch_dir = patchdir(package)
+            FileUtils.mkdir_p patch_dir
+            cur_patches = cur_patches.each_with_index.
+                map do |(_path, level, content), idx|
+                    path = File.join(patch_dir, idx.to_s)
+                    File.open(path, 'w') do |patch_io|
+                        patch_io.write content
+                    end
+                    [path, level]
+                end
+            File.open(patchlist(package), 'w') do |f|
+                patch_state = cur_patches.map do |path, level|
+                    path = Pathname.new(path).
+                        relative_path_from(Pathname.new(package.srcdir)).to_s
+                    "#{path} #{level}"
+                end
+                f.write(patch_state.join("\n"))
             end
-            [path, level]
         end
-        File.open(patchlist(package), 'w') do |f|
-            patch_state = cur_patches.map do |path, level|
-                path = Pathname.new(path).relative_path_from( Pathname.new(package.srcdir) ).to_s
-                "#{path} #{level}"
-            end
-            f.write(patch_state.join("\n"))
+
+        def supports_relocation?
+            false
         end
     end
-
-    def supports_relocation?; false end
 end
-end
-