autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/metapackage.rb

@@ -4,7 +4,7 @@ class Metapackage
         # The metapackage name
         attr_reader :name
         # The packages listed in this metapackage
-        attr_reader :packages
+        attr_reader :packages_by_name
         # The normal dependency handling behaviour is to generate an error if a
         # metapackage is selected for the build but some of its dependencies
         # cannot be built. This modifies the behaviour to simply ignore the
@@ -20,22 +20,40 @@ def weak_dependencies?
 
         def initialize(name)
             @name = name
-            @packages = []
+            @packages_by_name = Hash.new
             @weak_dependencies = false
         end
 
+        def size
+            packages_by_name.size
+        end
+
+        # Deprecated, use #each_package instead
+        def packages
+            Autoproj.warn_deprecated "use #each_package instead"
+            each_package.to_a
+        end
+
         # Adds a package to this metapackage
         #
         # @param [Autobuild::Package] pkg
         def add(pkg)
-            @packages << pkg
+            packages_by_name[pkg.name] = pkg
+        end
+
+        # Remove a package from this metapackage
+        def remove(pkg)
+            if pkg.respond_to?(:name)
+                pkg = pkg.name
+            end
+            packages_by_name.delete(pkg)
         end
 
         # Lists the packages contained in this metapackage
         #
         # @yieldparam [Autobuild::Package] pkg
         def each_package(&block)
-            @packages.each(&block)
+            packages_by_name.each_value(&block)
         end
 
         # Tests if the given package is included in this metapackage
@@ -45,7 +63,15 @@ def include?(pkg)
             if !pkg.respond_to?(:to_str)
                 pkg = pkg.name
             end
-            @packages.any? { |p| p.name == pkg }
+            packages_by_name.has_key?(pkg)
+        end
+
+        def clear
+            packages_by_name.clear
+        end
+
+        def delete_if
+            packages_by_name.delete_if { |name, package| yield(package) }
         end
     end
 end

data/lib/autoproj/ops/configuration.rb

@@ -41,11 +41,9 @@ def manifest_path
         # @option options [InstallationManifest] :update_from
         #   another autoproj installation from which we
         #   should update (instead of the normal VCS)
-        def initialize(workspace, options = Hash.new)
-            options = validate_options options,
-                update_from: nil
+        def initialize(workspace, update_from: nil)
             @ws = workspace
-            @update_from = options[:update_from]
+            @update_from = update_from
             @remote_update_message_displayed = false
         end
 
@@ -129,8 +127,8 @@ def update_remote_package_set(vcs, options = Hash.new)
                 reset: false,
                 retry_count: nil
 
-            name = PackageSet.name_of(ws.manifest, vcs)
-            raw_local_dir = PackageSet.raw_local_dir_of(vcs)
+            name = PackageSet.name_of(ws, vcs)
+            raw_local_dir = PackageSet.raw_local_dir_of(ws, vcs)
 
             return if options[:checkout_only] && File.exist?(raw_local_dir)
 
@@ -140,7 +138,7 @@ def update_remote_package_set(vcs, options = Hash.new)
                 Autoproj.message("autoproj: updating remote definitions of package sets", :bold)
                 @remote_update_message_displayed = true
             end
-            ws.install_os_packages([vcs.type])
+            ws.install_os_packages([vcs.type], all: nil)
             update_configuration_repository(
                 vcs, name, raw_local_dir, options)
         end
@@ -150,8 +148,8 @@ def update_remote_package_set(vcs, options = Hash.new)
         # @param [VCSDefinition] vcs the package set VCS
         # @return [String] the full path to the created user dir
         def create_remote_set_user_dir(vcs)
-            name = PackageSet.name_of(ws.manifest, vcs)
-            raw_local_dir = PackageSet.raw_local_dir_of(vcs)
+            name = PackageSet.name_of(ws, vcs)
+            raw_local_dir = PackageSet.raw_local_dir_of(ws, vcs)
             FileUtils.mkdir_p(remotes_user_dir)
             symlink_dest = File.join(remotes_user_dir, name)
 
@@ -172,7 +170,7 @@ def create_remote_set_user_dir(vcs)
         end
 
         def load_package_set(vcs, options, imported_from)
