autoproj 2.12.0 → 2.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a68519807da7c2961d51b2036e82906d450b7726b97fdf7b61f79ab15918a506
-  data.tar.gz: f7951a66ca5422a51dc4c8f15d979916ae85ee0ff84fb7bdaeb83d3df72dc0ac
+  metadata.gz: 214fd95f143468744f972355eefe4d626db36b1b9682c47998fc33373f1e5af5
+  data.tar.gz: 7fc8e361877c7ae1a66da15c00661e858cde213e6cf152c83799a7af71d910bf
 SHA512:
-  metadata.gz: f84abc55dc7ac4c1d09a4478c86dd33b05a71e53d5368eb501bc31b637c48ab24ed13587300a6f2760d3731b95bb9bdbf46138c18ef4f9e8c1bd7a90ab1a15df
-  data.tar.gz: 02da417bb10600b48425087f732c823930ce5e573724d097927f9c49381b5e15fe3c682cbc52248fafd943e0b2bc4b7b15db9ebe7415b4599ff9dc13f65ecadb
+  metadata.gz: 75a492d69d8b5902468f0a21c20bf1b4cbfe19c86d438f879094d3684c31da6a14fa184aa839fe1607dad086bf3210fe43a572d488f99e1ecb85c56be04f9489
+  data.tar.gz: d65b0bbbce89c696c913cddb23241b40a8d3acad47aabe7b93e9283701d3e7c1a82fde6544924d7b3f209a855aa9d065218303701c809b7a15e4fba3837193f6

data/bin/autoproj

@@ -6,6 +6,6 @@ argv = Autoproj::CLI.basic_setup
 
 begin
     Autoproj::CLI::Main.start(argv)
-rescue Interrupt
+rescue Interrupt # rubocop:disable Lint/HandleExceptions
     # Already notified in the reporting infrastructure
 end

data/lib/autoproj/autobuild_extensions/dsl.rb

@@ -35,24 +35,30 @@ def self.package_name_from_options(spec)
     # @deprecated use Autoproj.workspace.in_package_set or add a proper Loader
     #   object to your class
     def self.in_package_set(package_set, path, &block)
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use Autoproj.workspace.in_package_set instead"
+        )
         Autoproj.workspace.in_package_set(package_set, path, &block)
     end
 
     # @deprecated use Autoproj.workspace.current_file or add a proper Loader
     #   object to your class
     def self.current_file
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use AUtoproj.workspace.current_file instead"
+        )
         Autoproj.workspace.current_file
     end
 
     # @deprecated use Autoproj.workspace.current_package_set or add a proper
     #   Loader object to your class
     def self.current_package_set
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use Autoproj.workspace.current_package_set instead"
+        )
         Autoproj.workspace.current_package_set
     end
 
@@ -60,22 +66,27 @@ def self.current_package_set
     #   Beware that the return value changed from Autobuild::Package to
     #   Autoproj::PackageDefinition
     def self.define(package_type, spec, &block)
-        Autoproj.warn_deprecated __method__, "use Autoproj.workspace.define_package "\
+        Autoproj.warn_deprecated(
+            __method__, "use Autoproj.workspace.define_package "\
             "instead (and beware that the return value changed from "\
             "Autobuild::Package to Autoproj::PackageDefinition)"
+        )
         workspace.define_package(package_type, spec, block, *current_file).
             autobuild
     end
 
     def self.loaded_autobuild_files
-        Autoproj.warn_deprecated __method__,
-            "use Autoproj.workspace.loaded_autobuild_files"
+        Autoproj.warn_deprecated(
+            __method__, "use Autoproj.workspace.loaded_autobuild_files"
+        )
         Autoproj.workspace.loaded_autobuild_files
     end
 
     def self.import_autobuild_file(package_set, path)
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use Autoproj.workspace.import_autobuild_file"
+        )
         Autoproj.workspace.import_autobuild_file(package_set, path)
     end
 
@@ -490,11 +501,13 @@ def renamed_package(current_name, old_name, options)
         explicitely_selected_in_layout?(old_name)
     if options[:obsolete] && !explicit_selection
         import_package old_name
-        Autoproj.workspace.manifest.exclude_package old_name,
+        Autoproj.workspace.manifest.exclude_package(
+            old_name,
             "#{old_name} has been renamed to #{current_name}, you still have "\
             "the option of using the old name by adding '- #{old_name}' explicitely "\
             "in the layout in autoproj/manifest, but be warned that the name will "\
             "stop being usable at all in the near future"
+        )
     else
         metapackage old_name, current_name
     end

data/lib/autoproj/cli/base.rb

@@ -151,7 +151,7 @@ def resolve_selection(user_selection, checkout_only: true, only_local: false, re
                     non_imported_packages: non_imported_packages,
                     auto_exclude: auto_exclude)
 
-                return source_packages, osdep_packages, resolved_selection
+                [source_packages, osdep_packages, resolved_selection]
             rescue ExcludedSelection => e
                 raise CLIInvalidSelection, e.message, e.backtrace
             end

data/lib/autoproj/cli/build.rb

@@ -18,12 +18,14 @@ def validate_options(selected_packages, options)
             end
 
             def run(selected_packages, **options)
