autoproj 2.15.0 → 2.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e37a5cc9f8c9ada28c0adbf2fed26100734010c4076251e49efdcacc55692a8f
-  data.tar.gz: e0d14e06bd7531fa0e572f1af4a85d805480a50457cce7e433c3d6f54331c546
+  metadata.gz: 79dfca26614ef3c2b0491b7c91979986dd94e3c74ae0a15bc4a3b6729c0d0bd4
+  data.tar.gz: 425261fdab1ec54880133f874a357a1b4adb0a247d08c421da02dde615e4c1b4
 SHA512:
-  metadata.gz: 1b8194f91586c641f6ea957791a8511d94eac07b454a45a77ac67e085bd3a96251ba87193dd0410709863d97db4fde959911c1e3911b86d49e5cfb3808cbcd94
-  data.tar.gz: 2d05c7b38d65095aac4183967c036e86dc596d765e5a236cad7af5b19e8d6d56188d6da42a227b6aa4080ea71356ac70521cbc86ef10a27fe6682c9f0a80b46b
+  metadata.gz: 2e46b35e75abf68b4cf1643ffe96b915179b3a2e59862c95248ed64ae8eb1d54ae892ea7dd006db87f7722a065f24512e26435e0f848458d23e67f12a41f7165
+  data.tar.gz: 371003014229e5023749734b108bf4484059ad3fd0e73f9b7dfcf6cabe426d709b8d2aca75415b10687354eae17eebf9c6b6835006c505f40a1093983217084d

data/autoproj.gemspec

@@ -29,7 +29,9 @@ Gem::Specification.new do |s|
     s.add_runtime_dependency "backports", "~> 3.0"
     s.add_runtime_dependency "bundler"
     s.add_runtime_dependency "concurrent-ruby", "~> 1.1"
+    s.add_runtime_dependency "parslet"
     s.add_runtime_dependency "rb-inotify" if RbConfig::CONFIG["target_os"] =~ /linux/
+    s.add_runtime_dependency "rgl", "~> 0.5.7"
     s.add_runtime_dependency "thor", "~> 1.0"
     s.add_runtime_dependency "tty-color", "~> 0.5.0"
     s.add_runtime_dependency "tty-prompt", "~> 0.21.0"

data/bin/autoproj_bootstrap

@@ -172,16 +172,23 @@ module Autoproj
             attr_writer :local
 
             # The user-wide place where RubyGems installs gems
-            def dot_gem_dir
-                File.join(Gem.user_home, ".gem")
+            def self.dot_gem_dir
+                if Gem.respond_to?(:data_home) # Debian 11+
+                    File.join(Gem.data_home, "gem")
+                else
+                    File.join(Gem.user_home, ".gem")
+                end
             end
 
             # The version and platform-specific suffix under {#dot_gem_dir}
             #
             # This is also the suffix used by bundler to install gems
-            def gem_path_suffix
-                @gem_path_suffix ||= Pathname.new(Gem.user_dir)
-                                             .relative_path_from(Pathname.new(dot_gem_dir)).to_s
+            def self.gems_path_suffix
+                @gems_path_suffix ||=
+                    Pathname
+                    .new(Gem.user_dir)
+                    .relative_path_from(Pathname.new(dot_gem_dir))
+                    .to_s
             end
 
             # The path into which the workspace's gems should be installed
@@ -196,13 +203,13 @@ module Autoproj
             #
             # @return [String]
             def gems_gem_home
-                File.join(gems_install_path, gem_path_suffix)
+                File.join(gems_install_path, self.class.gems_path_suffix)
             end
             # Sets where the workspace's gems should be installed
             #
             # @param [String] path the absolute path that should be given to
             #   bundler. The gems themselves will be installed in the
-            #   {#gem_path_suffix} subdirectory under this
+            #   {.gems_path_suffix} subdirectory under this
 
             private def xdg_var(varname, default)
                 if (env = ENV[varname]) && !env.empty?
@@ -439,32 +446,42 @@ module Autoproj
                 lockfile = File.join(dot_autoproj, "Gemfile.lock")
                 FileUtils.rm lockfile if File.exist?(lockfile)
 