-            pkg_set = PackageSet.new(ws.manifest, vcs)
+            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
@@ -186,22 +184,14 @@ def load_package_set(vcs, options, imported_from)
         def queue_auto_imports_if_needed(queue, pkg_set, root_set)
             if pkg_set.auto_imports?
                 pkg_set.each_raw_imported_set do |import_vcs, import_options|
-                    repository_id = repository_id_of(import_vcs)
-                    import_vcs = root_set.overrides_for("pkg_set:#{repository_id}", import_vcs)
+                    vcs_overrides_key = import_vcs.overrides_key
+                    import_vcs = root_set.resolve_overrides("pkg_set:#{vcs_overrides_key}", import_vcs)
                     queue << [import_vcs, import_options, pkg_set]
                 end
             end
             queue
         end
 
-        def repository_id_of(vcs)
-            if vcs.local?
-                return "local:#{vcs.url}"
-            end
-
-            vcs.create_autobuild_importer.repository_id
-        end
-
         # Load the package set information
         #
         # It loads the package set information as required by {manifest} and
@@ -230,7 +220,7 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
             queue = queue_auto_imports_if_needed(Array.new, root_pkg_set, root_pkg_set)
             while !queue.empty?
                 vcs, import_options, imported_from = queue.shift
-                repository_id = repository_id_of(vcs)
+                repository_id = vcs.overrides_key
                 if already_processed = by_repository_id[repository_id]
                     already_processed_vcs, already_processed_from, pkg_set = *already_processed
                     if (already_processed_from != root_pkg_set) && (already_processed_vcs != vcs)
@@ -249,12 +239,10 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
                 # retrieve the actual name of the package set
                 if !vcs.local?
                     update_remote_package_set(vcs, options)
-                    create_remote_set_user_dir(vcs)
-                    raw_local_dir = PackageSet.raw_local_dir_of(vcs)
-                    required_remotes_dirs << raw_local_dir
+                    required_remotes_dirs << PackageSet.raw_local_dir_of(ws, vcs)
                 end
 
-                name = PackageSet.name_of(ws.manifest, vcs)
+                name = PackageSet.name_of(ws, vcs)
 
                 required_user_dirs = by_name.collect { |k,v| k }
                 Autoproj.debug "Trying to load package_set: #{name} from definition #{repository_id}"
@@ -264,8 +252,8 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
                     already_loaded_pkg_set, already_loaded_vcs = *already_loaded
                     if already_loaded_vcs != vcs
                         if imported_from
-                            Autoproj.warn "redundant auto-import by #{imported_from.name} for package set '#{name}'."
-                            Autoproj.warn "    A package set with the same name (#{name}) has already been imported from"
+                            Autoproj.warn "redundant auto-import of package set '#{name}' by package set '#{imported_from.name}'"
+                            Autoproj.warn "    A package set with the same name has already been imported from"
                             Autoproj.warn "        #{already_loaded_vcs}"
                             Autoproj.warn "    Skipping the following one: "
                             Autoproj.warn "        #{vcs}"
@@ -277,12 +265,14 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
                     if imported_from
                         already_loaded_pkg_set.imported_from << imported_from
                         imported_from.imports << already_loaded_pkg_set
+                        by_repository_id[repository_id][2] = already_loaded_pkg_set
                     end
                     next
-                else
-                    create_remote_set_user_dir(vcs)
                 end
 
+                if !vcs.local?
+                    create_remote_set_user_dir(vcs)
+                end
                 pkg_set = load_package_set(vcs, import_options, imported_from)
                 by_repository_id[repository_id][2] = pkg_set
                 package_sets << pkg_set
@@ -335,7 +325,7 @@ def sort_package_sets_by_import_order(package_sets, root_pkg_set)
             #    considered in turn, and added at the earliest place that fits
             #    the dependencies
             topological = Array.new
-            queue = package_sets.to_a
+            queue = (package_sets.to_a + [root_pkg_set]).uniq
             while !queue.empty?
                 last_size = queue.size
                 pending = queue.dup
@@ -355,7 +345,7 @@ def sort_package_sets_by_import_order(package_sets, root_pkg_set)
 
             result = root_pkg_set.imports.to_a.dup
             to_insert = topological.dup.
-                find_all { |pkg_set| !result.include?(pkg_set) }
+                find_all { |p| !result.include?(p) }
             while !to_insert.empty?
                 pkg_set = to_insert.shift
                 dependencies = pkg_set.imports.dup
@@ -369,7 +359,13 @@ def sort_package_sets_by_import_order(package_sets, root_pkg_set)
                     result.insert(i + 1, pkg_set)
                 end
             end
-            result << root_pkg_set
+
+            # 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"
+            end
             result
         end
 
@@ -383,34 +379,39 @@ def load_package_sets(options = Hash.new)
             update_configuration(options)
         end
 
-        def update_configuration(options = Hash.new)
-            if !options.kind_of?(Hash)
-                options = Hash[only_local: options]
-            end
-            options = validate_options options,
+        def update_configuration(
                 only_local: false,
                 checkout_only: !Autobuild.do_update,
                 ignore_errors: false,
                 reset: false,
-                retry_count: nil
+                retry_count: nil)
+
+            update_options = Hash[
+                only_local: only_local,
+                checkout_only: checkout_only,
+                ignore_errors: ignore_errors,
+                reset: reset,
+                retry_count: retry_count]
 
-            # Load the installation's manifest a first time, to check if we should
-            # update it ... We assume that the OS dependencies for this VCS is already
-            # installed (i.e. that the user did not remove it)
             if ws.manifest.vcs && !ws.manifest.vcs.local?
-                update_main_configuration(options)
+                update_main_configuration(**update_options)
             end
             ws.load_main_initrb
             ws.manifest.load(manifest_path)
-
-            root_pkg_set = ws.manifest.local_package_set
+            root_pkg_set = ws.manifest.main_package_set
             root_pkg_set.load_description_file
             root_pkg_set.explicit = true
-            package_sets = load_and_update_package_sets(root_pkg_set, options)
+            update_package_sets(**update_options)
+        end
+
+        def update_package_sets(**update_options)
+            root_pkg_set = ws.manifest.main_package_set
+            package_sets = load_and_update_package_sets(root_pkg_set, **update_options)
             root_pkg_set.imports.each do |pkg_set|
                 pkg_set.explicit = true
             end
             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.manifest.register_package_set(pkg_set)
             end

data/lib/autoproj/ops/import.rb

@@ -13,9 +13,9 @@ def mark_exclusion_along_revdeps(pkg_name, revdeps, chain = [], reason = nil)
                     reason = ws.manifest.exclusion_reason(pkg_name)
                 else
                     if chain.size == 1
-                        ws.manifest.add_exclusion(pkg_name, "its dependency #{reason}")
+                        ws.manifest.exclude_package(pkg_name, "its dependency #{reason}")
                     else
-                        ws.manifest.add_exclusion(pkg_name, "#{reason} (dependency chain: #{chain.join(">")})")
+                        ws.manifest.exclude_package(pkg_name, "#{reason} (dependency chain: #{chain.join(">")})")
                     end
                 end
 
@@ -34,11 +34,11 @@ def import_next_step(pkg, reverse_dependencies)
                 new_packages = []
                 pkg.dependencies.each do |dep_name|
                     reverse_dependencies[dep_name] << pkg.name
-                    new_packages << ws.manifest.find_autobuild_package(dep_name)
+                    new_packages << ws.manifest.find_package_definition(dep_name)
                 end
                 pkg_opt_deps, pkg_opt_os_deps = pkg.partition_optional_dependencies
                 pkg_opt_deps.each do |dep_name|
-                    new_packages << ws.manifest.find_autobuild_package(dep_name)
+                    new_packages << ws.manifest.find_package_definition(dep_name)
                 end
 
                 # Handle OS dependencies, excluding the package if some
@@ -82,7 +82,9 @@ def pre_package_import(selection, manifest, pkg, reverse_dependencies)
 
             def post_package_import(selection, manifest, pkg, reverse_dependencies)
                 Rake::Task["#{pkg.name}-import"].instance_variable_set(:@already_invoked, true)
-                manifest.load_package_manifest(pkg.name)
+                if pkg.checked_out?
+                    manifest.load_package_manifest(pkg.name)
+                end
 
                 # The package setup mechanisms might have added an exclusion
                 # on this package. Handle this.
@@ -95,35 +97,82 @@ def post_package_import(selection, manifest, pkg, reverse_dependencies)
                 elsif manifest.ignored?(pkg.name)
                     false
                 else
-                    Autoproj.each_post_import_block(pkg) do |block|
-                        block.call(pkg)
+                    if pkg.checked_out?
+                        Autoproj.each_post_import_block(pkg) do |block|
+                            block.call(pkg)
+                        end
                     end
                     import_next_step(pkg, reverse_dependencies)
                 end
             end
 
+            # Install the VCS osdep for the given packages
+            #
+            # @param [Hash] osdeps_options the options that will be passed to
+            #   {Workspace#install_os_packages}
+            # @return [Set] the set of installed OS packages
+            def install_vcs_packages_for(*packages, **osdeps_options)
+                vcs_to_install = packages.map { |pkg| pkg.vcs.type }.uniq
+                # This assumes that the VCS packages do not depend on a
+                # 'strict' package mangers such as e.g. BundlerManager
+                ws.install_os_packages(vcs_to_install, all: nil, **osdeps_options)
+                vcs_to_install
+            end
+
+            # @api private
+            #
+            # Queue the work necessary to import the given package, making sure
+            # that the execution results end up in a given queue
+            #
+            # @param executor the future executor 
+            # @param [Queue] completion_queue the queue where the completion
+            #   results should be pushed, as a (package, time, result,
+            #   error_reason) tuple
+            # @param [Integer] retry_count the number of retries that are
+            #   allowed. Set to zero for no retry
+            # @param [Hash] import_options options passed to {Autobuild::Importer#import}
+            def queue_import_work(executor, completion_queue, pkg, retry_count: nil, **import_options)
+                import_future = Concurrent::Future.new(executor: executor, args: [pkg]) do |import_pkg|
+                    ## COMPLETELY BYPASS RAKE HERE
+                    # The reason is that the ordering of import/prepare between
+                    # packages is not important BUT the ordering of import vs.
+                    # prepare in one package IS important: prepare is the method
+                    # that takes into account dependencies.
+                    if retry_count
+                        import_pkg.autobuild.importer.retry_count = retry_count
+                    end
+                    import_pkg.autobuild.import(**import_options)
+                end
+                import_future.add_observer do |time, result, reason|
+                    completion_queue << [pkg, time, result, reason]
+                end
+                import_future.execute
+            end
+
             class ImportFailed < RuntimeError; end
 
             # Import all packages from the given selection, and their
             # dependencies
-            def import_selected_packages(selection, updated_packages, options = Hash.new)
-                parallel_options, options = Kernel.filter_options options,
-                    parallel: ws.config.parallel_import_level
+            def import_selected_packages(selection, updated_packages,
+                                         parallel: ws.config.parallel_import_level,
+                                         recursive: true,
+                                         retry_count: nil,
+                                         ignore_errors: false,
+                                         install_vcs_packages: Hash.new,
+                                         non_imported_packages: :checkout,
+                                         **import_options)
+
+                if ![:checkout, :ignore, :return].include?(non_imported_packages)
+                    raise ArgumentError, "invalid value for 'non_imported_packages'. Expected one of :checkout, :ignore or :return but got #{non_imported_packages}"
+                end
 
                 # This is used in the ensure block, initialize as early as
                 # possible
-                executor = Concurrent::FixedThreadPool.new(parallel_options[:parallel], max_length: 0)
-
-                options, import_options = Kernel.filter_options options,
-                    recursive: true,
-                    retry_count: nil
-
-                ignore_errors = options[:ignore_errors]
-                retry_count = options[:retry_count]
+                executor = Concurrent::FixedThreadPool.new(parallel, max_length: 0)
                 manifest = ws.manifest
 
                 selected_packages = selection.each_source_package_name.map do |pkg_name|
-                    manifest.find_autobuild_package(pkg_name)
+                    manifest.find_package_definition(pkg_name)
                 end.to_set
 
                 # The reverse dependencies for the package tree. It is discovered as
@@ -138,69 +187,96 @@ def import_selected_packages(selection, updated_packages, options = Hash.new)
                 pending_packages = Set.new
                 # The set of all packages that are currently selected by +selection+
                 all_processed_packages = Set.new
-                interactive_imports = Array.new
+                main_thread_imports = Array.new
                 package_queue = selected_packages.to_a.sort_by(&:name)
                 failures = Hash.new
+                missing_vcs = Array.new
+                installed_vcs_packages = Set['none', 'local']
                 while failures.empty? || ignore_errors
                     # Queue work for all packages in the queue
                     package_queue.each do |pkg|
                         # Remove packages that have already been processed
                         next if all_processed_packages.include?(pkg)
+                        if (non_imported_packages != :checkout) && !File.directory?(pkg.autobuild.srcdir)
+                            if non_imported_packages == :return
+                                all_processed_packages << pkg
+                                completion_queue << [pkg, Time.now, false, nil]
+                                next
+                            else
+                                all_processed_packages << pkg
+                                ws.manifest.ignore_package(pkg.name)
+                                next
+                            end
+                        elsif install_vcs_packages && !installed_vcs_packages.include?(pkg.vcs.type)
+                            missing_vcs << pkg
+                            next
+                        end
                         all_processed_packages << pkg
 
-                        if !pre_package_import(selection, manifest, pkg, reverse_dependencies)
+                        importer = pkg.autobuild.importer
+                        if !pre_package_import(selection, manifest, pkg.autobuild, reverse_dependencies)
                             next
-                        elsif !pkg.importer
+                        elsif !importer
+                            # The validity of this is checked in
+                            # pre_package_import
                             completion_queue << [pkg, Time.now, false, nil]
                             next
-                        elsif pkg.importer.interactive?
-                            interactive_imports << pkg
+                        elsif importer.interactive?
+                            main_thread_imports << pkg
+                            next
+                        elsif pkg.autobuild.checked_out? && import_options[:checkout_only]
+                            main_thread_imports << pkg
                             next
                         end
 
                         pending_packages << pkg
-                        import_future = Concurrent::Future.new(executor: executor, args: [pkg]) do |import_pkg|
-                            ## COMPLETELY BYPASS RAKE HERE
-                            # The reason is that the ordering of import/prepare between
-                            # packages is not important BUT the ordering of import vs.
-                            # prepare in one package IS important: prepare is the method
-                            # that takes into account dependencies.
-                            if retry_count
-                                import_pkg.importer.retry_count = retry_count
-                            end
-                            import_pkg.import(import_options.merge(allow_interactive: false))
-                        end
-                        import_future.add_observer do |time, result, reason|
-                            completion_queue << [pkg, time, result, reason]
+                        begin
+                            queue_import_work(
+                                executor, completion_queue, pkg, retry_count: retry_count,
+                                **import_options.merge(allow_interactive: false))
+                        rescue Exception
+                            pending_packages.delete(pkg)
+                            raise
                         end
-                        import_future.execute
+                        true
                     end
                     package_queue.clear
 
                     if completion_queue.empty? && pending_packages.empty?
+                        if !missing_vcs.empty?
+                            installed_vcs_packages.merge(
+                                install_vcs_packages_for(*missing_vcs, **install_vcs_packages))
+                            package_queue.concat(missing_vcs)
+                            missing_vcs.clear
+                            next
+                        end
+
                         # We've nothing to process anymore ... process
                         # interactive imports if there are some. Otherwise,
                         # we're done
-                        if interactive_imports.empty?
+                        if main_thread_imports.empty?
                             break
                         else
-                            interactive_imports.each do |pkg|
+                            main_thread_imports.delete_if do |pkg|
                                 begin
-                                    result = pkg.import(import_options.merge(allow_interactive: true))
+                                    if retry_count
+                                        pkg.autobuild.importer.retry_count = retry_count
+                                    end
+                                    result = pkg.autobuild.import(
+                                        **import_options.merge(allow_interactive: true))
                                 rescue Exception => reason
                                 end
                                 completion_queue << [pkg, Time.now, result, reason]
                             end
-                            interactive_imports.clear
                         end
                     end
 
-                    # And wait one to finish
+                    # And wait for one to finish
                     pkg, _time, _result, reason = completion_queue.pop
                     pending_packages.delete(pkg)
                     if reason
                         if reason.kind_of?(Autobuild::InteractionRequired)
-                            interactive_imports << pkg
+                            main_thread_imports << pkg
                         else
                             # One importer failed... terminate
                             Autoproj.error "import of #{pkg.name} failed"