-                build_options, options = filter_options options,
+                build_options, options = filter_options(
+                    options,
                     force: false,
                     rebuild: false,
                     parallel: nil,
                     confirm: true,
                     not: Array.new
+                )
 
                 command_line_selection, source_packages, _osdep_packages =
                     super(selected_packages,
@@ -41,6 +43,7 @@ def run(selected_packages, **options)
                 # Disable all packages that are not selected
                 ws.manifest.each_autobuild_package do |pkg|
                     next if active_packages.include?(pkg.name)
+
                     pkg.disable
                 end
 
@@ -61,11 +64,13 @@ def run(selected_packages, **options)
                                     else 'force-build'
                                     end
                         if build_options[:confirm] != false
-                            opt = BuildOption.new("", "boolean",
+                            opt = BuildOption.new(
+                                "", "boolean",
                                 {
                                     doc: "this is going to trigger a #{mode_name} "\
                                         "of all packages. Is that really what you want ?"
-                                }, nil)
+                                }, nil
+                            )
                             raise Interrupt unless opt.ask(false)
                         end
 

data/lib/autoproj/cli/cache.rb

@@ -1,9 +1,54 @@
+# frozen_string_literal: true
+
 require 'autoproj/cli/inspection_tool'
 require 'autoproj/ops/cache'
 
 module Autoproj
     module CLI
         class Cache < InspectionTool