-                clean_env = env_for_child.dup
+                run_bundler(bundler, "config", "set", "--local", "path", gems_install_path,
+                            bundler_version: bundler_version)
+                run_bundler(bundler, "config", "set", "--local", "shebang", Gem.ruby,
+                            bundler_version: bundler_version)
+
+                install_args = ["--gemfile=#{autoproj_gemfile_path}"]
+                install_args << "--local" if local?
+                run_bundler(bundler, "install", *install_args,
+                            bundler_version: bundler_version)
 
-                opts = Array.new
-                opts << "--local" if local?
-                opts << "--path=#{gems_install_path}"
                 shims_path = File.join(dot_autoproj, "bin")
+                run_bundler(bundler, "binstubs", "--all", "--force", "--path", shims_path,
+                            bundler_version: bundler_version)
+                self.class.rewrite_shims(
+                    shims_path, ruby_executable, root_dir,
+                    autoproj_gemfile_path, gems_gem_home
+                )
+            end
+
+            class BundlerFailed < RuntimeError; end
+
+            def run_bundler(bundler, *args, bundler_version: self.bundler_version)
+                clean_env = env_for_child.dup
 
                 version_arg = []
                 version_arg << "_#{bundler_version}_" if bundler_version
 
                 result = system(
-                    clean_env,
-                    Gem.ruby, bundler, *version_arg, "install",
-                    "--gemfile=#{autoproj_gemfile_path}",
-                    "--shebang=#{Gem.ruby}",
-                    "--binstubs=#{shims_path}",
-                    *opts, chdir: dot_autoproj
+                    clean_env, Gem.ruby, bundler, *version_arg,
+                    *args, chdir: dot_autoproj
                 )
 
                 unless result
-                    STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
-                    exit 1
+                    raise BundlerFailed,
+                          "FAILED: bundler #{args.join(', ')} in #{dot_autoproj}"
                 end
-            ensure
-                self.class.rewrite_shims(shims_path, ruby_executable,
-                                         root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
             EXCLUDED_FROM_SHIMS = %w[rake thor].freeze
@@ -491,6 +508,7 @@ module Autoproj
                     bin_shim = File.join(shim_path, bin_name)
                     bin_script_lines = File.readlines(bin_script)
                     next if has_autoproj_preamble?(bin_script_lines)
+                    next unless ruby_script?(bin_script_lines)
 
                     File.open(bin_shim, "w") do |io|
                         if bin_name == "bundler" || bin_name == "bundle"
@@ -505,6 +523,10 @@ module Autoproj
                 end
             end
 
+            def self.ruby_script?(script_lines)
+                script_lines.first =~ /\#\s*!(.*ruby.*)/
+            end
+
             def self.new_style_bundler_binstub?(script_lines)
                 script_lines.any? { |l| l =~ /This file was generated by Bundler/ }
             end

data/bin/autoproj_install

@@ -172,16 +172,23 @@ module Autoproj
             attr_writer :local
 
             # The user-wide place where RubyGems installs gems
-            def dot_gem_dir
-                File.join(Gem.user_home, ".gem")
+            def self.dot_gem_dir
+                if Gem.respond_to?(:data_home) # Debian 11+
+                    File.join(Gem.data_home, "gem")
+                else
+                    File.join(Gem.user_home, ".gem")
+                end
             end
 
             # The version and platform-specific suffix under {#dot_gem_dir}
             #
             # This is also the suffix used by bundler to install gems
-            def gem_path_suffix
-                @gem_path_suffix ||= Pathname.new(Gem.user_dir)
-                                             .relative_path_from(Pathname.new(dot_gem_dir)).to_s
+            def self.gems_path_suffix
+                @gems_path_suffix ||=
+                    Pathname
+                    .new(Gem.user_dir)
+                    .relative_path_from(Pathname.new(dot_gem_dir))
+                    .to_s
             end
 
             # The path into which the workspace's gems should be installed
@@ -196,13 +203,13 @@ module Autoproj
             #
             # @return [String]
             def gems_gem_home
-                File.join(gems_install_path, gem_path_suffix)
+                File.join(gems_install_path, self.class.gems_path_suffix)
             end
             # Sets where the workspace's gems should be installed
             #
             # @param [String] path the absolute path that should be given to
             #   bundler. The gems themselves will be installed in the
-            #   {#gem_path_suffix} subdirectory under this
+            #   {.gems_path_suffix} subdirectory under this
 
             private def xdg_var(varname, default)
                 if (env = ENV[varname]) && !env.empty?
@@ -439,32 +446,42 @@ module Autoproj
                 lockfile = File.join(dot_autoproj, "Gemfile.lock")
                 FileUtils.rm lockfile if File.exist?(lockfile)
 
-                clean_env = env_for_child.dup
+                run_bundler(bundler, "config", "set", "--local", "path", gems_install_path,
+                            bundler_version: bundler_version)
+                run_bundler(bundler, "config", "set", "--local", "shebang", Gem.ruby,
+                            bundler_version: bundler_version)
+
+                install_args = ["--gemfile=#{autoproj_gemfile_path}"]
+                install_args << "--local" if local?
+                run_bundler(bundler, "install", *install_args,
+                            bundler_version: bundler_version)
 
-                opts = Array.new
-                opts << "--local" if local?
-                opts << "--path=#{gems_install_path}"
                 shims_path = File.join(dot_autoproj, "bin")
+                run_bundler(bundler, "binstubs", "--all", "--force", "--path", shims_path,
+                            bundler_version: bundler_version)
+                self.class.rewrite_shims(
+                    shims_path, ruby_executable, root_dir,
+                    autoproj_gemfile_path, gems_gem_home
+                )
+            end
+
+            class BundlerFailed < RuntimeError; end
+
+            def run_bundler(bundler, *args, bundler_version: self.bundler_version)
+                clean_env = env_for_child.dup
 
                 version_arg = []
                 version_arg << "_#{bundler_version}_" if bundler_version
 
                 result = system(
-                    clean_env,
-                    Gem.ruby, bundler, *version_arg, "install",
-                    "--gemfile=#{autoproj_gemfile_path}",
-                    "--shebang=#{Gem.ruby}",
-                    "--binstubs=#{shims_path}",
-                    *opts, chdir: dot_autoproj
+                    clean_env, Gem.ruby, bundler, *version_arg,
+                    *args, chdir: dot_autoproj
                 )
 
                 unless result
-                    STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
-                    exit 1
+                    raise BundlerFailed,
+                          "FAILED: bundler #{args.join(', ')} in #{dot_autoproj}"
                 end
-            ensure
-                self.class.rewrite_shims(shims_path, ruby_executable,
-                                         root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
             EXCLUDED_FROM_SHIMS = %w[rake thor].freeze
@@ -491,6 +508,7 @@ module Autoproj
                     bin_shim = File.join(shim_path, bin_name)
                     bin_script_lines = File.readlines(bin_script)
                     next if has_autoproj_preamble?(bin_script_lines)
+                    next unless ruby_script?(bin_script_lines)
 
                     File.open(bin_shim, "w") do |io|
                         if bin_name == "bundler" || bin_name == "bundle"
@@ -505,6 +523,10 @@ module Autoproj
                 end
             end
 
+            def self.ruby_script?(script_lines)
+                script_lines.first =~ /\#\s*!(.*ruby.*)/
+            end
+
             def self.new_style_bundler_binstub?(script_lines)
                 script_lines.any? { |l| l =~ /This file was generated by Bundler/ }
             end

data/lib/autoproj/autobuild.rb

@@ -1,4 +1,5 @@
 require "autoproj/autobuild_extensions/package"
+require "autoproj/autobuild_extensions/python"
 require "autoproj/autobuild_extensions/archive_importer"
 require "autoproj/autobuild_extensions/git"
 require "autoproj/autobuild_extensions/svn"
@@ -16,3 +17,6 @@ end
 Autobuild::SVN.class_eval do
     prepend Autoproj::AutobuildExtensions::SVN
 end
+Autobuild::Python.class_eval do
+    prepend Autoproj::AutobuildExtensions::Python
+end

data/lib/autoproj/autobuild_extensions/dsl.rb

@@ -20,6 +20,28 @@ module Autoproj
         end
     end
 
+    class << self
+        attr_writer :custom_package_handlers
+
+        def custom_package_handlers
+            @custom_package_handlers ||= []
+        end
+    end
+
+    def self.each_custom_package_handler(&block)
+        return enum_for(__method__) unless block_given?
+
+        custom_package_handlers.each do |handler|
+            block.call(handler)
+        end
+    end
+
+    # Registers a block that will be called to determine a package
+    # handler for the package in full_path.
+    def self.custom_package_handler(&block)
+        custom_package_handlers << block
+    end
+
     # @api private
     #
     # Helper method that extracts the package name from a Rake-style package
@@ -112,6 +134,10 @@ module Autoproj
 
     # Tries to find a handler automatically for 'full_path'
     def self.package_handler_for(full_path)
+        each_custom_package_handler do |handler|
+            pair = handler.call(full_path)
+            return pair if pair
+        end
         pyglob = File.join(File.basename(full_path), "*.py")
         if !Dir.enum_for(:glob, File.join(full_path, "*.orogen")).to_a.empty?
             ["orogen_package", full_path]

data/lib/autoproj/autobuild_extensions/python.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Autoproj
+    module AutobuildExtensions
+        # Extension for Autobuild::Python
+        module Python
+            def activate_python
+                Autoproj::Python.setup_python_configuration_options(ws: ws)
+                Autoproj::Python.assert_python_activated(ws: ws)
+            end
+
+            def update_environment
+                activate_python
+                super
+            end
+        end
+    end
+end

data/lib/autoproj/configuration.rb

@@ -270,13 +270,12 @@ module Autoproj
 
         # The user-wide place where RubyGems installs gems
         def self.dot_gem_dir
-            File.join(Gem.user_home, ".gem")
+            Ops::Install.dot_gem_dir
         end
 
         # The Ruby platform and version-specific subdirectory used by bundler and rubygem
         def self.gems_path_suffix
-            @gems_path_suffix ||= Pathname.new(Gem.user_dir)
-                                          .relative_path_from(Pathname.new(dot_gem_dir)).to_s
+            Ops::Install.gems_path_suffix
         end
 
         # The gem install root into which the workspace gems are installed

data/lib/autoproj/ops/configuration.rb

@@ -1,9 +1,54 @@
+require "rgl/adjacency"
+require "rgl/dot"
+require "rgl/topsort"
+
 module Autoproj
     module Ops
         #--
         # NOTE: indentation is wrong to let git track the history properly
         #+++
 
+        # PackageSetHierachy be used to build the hierarchy of package set
+        # imports, as directed acyclic graph (DAG)
+        # so that they can be (topologically) sorted according to their
+        # dependencies
+        class PackageSetHierarchy
+            attr_reader :dag
+
+            def initialize(package_sets, root_pkg_set)
+                @dag = RGL::DirectedAdjacencyGraph.new
+
+                package_sets.each do |p|
+                    p.imports.each do |dep|
+                        @dag.add_edge dep, p
+                    end
+                end
+
+                @dag.add_vertex root_pkg_set
+                import_order = root_pkg_set.imports.to_a
+                import_order.each_with_index do |p, index|
+                    if index + 1 < import_order.size
+                        @dag.add_edge p, import_order[index + 1]
+                        @dag.add_edge p, root_pkg_set
+                    end
+                end
+
+                unless @dag.acyclic?
+                    raise "The package set hierarchy contains cycles: #{@dag.cycles}"
+                end
+            end
+
+            # Flatten the hierarchy, a establish a sorting
+            def flatten
+                @dag.topsort_iterator.to_a
+            end
+
+            # Write the hierarchy to an image (png) file
+            def to_png(path)
+                @dag.write_to_graphic_file("png", path.gsub(".png", ""))
+            end
+        end
+
         # Implementation of the operations to manage the configuration
         class Configuration
             attr_reader :ws
@@ -160,7 +205,6 @@ module Autoproj
             def load_package_set(vcs, options, imported_from)
                 pkg_set = PackageSet.new(ws, vcs)
                 pkg_set.auto_imports = options[:auto_imports]
-                ws.load_if_present(pkg_set, pkg_set.local_dir, "init.rb")
                 pkg_set.load_description_file
                 if imported_from
                     pkg_set.imported_from << imported_from
@@ -314,57 +358,19 @@ module Autoproj
                 to_s
             end
 
+            # Sort the package sets by dependency order
+            # Package sets that have no dependencies come first,
+            # the local package set (by main configuration) last
             def sort_package_sets_by_import_order(package_sets, root_pkg_set)
-                # The sorting is done in two steps:
-                #  - first, we build a topological order of the package sets
-                #  - then, we insert the auto-imported packages, following this
-                #    topological order, in the user-provided order. Each package is
-                #    considered in turn, and added at the earliest place that fits
-                #    the dependencies
-                topological = Array.new
-                queue = (package_sets.to_a + [root_pkg_set]).uniq
-                until queue.empty?
-                    last_size = queue.size
-                    pending = queue.dup
-                    queue = Array.new
-                    until pending.empty?
-                        pkg_set = pending.shift
-                        if pkg_set.imports.any? { |imported_set| !topological.include?(imported_set) }
-                            queue.push(pkg_set)
-                        else
-                            topological << pkg_set
-                        end
-                    end
-                    if queue.size == last_size
-                        raise ArgumentError, "cannot resolve the dependencies between package sets. There seem to be a cycle amongst #{queue.map(&:name).sort.join(', ')}"
-                    end
-                end
-
-                result = root_pkg_set.imports.to_a.dup
-                to_insert = topological.dup
-                                       .find_all { |p| !result.include?(p) }
-                until to_insert.empty?
-                    pkg_set = to_insert.shift
-                    dependencies = pkg_set.imports.dup
-                    if dependencies.empty?
-                        result.unshift(pkg_set)
-                    else
-                        i = result.find_index do |p|
-                            dependencies.delete(p)
-                            dependencies.empty?
-                        end
-                        result.insert(i + 1, pkg_set)
-                    end
-                end
+                c = PackageSetHierarchy.new(package_sets, root_pkg_set)
+                sorted_pkg_sets = c.flatten
 
-                # Sanity check related to the root package set
-                # - it should be last
-                # - it should be present only once
-                if result.last != root_pkg_set
-                    raise InternalError, "failed to sort the package sets: the root package set should be last, but is not"
+                if sorted_pkg_sets.last != root_pkg_set
+                    raise InternalError, "Failed to sort the package sets: the " \
+                                         "root package set should be last, but is not #{sorted_pkg_sets.map(&:name)}"
                 end
 
-                result
+                sorted_pkg_sets
             end
 
             def load_package_sets(
@@ -623,6 +629,7 @@ module Autoproj
                 package_sets = sort_package_sets_by_import_order(package_sets, root_pkg_set)
                 ws.manifest.reset_package_sets
                 package_sets.each do |pkg_set|
+                    ws.load_if_present(pkg_set, pkg_set.local_dir, "init.rb")
                     ws.manifest.register_package_set(pkg_set)
                 end
                 failures

data/lib/autoproj/ops/import.rb

@@ -467,7 +467,9 @@ module Autoproj
 
                 raise failures.first if !keep_going && !failures.empty?
 
-                install_internal_dependencies_for(*all_processed_packages)
+                install_internal_dependencies_for(
+                    *all_processed_packages, install_only: import_options[:checkout_only]
+                )
                 finalize_package_load(all_processed_packages, auto_exclude: auto_exclude)
 
                 all_enabled_osdeps = selection.each_osdep_package_name.to_set

data/lib/autoproj/ops/install.rb

@@ -162,16 +162,23 @@ module Autoproj
             attr_writer :local
 
             # The user-wide place where RubyGems installs gems
-            def dot_gem_dir
-                File.join(Gem.user_home, ".gem")
+            def self.dot_gem_dir
+                if Gem.respond_to?(:data_home) # Debian 11+
+                    File.join(Gem.data_home, "gem")
+                else
+                    File.join(Gem.user_home, ".gem")
+                end
             end
 
             # The version and platform-specific suffix under {#dot_gem_dir}
             #
             # This is also the suffix used by bundler to install gems
-            def gem_path_suffix
-                @gem_path_suffix ||= Pathname.new(Gem.user_dir)
-                                             .relative_path_from(Pathname.new(dot_gem_dir)).to_s
+            def self.gems_path_suffix
+                @gems_path_suffix ||=
+                    Pathname
+                    .new(Gem.user_dir)
+                    .relative_path_from(Pathname.new(dot_gem_dir))
+                    .to_s
             end
 
             # The path into which the workspace's gems should be installed
@@ -186,13 +193,13 @@ module Autoproj
             #
             # @return [String]
             def gems_gem_home
-                File.join(gems_install_path, gem_path_suffix)
+                File.join(gems_install_path, self.class.gems_path_suffix)
             end
             # Sets where the workspace's gems should be installed
             #
             # @param [String] path the absolute path that should be given to
             #   bundler. The gems themselves will be installed in the
-            #   {#gem_path_suffix} subdirectory under this
+            #   {.gems_path_suffix} subdirectory under this
 
             private def xdg_var(varname, default)
                 if (env = ENV[varname]) && !env.empty?
@@ -429,32 +436,42 @@ module Autoproj
                 lockfile = File.join(dot_autoproj, "Gemfile.lock")
                 FileUtils.rm lockfile if File.exist?(lockfile)
 
-                clean_env = env_for_child.dup
+                run_bundler(bundler, "config", "set", "--local", "path", gems_install_path,
+                            bundler_version: bundler_version)
+                run_bundler(bundler, "config", "set", "--local", "shebang", Gem.ruby,
+                            bundler_version: bundler_version)
+
+                install_args = ["--gemfile=#{autoproj_gemfile_path}"]
+                install_args << "--local" if local?
+                run_bundler(bundler, "install", *install_args,
+                            bundler_version: bundler_version)
 
-                opts = Array.new
-                opts << "--local" if local?
-                opts << "--path=#{gems_install_path}"
                 shims_path = File.join(dot_autoproj, "bin")
+                run_bundler(bundler, "binstubs", "--all", "--force", "--path", shims_path,
+                            bundler_version: bundler_version)
+                self.class.rewrite_shims(
+                    shims_path, ruby_executable, root_dir,
+                    autoproj_gemfile_path, gems_gem_home
+                )
+            end
+
+            class BundlerFailed < RuntimeError; end
+
+            def run_bundler(bundler, *args, bundler_version: self.bundler_version)
+                clean_env = env_for_child.dup
 
                 version_arg = []
                 version_arg << "_#{bundler_version}_" if bundler_version
 
                 result = system(
-                    clean_env,
-                    Gem.ruby, bundler, *version_arg, "install",
-                    "--gemfile=#{autoproj_gemfile_path}",
-                    "--shebang=#{Gem.ruby}",
-                    "--binstubs=#{shims_path}",
-                    *opts, chdir: dot_autoproj
+                    clean_env, Gem.ruby, bundler, *version_arg,
+                    *args, chdir: dot_autoproj
                 )
 
                 unless result
-                    STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
-                    exit 1
+                    raise BundlerFailed,
+                          "FAILED: bundler #{args.join(', ')} in #{dot_autoproj}"
                 end
-            ensure
-                self.class.rewrite_shims(shims_path, ruby_executable,
-                                         root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
             EXCLUDED_FROM_SHIMS = %w[rake thor].freeze
@@ -481,6 +498,7 @@ module Autoproj
                     bin_shim = File.join(shim_path, bin_name)
                     bin_script_lines = File.readlines(bin_script)
                     next if has_autoproj_preamble?(bin_script_lines)
+                    next unless ruby_script?(bin_script_lines)
 
                     File.open(bin_shim, "w") do |io|
                         if bin_name == "bundler" || bin_name == "bundle"
@@ -495,6 +513,10 @@ module Autoproj
                 end
             end
 
+            def self.ruby_script?(script_lines)
+                script_lines.first =~ /\#\s*!(.*ruby.*)/
+            end
+
             def self.new_style_bundler_binstub?(script_lines)
                 script_lines.any? { |l| l =~ /This file was generated by Bundler/ }
             end

data/lib/autoproj/package_managers/apt_dpkg_manager.rb

@@ -9,6 +9,12 @@ module Autoproj
         class AptDpkgManager < ShellScriptManager
             attr_accessor :status_file
 
+            class << self
+                def inherit
+                    @inherit ||= Set.new
+                end
+            end
+
             def initialize(ws, status_file = "/var/lib/dpkg/status")
                 @status_file = status_file
                 @installed_packages = nil
@@ -129,6 +135,7 @@ module Autoproj
                 end
             end
 
+            # rubocop:disable Metrics/AbcSize
             def install(packages, filter_uptodate_packages: false, install_only: false)
                 if filter_uptodate_packages || install_only
                     already_installed, missing = packages.partition do |package_name|
@@ -144,12 +151,13 @@ module Autoproj
                     packages = missing + (need_update || [])
                 end
 
-                if super(packages)
+                if super(packages, inherit: self.class.inherit)
                     # Invalidate caching of installed packages, as we just
                     # installed new packages !
                     @installed_packages = nil
                 end
             end
+            # rubocop:enable Metrics/AbcSize
         end
     end
 end