@@ -210,13 +286,13 @@ def import_selected_packages(selection, updated_packages, options = Hash.new)
                             failures[pkg] = reason
                         end
                     else
-                        if new_packages = post_package_import(selection, manifest, pkg, reverse_dependencies)
+                        if new_packages = post_package_import(selection, manifest, pkg.autobuild, reverse_dependencies)
                             # Excluded dependencies might have caused the package to be
                             # excluded as well ... do not add any dependency to the
                             # processing queue if it is the case
                             if manifest.excluded?(pkg.name)
                                 selection.filter_excluded_and_ignored_packages(manifest)
-                            elsif options[:recursive]
+                            elsif recursive
                                 package_queue = new_packages.sort_by(&:name)
                             end
                         end
@@ -240,7 +316,12 @@ def import_selected_packages(selection, updated_packages, options = Hash.new)
                     executor.shutdown
                     executor.wait_for_termination
                 end
-                updated_packages.concat(all_processed_packages.find_all(&:updated?).map(&:name))
+                if all_processed_packages
+                    all_updated_packages = all_processed_packages.find_all do |processed_pkg|
+                        processed_pkg.autobuild.updated?
+                    end
+                    updated_packages.concat(all_updated_packages.map(&:name))
+                end
             end
             
             def finalize_package_load(processed_packages)
@@ -256,8 +337,9 @@ def finalize_package_load(processed_packages)
 
                     next if manifest.ignored?(pkg_name) || manifest.excluded?(pkg_name)
 
-                    pkg = manifest.find_autobuild_package(pkg_name)
-                    if !processed_packages.include?(pkg) && File.directory?(pkg.srcdir)
+                    pkg_definition = manifest.find_package_definition(pkg_name)
+                    pkg = pkg_definition.autobuild
+                    if !processed_packages.include?(pkg_definition) && File.directory?(pkg.srcdir)
                         manifest.load_package_manifest(pkg.name)
                         Autoproj.each_post_import_block(pkg) do |block|
                             block.call(pkg)
@@ -286,37 +368,45 @@ def finalize_package_load(processed_packages)
                 all
             end
 
-            def import_packages(selection, options = Hash.new)
+            def import_packages(selection,
+                                non_imported_packages: :checkout,
+                                warn_about_ignored_packages: true,
+                                warn_about_excluded_packages: true,
+                                recursive: true,
+                                ignore_errors: false,
+                                install_vcs_packages: Hash.new,
+                                **import_options)
+
                 # Used in the ensure block, initialize as soon as possible
                 updated_packages = Array.new
 
-                options, import_options = Kernel.filter_options options,
-                    warn_about_ignored_packages: true,
-                    warn_about_excluded_packages: true,
-                    recursive: true
-
                 manifest = ws.manifest
 
                 all_processed_packages = import_selected_packages(
-                    selection, updated_packages, import_options.merge(recursive: options[:recursive]))
+                    selection, updated_packages,
+                    non_imported_packages: non_imported_packages,
+                    ignore_errors: ignore_errors,
+                    recursive: recursive,
+                    install_vcs_packages: install_vcs_packages,
+                    **import_options)
                 finalize_package_load(all_processed_packages)
 
                 all_enabled_osdeps = selection.each_osdep_package_name.to_set
                 all_enabled_sources = all_processed_packages.map(&:name)
-                if options[:recursive]
+                if recursive
                     all_processed_packages.each do |pkg|
-                        all_enabled_osdeps.merge(pkg.os_packages)
+                        all_enabled_osdeps.merge(pkg.autobuild.os_packages)
                     end
                 end
 
-                if options[:warn_about_excluded_packages]
+                if warn_about_excluded_packages
                     selection.exclusions.each do |sel, pkg_names|
                         pkg_names.sort.each do |pkg_name|
                             Autoproj.warn "#{pkg_name}, which was selected for #{sel}, cannot be built: #{manifest.exclusion_reason(pkg_name)}", :bold
                         end
                     end
                 end
-                if options[:warn_about_ignored_packages]
+                if warn_about_ignored_packages
                     selection.ignores.each do |sel, pkg_names|
                         pkg_names.sort.each do |pkg_name|
                             Autoproj.warn "#{pkg_name}, which was selected for #{sel}, is ignored", :bold