+            def parse_gem_compile(string)
+                scanner = StringScanner.new(string)
+                name = scanner.scan(/[^\[]+/)
+
+                level = 0
+                artifacts = []
+                artifact_include = nil
+                artifact_name = ''.dup
+                until scanner.eos?
+                    c = scanner.getch
+                    if level == 0
+                        raise ArgumentError, "expected '[' but got '#{c}'" unless c == '['
+
+                        level = 1
+                        include_c = scanner.getch
+                        if %w[+ -].include?(include_c)
+                            artifact_include = (include_c == '+')
+                        elsif include_c == ']'
+                            raise ArgumentError, "empty [] found in '#{string}'"
+                        else
+                            raise ArgumentError,
+                                  "expected '+' or '-' but got '#{c}' in '#{string}'"
+                        end
+                        next
+                    end
+
+                    if c == ']'
+                        level -= 1
+                        if level == 0
+                            artifacts << [artifact_include, artifact_name]
+                            artifact_name = ''.dup
+                            next
+                        end
+                    end
+
+                    artifact_name << c
+                end
+
+                raise ArgumentError, "missing closing ']' in #{string}" if level != 0
+
+                [name, artifacts: artifacts]
+            end
+
             def validate_options(argv, options = Hash.new)
                 argv, options = super
 
@@ -22,8 +67,7 @@ def validate_options(argv, options = Hash.new)
 
                 if (compile = options[:gems_compile])
                     options[:gems_compile] = compile.map do |name|
-                        name, *artifacts = name.split('+')
-                        [name, artifacts: artifacts]
+                        parse_gem_compile(name)
                     end
                 end
 
@@ -58,4 +102,3 @@ def run(cache_dir, *package_names,
         end
     end
 end
-

data/lib/autoproj/cli/inspection_tool.rb

@@ -8,9 +8,7 @@ class InspectionTool < Base
             def initialize_and_load(mainline: nil)
                 Autoproj.silent do
                     ws.setup
-                    if mainline == 'mainline' || mainline == 'true'
-                        mainline = true
-                    end
+                    mainline = true if %w[mainline true].include?(mainline)
                     ws.load_package_sets(mainline: mainline)
                     ws.config.save
                     ws.setup_all_package_directories
@@ -22,7 +20,7 @@ def initialize_and_load(mainline: nil)
             # @param [Array<String>] packages the list of package names
             # @param [Symbol] non_imported_packages whether packages that are
             #   not yet imported should be ignored (:ignore) or returned
-            #   (:return). 
+            #   (:return).
             # @option options recursive (true) whether the package resolution
             #   should return the package(s) and their dependencies
             #
@@ -32,7 +30,8 @@ def initialize_and_load(mainline: nil)
             #   the arguments were pointing within the configuration area
             def finalize_setup(packages = [], non_imported_packages: :ignore, recursive: true, auto_exclude: false)
                 Autoproj.silent do
-                    packages, config_selected = normalize_command_line_package_selection(packages)
+                    packages, config_selected =
+                        normalize_command_line_package_selection(packages)
                     # Call resolve_user_selection once to auto-add packages, so
                     # that they're available to e.g. overrides.rb
                     resolve_user_selection(packages)
@@ -41,7 +40,7 @@ def finalize_setup(packages = [], non_imported_packages: :ignore, recursive: tru
                         resolve_selection(packages, recursive: recursive, non_imported_packages: non_imported_packages, auto_exclude: auto_exclude)
                     ws.finalize_setup
                     ws.export_installation_manifest
-                    return source_packages, osdep_packages, resolved_selection, config_selected
+                    [source_packages, osdep_packages, resolved_selection, config_selected]
                 end
             end
         end

data/lib/autoproj/cli/show.rb

@@ -17,7 +17,8 @@ def run(user_selection, short: false, recursive: false, mainline: false, env: fa
                     source_packages, osdep_packages, * =
                         finalize_setup(user_selection, recursive: recursive, non_imported_packages: :return)
                 else
-                    source_packages, osdep_packages = Array.new, Array.new
+                    source_packages = []
+                    osdep_packages = []
                 end
 
                 all_matching_osdeps = osdep_packages.map { |pkg| [pkg, true] }
@@ -232,7 +233,7 @@ def display_common_information(pkg_name, default_packages, revdeps)
                     end
                 end
 
-                if !selections.empty?
+                unless selections.empty?
                     puts "  selected by way of"
                     selections.each do |root_pkg|
                         paths = find_selection_path(root_pkg, pkg_name)
@@ -248,9 +249,7 @@ def display_common_information(pkg_name, default_packages, revdeps)
             end
 
             def find_selection_path(from, to)
-                if from == to
-                    return [[from]]
-                end
+                return [[from]] if from == to
 
                 all_paths = Array.new
                 ws.manifest.resolve_package_name(from).each do |pkg_type, pkg_name|
@@ -262,19 +261,17 @@ def find_selection_path(from, to)
 
                     pkg = ws.manifest.find_autobuild_package(pkg_name)
                     pkg.dependencies.each do |dep_pkg_name|
-                        if result = find_selection_path(dep_pkg_name, to)
+                        if (result = find_selection_path(dep_pkg_name, to))
                             all_paths.concat(result.map { |p| path + p })
                         end
                     end
-                    if pkg.os_packages.include?(to)
-                        all_paths << (path + [to])
-                    end
+                    all_paths << (path + [to]) if pkg.os_packages.include?(to)
                 end
 
                 # Now filter common trailing subpaths
                 all_paths = all_paths.sort_by(&:size)
                 filtered_paths = Array.new
-                while !all_paths.empty?
+                until all_paths.empty?
                     path = all_paths.shift
                     filtered_paths << path
                     size = path.size
@@ -290,19 +287,15 @@ def vcs_to_array(vcs)
                     options = vcs.dup
                     type = options.delete('type')
                     url  = options.delete('url')
-                else 
+                else
                     options = vcs.options
                     type = vcs.type
                     url = vcs.url
                 end
 
                 fields = []
-                if type
-                    fields << ['type', type]
-                end
-                if url
-                    fields << ['url', url]
-                end
+                fields << ['type', type] if type
+                fields << ['url', url] if url
                 fields = fields.concat(options.to_a.sort_by { |k, _| k.to_s })
                 fields.map do |key, value|
                     if value.respond_to?(:to_str) && File.file?(value) && value =~ /^\//
@@ -315,9 +308,10 @@ def vcs_to_array(vcs)
             def compute_all_revdeps(pkg_revdeps, revdeps)
                 pkg_revdeps = pkg_revdeps.dup
                 all_revdeps = Array.new
-                while !pkg_revdeps.empty?
+                until pkg_revdeps.empty?
                     parent_name = pkg_revdeps.shift
                     next if all_revdeps.include?(parent_name)
+
                     all_revdeps << parent_name
                     pkg_revdeps.concat(revdeps[parent_name].to_a)
                 end

data/lib/autoproj/cli/update.rb

@@ -199,9 +199,7 @@ def update_packages(selected_packages,
                 retry_count: 0, osdeps: true, auto_exclude: false, osdeps_options: Hash.new,
                 report: true)
 
-                if from
-                    setup_update_from(from)
-                end
+                setup_update_from(from) if from
 
                 ops = Autoproj::Ops::Import.new(
                     ws, report_path: (ws.import_report_path if report))
@@ -216,14 +214,15 @@ def update_packages(selected_packages,
                                         retry_count: retry_count,
                                         install_vcs_packages: (osdeps_options if osdeps),
                                         auto_exclude: auto_exclude)
-                return source_packages, osdep_packages, nil
+                [source_packages, osdep_packages, nil]
             rescue ExcludedSelection => e
                 raise CLIInvalidSelection, e.message, e.backtrace
             rescue PackageImportFailed => import_failure
-                if !keep_going
-                    raise
-                end
-                return import_failure.source_packages, import_failure.osdep_packages, import_failure
+                raise unless keep_going
+
+                [import_failure.source_packages,
+                 import_failure.osdep_packages,
+                 import_failure]
             end
 
             def setup_update_from(other_root)

data/lib/autoproj/manifest.rb

@@ -50,12 +50,14 @@ def self.load(file)
 
         # Load the manifest data contained in +file+
         def load(file)
-            if !File.exist?(file)
-                raise ConfigError.new(File.dirname(file)), "expected an autoproj configuration in #{File.dirname(file)}, but #{file} does not exist"
+            unless File.exist?(file)
+                raise ConfigError.new(File.dirname(file)),
+                      "expected an autoproj configuration in #{File.dirname(file)}, "\
+                      "but #{file} does not exist"
             end
 
             data = Autoproj.in_file(file, Autoproj::YAML_LOAD_ERROR) do
-                YAML.load(File.read(file)) || Hash.new
+                YAML.safe_load(File.read(file)) || {}
             end
 
             @file = file
@@ -81,7 +83,8 @@ def initialize_from_hash(data)
             @has_layout = !!data['layout']
 
             if data['constants']
-                @constant_definitions = Autoproj.resolve_constant_definitions(data['constants'])
+                @constant_definitions =
+                    Autoproj.resolve_constant_definitions(data['constants'])
             end
         end
 

data/lib/autoproj/ops/cache.rb

@@ -107,13 +107,20 @@ def create_or_update(*package_names, all: true, keep_going: false,
                     begin
                         case pkg.importer
                         when Autobuild::Git
-                            Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (git)"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] caching #{pkg.name} (git)"
+                            )
                             cache_git(pkg, checkout_only: checkout_only)
                         when Autobuild::ArchiveImporter
-                            Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (archive)"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] caching #{pkg.name} (archive)"
+                            )
                             cache_archive(pkg)
                         else
-                            Autoproj.message "  [#{i}/#{total}] not caching #{pkg.name} (cannot cache #{pkg.importer.class})"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] not caching #{pkg.name} "\
+                                "(cannot cache #{pkg.importer.class})"
+                            )
                         end
                     rescue Interrupt
                         raise
@@ -170,7 +177,9 @@ def create_or_update_gems(keep_going: true, compile_force: false, compile: [])
                         next if !compile_force && File.file?(expected_platform_gem)
 
                         begin
-                            compile_gem(gem, artifacts: artifacts, output: real_target_dir)
+                            compile_gem(
+                                gem, artifacts: artifacts, output: real_target_dir
+                            )
                         rescue CompilationFailed
                             unless keep_going
                                 raise CompilationFailed, "#{gem} failed to compile"
@@ -200,17 +209,13 @@ def synchronize_gems_cache_dirs(source, target)
             end
 
             def guess_gem_program
-                if Autobuild.programs['gem']
-                    return Autobuild.programs['gem']
-                end
+                return Autobuild.programs['gem'] if Autobuild.programs['gem']
 
                 ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
                 ruby_bindir = RbConfig::CONFIG['bindir']
 
                 candidates = ['gem']
-                if ruby_bin =~ /^ruby(.+)$/
-                    candidates << "gem#{$1}"
-                end
+                candidates << "gem#{$1}" if ruby_bin =~ /^ruby(.+)$/
 
                 candidates.each do |gem_name|
                     if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
@@ -219,11 +224,19 @@ def guess_gem_program
                     end
                 end
 
-                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
+                raise ArgumentError,
+                      'cannot find a gem program (tried '\
+                      "#{candidates.sort.join(', ')} in #{ruby_bindir})"
             end
 
             private def compile_gem(gem_path, output:, artifacts: [])
-                artifacts = artifacts.flat_map { |n| ["--artifact", n] }
+                artifacts = artifacts.flat_map do |include, n|
+                    if include
+                        ["--include", n]
+                    else
+                        ["--exclude", n]
+                    end
+                end
                 unless system(Autobuild.tool('ruby'), '-S', guess_gem_program,
                               'compile', '--output', output, *artifacts, gem_path)
                     raise CompilationFailed, "#{gem_path} failed to compile"

data/lib/autoproj/ops/cached_env.rb

@@ -9,7 +9,7 @@ def self.cached_env_path(root_dir)
         def self.load_cached_env(root_dir)
             path = cached_env_path(root_dir)
             if File.file?(path)
-                env = YAML.load(File.read(path))
+                env = YAML.safe_load(File.read(path))
                 Autobuild::Environment::ExportedEnvironment.new(
                     env['set'], env['unset'], env['update'])
             end
@@ -20,7 +20,7 @@ def self.save_cached_env(root_dir, env)
             path = cached_env_path(root_dir)
             existing =
                 begin
-                    YAML.load(File.read(path))
+                    YAML.safe_load(File.read(path))
                 rescue Exception
                 end
 

data/lib/autoproj/ops/import.rb

@@ -288,8 +288,12 @@ def import_selected_packages(selection,
                     if completion_queue.empty? && pending_packages.empty?
                         unless missing_vcs.empty?
                             installed_vcs_packages.merge(
-                                install_vcs_packages_for(*missing_vcs,
-                                                         **install_vcs_packages))
+                                install_vcs_packages_for(
+                                    *missing_vcs,
+                                     install_only: import_options[:checkout_only],
+                                     **install_vcs_packages
+                                )
+                            )
                             package_queue.concat(missing_vcs)
                             missing_vcs.clear
                             next
@@ -366,7 +370,9 @@ def import_selected_packages(selection,
                 end
             end
 
-            def finalize_package_load(processed_packages, auto_exclude: auto_exclude?)
+            def finalize_package_load(processed_packages,
+                                      ignore_optional_dependencies: false,
+                                      auto_exclude: auto_exclude?)
                 manifest = ws.manifest
 
                 all = Set.new

data/lib/autoproj/package_managers/apt_dpkg_manager.rb

@@ -14,15 +14,17 @@ def initialize(ws, status_file = "/var/lib/dpkg/status")
                 @installed_packages = nil
                 @installed_versions = nil
                 super(ws, true,
-                      %w{apt-get install},
-                      %w{DEBIAN_FRONTEND=noninteractive apt-get install -y})
+                      %w[apt-get install],
+                      %w[DEBIAN_FRONTEND=noninteractive apt-get install -y])
             end
 
             def configure_manager
                 super
-                ws.config.declare 'apt_dpkg_update', 'boolean',
+                ws.config.declare(
+                    'apt_dpkg_update', 'boolean',
                     default: 'yes',
                     doc: ['Would you like autoproj to keep apt packages up-to-date?']
+                )
                 keep_uptodate?
             end
 
@@ -58,11 +60,12 @@ def self.parse_dpkg_status(status_file, virtual: true)
                 dpkg_status << "\n"
 
                 dpkg_status = StringScanner.new(dpkg_status)
-                if !dpkg_status.scan(/Package: /)
-                    raise ArgumentError, "expected #{status_file} to have Package: lines but found none"
+                unless dpkg_status.scan(/Package: /)
+                    raise ArgumentError, "expected #{status_file} to have Package: "\
+                                         "lines but found none"
                 end
 
-                while paragraph_end = dpkg_status.scan_until(/Package: /)
+                while (paragraph_end = dpkg_status.scan_until(/Package: /))
                     paragraph = "Package: #{paragraph_end[0..-10]}"
                     parse_package_status(installed_packages, installed_versions,
                                          paragraph, virtual: virtual)
@@ -74,11 +77,10 @@ def self.parse_dpkg_status(status_file, virtual: true)
 
             def self.parse_apt_cache_paragraph(paragraph)
                 version = '0'
-                if paragraph =~ /^Package: (.*)$/
-                    package_name = $1
-                    if paragraph =~ /^Version: (.*)$/
-                        version = $1
-                    end
+                if (paragraph_m = /^Package: (.*)$/.match(paragraph))
+                    package_name = paragraph_m[1]
+                    version_m = /^Version: (.*)$/.match(paragraph)
+                    version = version_m[1] if version_m
                 end
                 [package_name, version]
             end
@@ -87,23 +89,24 @@ def self.parse_packages_versions(packages)
                 packages_versions = {}
                 apt_cache_show = `apt-cache show --no-all-versions #{packages.join(' ')}`
                 apt_cache_show = StringScanner.new(apt_cache_show)
-                if !apt_cache_show.scan(/Package: /)
-                    return packages_versions
-                end
+                return packages_versions unless apt_cache_show.scan(/Package: /)
 
-                while paragraph_end = apt_cache_show.scan_until(/Package: /)
+                while (paragraph_end = apt_cache_show.scan_until(/Package: /))
                     paragraph = "Package: #{paragraph_end[0..-10]}"
                     package_name, version = parse_apt_cache_paragraph(paragraph)
                     packages_versions[package_name] = DebianVersion.new(version)
                 end
-                package_name, version = parse_apt_cache_paragraph("Package: #{apt_cache_show.rest}")
+                package_name, version = parse_apt_cache_paragraph(
+                    "Package: #{apt_cache_show.rest}"
+                )
                 packages_versions[package_name] = DebianVersion.new(version)
                 packages_versions
             end
 
             def updated?(package, available_version)
-                # Consider up-to-date if the package is provided by another package (purely virtual)
-                # Ideally, we should check the version of the package that provides it
+                # Consider up-to-date if the package is provided by another
+                # package (purely virtual) Ideally, we should check the version
+                # of the package that provides it
                 return true unless available_version && @installed_versions[package]
 
                 (available_version <= @installed_versions[package])
@@ -111,8 +114,13 @@ def updated?(package, available_version)
 
             # On a dpkg-enabled system, checks if the provided package is installed
             # and returns true if it is the case
-            def installed?(package_name, filter_uptodate_packages: false, install_only: false)
-                @installed_packages, @installed_versions = self.class.parse_dpkg_status(status_file) unless @installed_packages && @installed_versions
+            def installed?(package_name, filter_uptodate_packages: false,
+                                         install_only: false)
+                unless @installed_packages && @installed_versions
+                    @installed_packages, @installed_versions =
+                        self.class.parse_dpkg_status(status_file)
+                end
+
                 if package_name =~ /^(\w[a-z0-9+-.]+)/
                     @installed_packages.include?($1)
                 else
@@ -122,11 +130,18 @@ def installed?(package_name, filter_uptodate_packages: false, install_only: fals
             end
 
             def install(packages, filter_uptodate_packages: false, install_only: false)
-                packages_versions = self.class.parse_packages_versions(packages)
                 if filter_uptodate_packages || install_only
-                    packages = packages.find_all do |package_name|
-                        !installed?(package_name) || (keep_uptodate? && !updated?(package_name, packages_versions[package_name]))
+                    already_installed, missing = packages.partition do |package_name|
+                        installed?(package_name)
+                    end
+
+                    if keep_uptodate? && !install_only
+                        packages_versions = self.class.parse_packages_versions(already_installed)
+                        need_update = already_installed.find_all do |package_name|
+                            !updated?(package_name, packages_versions[package_name])
+                        end
                     end
+                    packages = missing + (need_update || [])
                 end
 
                 if super(packages)

data/lib/autoproj/package_managers/bundler_manager.rb

@@ -89,6 +89,7 @@ def initialize_environment
                             Bundler.rubygems.gem_path
                                    .none? { |gem_p| p.start_with?(gem_p) }
                     end
+
                 # And discover the system's rubylib
                 if (system_rubylib = discover_rubylib)
                     # Do not explicitely add the system rubylib to the

data/lib/autoproj/package_managers/shell_script_manager.rb

@@ -7,8 +7,10 @@ def self.execute(command_line, with_locking, with_root, env: Autobuild.env)
                 if with_locking
                     File.open('/tmp/autoproj_osdeps_lock', 'w') do |lock_io|
                         begin
-                            while !lock_io.flock(File::LOCK_EX | File::LOCK_NB)
-                                Autoproj.message "  waiting for other autoproj instances to finish their osdeps installation"
+                            until lock_io.flock(File::LOCK_EX | File::LOCK_NB)
+                                Autoproj.message "  waiting for other autoproj "\
+                                                 "instances to finish their osdeps "\
+                                                 "installation"
                                 sleep 5
                             end
                             return execute(command_line, false, with_root, env: env)
@@ -17,7 +19,7 @@ def self.execute(command_line, with_locking, with_root, env: Autobuild.env)
                         end
                     end
                 end
-                
+
                 if with_root
                     sudo = Autobuild.tool_in_path('sudo', env: env)
                     command_line = [sudo, *command_line]
@@ -34,10 +36,12 @@ def self.execute(command_line, with_locking, with_root, env: Autobuild.env)
             # This declares if this package manager cannot be used concurrently.
             # If it is the case, autoproj will ensure that there is no two
             # autoproj instances running this package manager at the same time
-            # 
+            #
             # @return [Boolean]
             # @see needs_locking=
-            def needs_locking?; !!@needs_locking end
+            def needs_locking?
+                @needs_locking
+            end
 
             # Overrides the {#needs_root?} flag
             attr_writer :needs_root
@@ -45,10 +49,12 @@ def needs_locking?; !!@needs_locking end
             #
             # This declares if the command line(s) for this package manager
             # should be started as root. Root access is provided using sudo
-            # 
+            #
             # @return [Boolean]
             # @see needs_root=
-            def needs_root?; !!@needs_root end
+            def needs_root?
+                @needs_root
+            end
 
             # Command line used by autoproj to install packages
             #
@@ -83,10 +89,13 @@ def needs_root?; !!@needs_root end
             #   itself, see {#auto_install_cmd}.
             # @param [Boolean] needs_root if the command lines should be started
             #   as root or not. See {#needs_root?}
-            def initialize(ws, needs_locking, user_install_cmd, auto_install_cmd,needs_root=true)
+            def initialize(ws, needs_locking, user_install_cmd,
+                           auto_install_cmd, needs_root = true)
                 super(ws)
-                @needs_locking, @user_install_cmd, @auto_install_cmd,@needs_root =
-                    needs_locking, user_install_cmd, auto_install_cmd, needs_root
+                @needs_locking = needs_locking
+                @user_install_cmd = user_install_cmd
+                @auto_install_cmd = auto_install_cmd
+                @needs_root = needs_root
             end
 
             # Generate the shell script that would allow the user to install
@@ -98,7 +107,8 @@ def initialize(ws, needs_locking, user_install_cmd, auto_install_cmd,needs_root=
             #   command-line pattern that should be used to generate the script.
             #   If given, it overrides the default value stored in
             #   {#user_install_cmd]
-            def generate_user_os_script(os_packages, user_install_cmd: self.user_install_cmd)
+            def generate_user_os_script(os_packages,
+                                        user_install_cmd: self.user_install_cmd)
                 if user_install_cmd
                     user_install_cmd.join(" ") + " " + os_packages.join("' '")
                 else generate_auto_os_script(os_packages)
@@ -114,7 +124,8 @@ def generate_user_os_script(os_packages, user_install_cmd: self.user_install_cmd
             #   command-line pattern that should be used to generate the script.
             #   If given, it overrides the default value stored in
             #   {#auto_install_cmd]
-            def generate_auto_os_script(os_packages, auto_install_cmd: self.auto_install_cmd)
+            def generate_auto_os_script(os_packages,
+                                        auto_install_cmd: self.auto_install_cmd)
                 auto_install_cmd.join(" ") + " " + os_packages.join("' '")
             end
 
@@ -139,9 +150,9 @@ def osdeps_interaction(os_packages, shell_script)
                 # anyway, do so now
                 puts <<-EOMSG
 
-                #{Autoproj.color("The build process and/or the packages require some other software to be installed", :bold)}
-                #{Autoproj.color("and you required autoproj to not install them itself", :bold)}
-                #{Autoproj.color("\nIf these packages are already installed, simply ignore this message\n", :red) if !respond_to?(:filter_uptodate_packages)}
+                #{Autoproj.color('The build process and/or the packages require some other software to be installed', :bold)}
+                #{Autoproj.color('and you required autoproj to not install them itself', :bold)}
+                #{Autoproj.color('\nIf these packages are already installed, simply ignore this message\n', :red) unless respond_to?(:filter_uptodate_packages)}
     The following packages are available as OS dependencies, i.e. as prebuilt
     packages provided by your distribution / operating system. You will have to
     install them manually if they are not already installed
@@ -152,8 +163,8 @@ def osdeps_interaction(os_packages, shell_script)
 
                 #{shell_script.split("\n").join("\n|   ")}
 
-            EOMSG
-                print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+                EOMSG
+                print "    #{Autoproj.color('Press ENTER to continue ', :bold)}"
                 STDOUT.flush
                 STDIN.readline
                 puts
@@ -172,23 +183,33 @@ def osdeps_interaction(os_packages, shell_script)
             #   packages. See the option in {#generate_auto_os_script}
             # @return [Boolean] true if packages got installed, false otherwise
             def install(packages, filter_uptodate_packages: false, install_only: false,
-                        auto_install_cmd: self.auto_install_cmd, user_install_cmd: self.user_install_cmd)
+                        auto_install_cmd: self.auto_install_cmd,
+                        user_install_cmd: self.user_install_cmd)
                 return if packages.empty?
 
                 handled_os = ws.supported_operating_system?
                 if handled_os
-                    shell_script = generate_auto_os_script(packages, auto_install_cmd: auto_install_cmd)
-                    user_shell_script = generate_user_os_script(packages, user_install_cmd: user_install_cmd)
+                    shell_script = generate_auto_os_script(
+                        packages, auto_install_cmd: auto_install_cmd
+                    )
+                    user_shell_script = generate_user_os_script(
+                        packages, user_install_cmd: user_install_cmd
+                    )
                 end
                 if osdeps_interaction(packages, user_shell_script)
-                    Autoproj.message "  installing OS packages: #{packages.sort.join(", ")}"
+                    Autoproj.message "  installing OS packages: "\
+                                     "#{packages.sort.join(', ')}"
 
                     if Autoproj.verbose
-                        Autoproj.message "Generating installation script for non-ruby OS dependencies"
+                        Autoproj.message "Generating installation script for "\
+                                         "non-ruby OS dependencies"
                         Autoproj.message shell_script
                     end
 
-                    ShellScriptManager.execute([*auto_install_cmd, *packages], needs_locking?, needs_root?, env: ws.env)
+                    ShellScriptManager.execute(
+                        [*auto_install_cmd, *packages], needs_locking?,
+                        needs_root?, env: ws.env
+                    )
                     return true
                 end
                 false
@@ -196,4 +217,3 @@ def install(packages, filter_uptodate_packages: false, install_only: false,
         end
     end
 end
-

data/lib/autoproj/package_manifest.rb

@@ -30,13 +30,15 @@ def self.load(package, file, ros_manifest: false)
         # @param [Boolean] ros_manifest whether the file follows the ROS format
         # @return [PackageManifest]
         # @see load
-        def self.parse(package, contents, path: '<loaded from string>', loader_class: Loader)
+        def self.parse(package, contents,
+                       path: '<loaded from string>', loader_class: Loader)
             manifest = PackageManifest.new(package, path)
             loader = loader_class.new(path, manifest)
             begin
                 REXML::Document.parse_stream(contents, loader)
             rescue REXML::ParseException => e
-                raise Autobuild::PackageException.new(package.name, 'prepare'), "invalid #{file}: #{e.message}"
+                raise Autobuild::PackageException.new(package.name, 'prepare'),
+                      "invalid #{file}: #{e.message}"
             end
             manifest
         end
@@ -45,7 +47,7 @@ def self.parse(package, contents, path: '<loaded from string>', loader_class: Lo
         Dependency  = Struct.new :name, :optional, :modes
 
         # The Autobuild::Package instance this manifest applies on
-        attr_reader :package
+        attr_accessor :package
         attr_reader :path
         attr_accessor :description
         attr_accessor :brief_description
@@ -64,7 +66,7 @@ def add_dependency(name, optional: false, modes: [])
         end
 
         def has_documentation?
-            !!description
+            description
         end
 
         def documentation
@@ -72,7 +74,7 @@ def documentation
         end
 
         def has_short_documentation?
-            !!brief_description
+            brief_description
         end
 
         def short_documentation
@@ -95,11 +97,12 @@ def initialize(package, path = nil, null: false)
         # Whether this is a null manifest (used for packages that have actually
         # no manifest) or not
         def null?
-            !!@null
+            @null
         end
 
-        def each_dependency(in_modes = Array.new, &block)
-            return enum_for(__method__, in_modes) if !block_given?
+        def each_dependency(in_modes = [])
+            return enum_for(__method__, in_modes) unless block_given?
+
             dependencies.each do |dep|
                 if dep.modes.empty? || in_modes.any? { |m| dep.modes.include?(m) }
                     yield(dep.name, dep.optional)
@@ -108,24 +111,28 @@ def each_dependency(in_modes = Array.new, &block)
         end
 
         def each_os_dependency(modes = Array.new, &block)
-            Autoproj.warn_deprecated "#{self.class}##{__method__}", "call #each_dependency instead"
-            return each_dependency(modes, &block)
+            Autoproj.warn_deprecated "#{self.class}##{__method__}",
+                                     "call #each_dependency instead"
+            each_dependency(modes, &block)
         end
 
         def each_package_dependency(modes = Array.new, &block)
-            Autoproj.warn_deprecated "#{self.class}##{__method__}", "call #each_dependency instead"
-            return each_dependency(modes, &block)
+            Autoproj.warn_deprecated "#{self.class}##{__method__}",
+                                     "call #each_dependency instead"
+            each_dependency(modes, &block)
         end
 
         def each_rock_maintainer
-            return enum_for(__method__) if !block_given?
+            return enum_for(__method__) unless block_given?
+
             rock_maintainers.each do |m|
                 yield(m.name, m.email)
             end
         end
 
         def each_maintainer
-            return enum_for(__method__) if !block_given?
+            return enum_for(__method__) unless block_given?
+
             maintainers.each do |m|
                 yield(m.name, m.email)
             end
@@ -134,7 +141,8 @@ def each_maintainer
         # Enumerates the name and email of each author. If no email is present,
         # yields (name, nil)
         def each_author
-            return enum_for(__method__) if !block_given?
+            return enum_for(__method__) unless block_given?
+
             authors.each do |m|
                 yield(m.name, m.email)
             end
@@ -178,11 +186,13 @@ def initialize(path, manifest)
 
             def parse_depend_tag(tag_name, attributes, modes: [], optional: false)
                 package = attributes['package'] || attributes['name']
-                if !package
-                    raise InvalidPackageManifest, "found '#{tag_name}' tag in #{path} without a 'package' attribute"
+                unless package
+                    raise InvalidPackageManifest,
+                          "found '#{tag_name}' tag in #{path} "\
+                          "without a 'package' attribute"
                 end
 
-                if tag_modes = attributes['modes']
+                if (tag_modes = attributes['modes'])
                     modes += tag_modes.split(',')
                 end
 
@@ -195,7 +205,7 @@ def parse_depend_tag(tag_name, attributes, modes: [], optional: false)
             def parse_contact_field(text)
                 text.strip.split(',').map do |str|
                     name, email = str.split('/').map(&:strip)
-                    email = nil if email && email.empty?
+                    email = nil if email&.empty?
                     ContactInfo.new(name, email)
                 end
             end
@@ -213,7 +223,7 @@ def toplevel_tag_start(name, attributes)
                 elsif name =~ /^(\w+)_depend$/
                     parse_depend_tag(name, attributes, modes: [$1])
                 elsif name == 'description'
-                    if brief = attributes['brief']
+                    if (brief = attributes['brief'])
                         manifest.brief_description = brief
                     end
                     @tag_text = ''
@@ -225,14 +235,13 @@ def toplevel_tag_start(name, attributes)
                     @tag_text = nil
                 end
             end
+
             def toplevel_tag_end(name)
                 if AUTHOR_FIELDS.include?(name)
                     manifest.send("#{name}s").concat(parse_contact_field(@tag_text))
                 elsif TEXT_FIELDS.include?(name)
                     field = @tag_text.strip
-                    if !field.empty?
-                        manifest.send("#{name}=", field)
-                    end
+                    manifest.send("#{name}=", field) unless field.empty?
                 elsif name == 'tags'
                     manifest.tags.concat(@tag_text.strip.split(',').map(&:strip))
                 end
@@ -245,10 +254,10 @@ def toplevel_tag_end(name)
         # REXML stream parser object used to load the XML contents into a
         # {PackageManifest} object
         class RosLoader < Loader
-            SUPPORTED_MODES = ['test', 'doc'].freeze
-            DEPEND_TAGS = Set['depend', 'build_depend', 'build_export_depend',
-                              'buildtool_depend', 'buildtool_export_depend',
-                              'exec_depend', 'test_depend', 'run_depend', 'doc_depend']
+            SUPPORTED_MODES = %w[test doc].freeze
+            DEPEND_TAGS = %w[depend build_depend build_export_depend
+                             buildtool_depend buildtool_export_depend
+                             exec_depend test_depend run_depend doc_depend].to_set.freeze
 
             def toplevel_tag_start(name, attributes)
                 if DEPEND_TAGS.include?(name)
@@ -265,18 +274,21 @@ def toplevel_tag_start(name, attributes)
 
             def toplevel_tag_end(name)
                 if DEPEND_TAGS.include?(name)
-                    raise InvalidPackageManifest, "found '#{name}' tag in #{path} without content" if @tag_text.strip.empty?
+                    if @tag_text.strip.empty?
+                        raise InvalidPackageManifest, "found '#{name}' tag in #{path} "\
+                                                      "without content"
+                    end
 
                     mode = []
-                    if name =~ /^(\w+)_depend$/
-                        mode = SUPPORTED_MODES & [$1]
+                    if (m = /^(\w+)_depend$/.match(name))
+                        mode = SUPPORTED_MODES & [m[1]]
                     end
 
                     manifest.add_dependency(@tag_text, modes: mode)
                 elsif AUTHOR_FIELDS.include?(name)
                     author_name = @tag_text.strip
                     email = @author_email ? @author_email.strip : nil
-                    email = nil if email && email.empty?
+                    email = nil if email&.empty?
                     contact = ContactInfo.new(author_name, email)
                     manifest.send("#{name}s").concat([contact])
                 elsif TEXT_FIELDS.include?(name)

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "2.12.0"
+    VERSION = "2.12.1"
 end

data/lib/autoproj/workspace.rb

@@ -243,7 +243,7 @@ def overrides_dir
             File.join(config_dir, OVERRIDES_DIR)
         end
 
-        IMPORT_REPORT_BASENAME = "import_report.json"
+        IMPORT_REPORT_BASENAME = "import_report.json".freeze
 
         # The full path to the update report
         #
@@ -252,7 +252,7 @@ def import_report_path
             File.join(log_dir, IMPORT_REPORT_BASENAME)
         end
 
-        BUILD_REPORT_BASENAME = "build_report.json"
+        BUILD_REPORT_BASENAME = "build_report.json".freeze
 
         # The full path to the build report
         #
@@ -306,14 +306,18 @@ def save_config
         def autodetect_operating_system(force: false)
             if force || !os_package_resolver.operating_system
                 begin
-                    Autobuild.progress_start :operating_system_autodetection,
+                    Autobuild.progress_start(
+                        :operating_system_autodetection,
                         "autodetecting the operating system"
+                    )
                     names, versions = OSPackageResolver.autodetect_operating_system
                     os_package_resolver.operating_system = [names, versions]
                     os_repository_resolver.operating_system = [names, versions]
-                    Autobuild.progress :operating_system_autodetection,
+                    Autobuild.progress(
+                        :operating_system_autodetection,
                         "operating system: #{(names - ['default']).join(',')} -"\
                         " #{(versions - ['default']).join(',')}"
+                    )
                 ensure
                     Autobuild.progress_done :operating_system_autodetection
                 end
@@ -416,7 +420,7 @@ def rewrite_shims
             gemfile  = File.join(dot_autoproj_dir, 'Gemfile')
             binstubs = File.join(dot_autoproj_dir, 'bin')
             Ops::Install.rewrite_shims(binstubs, config.ruby_executable,
-                root_dir, gemfile, config.gems_gem_home)
+                                       root_dir, gemfile, config.gems_gem_home)
         end
 
         def update_bundler
@@ -601,6 +605,10 @@ def register_workspace
             current_workspaces = Workspace.registered_workspaces
             existing = current_workspaces.find { |w| w.root_dir == root_dir }
             if existing
+                if existing.prefix_dir == prefix_dir && existing.build_dir == build_dir
+                    return
+                end
+
                 existing.prefix_dir = prefix_dir
                 existing.build_dir  = build_dir
             else
@@ -818,10 +826,12 @@ def all_os_packages(import_missing: false, parallel: config.parallel_import_leve
             if import_missing
                 ops = Autoproj::Ops::Import.new(self)
                 _, all_os_packages =
-                    ops.import_packages(manifest.default_packages,
-                                    checkout_only: true, only_local: true, reset: false,
-                                    recursive: true, keep_going: true, parallel: parallel,
-                                    retry_count: 0)
+                    ops.import_packages(
+                        manifest.default_packages,
+                        checkout_only: true, only_local: true, reset: false,
+                        recursive: true, keep_going: true, parallel: parallel,
+                        retry_count: 0
+                    )
                 all_os_packages
             else
                 manifest.all_selected_osdep_packages

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autoproj
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.12.1
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-27 00:00:00.000000000 Z
+date: 2020-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler