autoproj 2.10.2 → 2.11.0

data/lib/autoproj/cli/main_plugin.rb

@@ -30,6 +30,8 @@ def write_plugin_list(plugins)
                 type: 'string', default: '>= 0'
             option :git, desc: 'checkout a git repository instead of downloading the gem',
                 type: 'string'
+            option :branch, desc: 'choose the branch that should be checked out with --git',
+                type: 'string', default: 'master'
             option :path, desc: 'use the plugin that is already present on this path',
                 type: 'string'
             def install(name)
@@ -40,6 +42,7 @@ def install(name)
                     raise CLIInvalidArguments, "you can provide only one of --git or --path"
                 elsif options[:git]
                     gem_options[:git] = options[:git]
+                    gem_options[:branch] = options[:branch]
                 elsif options[:path]
                     gem_options[:path] = options[:path]
                 end

data/lib/autoproj/cli/main_test.rb

@@ -22,6 +22,21 @@ def report(report_options = Hash.new)
                 end
             end
 
+            desc 'default [on|off]', 'set whether tests are enabled or disabled by default, without touching existing settings'
+            def default(on_or_off)
+                require 'autoproj/cli/test'
+                report(silent: true) do
+                    cli = Test.new
+                    args = cli.validate_options([], options)
+                    enabled = case on_or_off
+                              when 'on' then true
+                              when 'off' then false
+                              else raise ArgumentError, "expected 'on' or 'off'"
+                              end
+                    cli.default(enabled)
+                end
+            end
+
             desc 'enable [PACKAGES]', 'enable tests for the given packages (or for all packages if none are given)'
             option :deps, type: :boolean, default: false,
                 desc: 'controls whether the dependencies of the packages given on the command line should be enabled as well (the default is not)'

data/lib/autoproj/cli/test.rb

@@ -1,92 +1,21 @@
-require 'autoproj/cli/inspection_tool'
+require 'autoproj/cli/utility'
 
 module Autoproj
     module CLI
-        class Test < InspectionTool
-            def enable(user_selection, options = {})
-                if user_selection.empty?
-                    ws.load_config
-                    ws.config.utility_enable_all('test')
-                else
-                    initialize_and_load
-                    selection, = finalize_setup(
-                        user_selection,
-                        recursive: options[:deps],
-                        non_imported_packages: :return
-                    )
-                    ws.config.utility_enable('test', *selection)
-                end
-                ws.config.save
+        class Test < Utility
+            def initialize(ws = Workspace.default,
+                           name: 'test',
+                           report_path: ws.utility_report_path('test'))
+                super
             end
 
-            def disable(user_selection, options = {})
-                if user_selection.empty?
-                    ws.load_config
-                    ws.config.utility_disable_all('test')
-                else
-                    initialize_and_load
-                    selection, = finalize_setup(
-                        user_selection,
-                        recursive: options[:deps],
-                        non_imported_packages: :return
-                    )
-                    ws.config.utility_disable('test', *selection)
-                end
-                ws.config.save
-            end
-
-            def list(user_selection, options = {})
-                initialize_and_load
-                resolved_selection, = finalize_setup(
-                    user_selection,
-                    recursive: options[:deps],
-                    non_imported_packages: :return
-                )
-
-                lines = []
-                resolved_selection.each do |pkg_name|
-                    pkg = ws.manifest.find_package_definition(pkg_name).autobuild
-                    lines << [
-                        pkg.name,
-                        pkg.test_utility.enabled?,
-                        pkg.test_utility.available?
-                    ]
-                end
-                lines = lines.sort_by { |name, _| name }
-                w     = lines.map { |name, _| name.length }.max
-                out_format = "%-#{w}s %-7s %-9s"
-                puts format(out_format, 'Package Name', 'Enabled', 'Available')
-                lines.each do |name, enabled, available|
-                    puts(format(out_format, name, (!!enabled).to_s, (!!available).to_s))
-                end
-            end
-
-            def run(user_selection, options = {})
-                options[:parallel] ||= ws.config.parallel_build_level
-                initialize_and_load
-
-                packages, _, resolved_selection = finalize_setup(
-                    user_selection,
-                    recursive: user_selection.empty? || options[:deps]
-                )
-
-                validate_user_selection(user_selection, resolved_selection)
-                if packages.empty?
-                    raise CLIInvalidArguments, "autoproj: the provided package "\
-                        "is not selected for build"
-                end
-
-                packages.each do |pkg|
-                    ws.manifest.find_autobuild_package(pkg).disable_phases(
-                        'import', 'prepare', 'install'
-                    )
-                end
-
-                Autobuild.apply(
-                    packages,
-                    'autoproj-test',
-                    ['test'],
-                    parallel: options[:parallel]
+            def package_metadata(package)
+                u = package.autobuild.test_utility
+                super.merge(
+                    'coverage_available' => !!u.coverage_available?,
+                    'coverage_enabled' => !!u.coverage_enabled?,
+                    'coverage_source_dir' => u.coverage_source_dir,
+                    'coverage_target_dir' => u.coverage_target_dir
                 )
             end
         end

data/lib/autoproj/cli/update.rb

@@ -66,7 +66,7 @@ def validate_options(selection, options)
                 return selection, options
             end
 
-            def run(selected_packages, run_hook: false, **options)
+            def run(selected_packages, run_hook: false, report: true, **options)
                 ws.manifest.accept_unavailable_osdeps = !options[:osdeps]
                 ws.setup
                 ws.autodetect_operating_system(force: true)
@@ -121,7 +121,8 @@ def run(selected_packages, run_hook: false, **options)
                         keep_going: options[:keep_going],
                         parallel: options[:parallel] || ws.config.parallel_import_level,
                         retry_count: options[:retry_count],
-                        auto_exclude: options[:auto_exclude])
+                        auto_exclude: options[:auto_exclude],
+                        report: report)
 
                 ws.finalize_setup
                 ws.export_installation_manifest
@@ -195,13 +196,15 @@ def normalize_osdeps_options(
             def update_packages(selected_packages,
                 from: nil, checkout_only: false, only_local: false, reset: false,
                 deps: true, keep_going: false, parallel: 1,
-                retry_count: 0, osdeps: true, auto_exclude: false, osdeps_options: Hash.new)
+                retry_count: 0, osdeps: true, auto_exclude: false, osdeps_options: Hash.new,
+                report: true)
 
                 if from
                     setup_update_from(from)
                 end
 
-                ops = Autoproj::Ops::Import.new(ws)
+                ops = Autoproj::Ops::Import.new(
+                    ws, report_path: (ws.import_report_path if report))
                 source_packages, osdep_packages =
                         ops.import_packages(selected_packages,
                                         checkout_only: checkout_only,

data/lib/autoproj/cli/utility.rb

@@ -0,0 +1,139 @@
+require 'autoproj/cli/inspection_tool'
+
+module Autoproj
+    module CLI
+        class Utility < InspectionTool
+            def initialize(ws, name: nil, report_path: nil)
+                @utility_name = name
+                @report_path = report_path
+                super(ws)
+            end
+
+            attr_reader :utility_name
+            def default(enabled)
+                ws.load_config
+                ws.config.utility_default(utility_name, enabled)
+                ws.config.save
+            end
+
+            def enable(user_selection, options = {})
+                if user_selection.empty?
+                    ws.load_config
+                    ws.config.utility_enable_all(utility_name)
+                else
+                    initialize_and_load
+                    selection, = finalize_setup(
+                        user_selection,
+                        recursive: options[:deps],
+                        non_imported_packages: :return
+                    )
+                    ws.config.utility_enable(utility_name, *selection)
+                end
+                ws.config.save
+            end
+
+            def disable(user_selection, options = {})
+                if user_selection.empty?
+                    ws.load_config
+                    ws.config.utility_disable_all(utility_name)
+                else
+                    initialize_and_load
+                    selection, = finalize_setup(
+                        user_selection,
+                        recursive: options[:deps],
+                        non_imported_packages: :return
+                    )
+                    ws.config.utility_disable(utility_name, *selection)
+                end
+                ws.config.save
+            end
+
+            def list(user_selection, options = {})
+                initialize_and_load
+                resolved_selection, = finalize_setup(
+                    user_selection,
+                    recursive: options[:deps],
+                    non_imported_packages: :return
+                )
+
+                lines = []
+                resolved_selection.each do |pkg_name|
+                    pkg = ws.manifest.find_package_definition(pkg_name).autobuild
+                    lines << [
+                        pkg.name,
+                        pkg.send("#{utility_name}_utility").enabled?,
+                        pkg.send("#{utility_name}_utility").available?
+                    ]
+                end
+                lines = lines.sort_by { |name, _| name }
+                w     = lines.map { |name, _| name.length }.max
+                out_format = "%-#{w}s %-7s %-9s"
+                puts format(out_format, 'Package Name', 'Enabled', 'Available')
+                lines.each do |name, enabled, available|
+                    puts(format(out_format, name, (!!enabled).to_s, (!!available).to_s))
+                end
+            end
+
+            def run(user_selection, options = {})
+                options[:parallel] ||= ws.config.parallel_build_level
+                initialize_and_load
+
+                user_selection, = normalize_command_line_package_selection(user_selection)
+                package_names, _, resolved_selection = finalize_setup(
+                    user_selection,
+                    recursive: user_selection.empty? || options[:deps]
+                )
+
+                validate_user_selection(user_selection, resolved_selection)
+                if package_names.empty?
+                    raise CLIInvalidArguments, "autoproj: the provided package "\
+                        "is not selected for build"
+                end
+
+                packages = package_names.map do |pkg_name|
+                    ws.manifest.find_package_definition(pkg_name)
+                end
+
+                Autobuild.apply(
+                    package_names,
+                    "autoproj-#{utility_name}",
+                    [utility_name],
+                    parallel: options[:parallel]
+                )
+
+            ensure
+                create_report(packages) if packages && @report_path
+            end
+
+            def package_metadata(package)
+                u = package.autobuild.utility(@utility_name)
+                {
+                    'source_dir' => u.source_dir,
+                    'target_dir' => u.target_dir,
+                    'available' => !!u.available?,
+                    'enabled' => !!u.enabled?,
+                    'invoked' => !!u.invoked?,
+                    'success' => !!u.success?,
+                    'installed' => !!u.installed?,
+                }
+            end
+
+            def create_report(packages)
+                info = packages.each_with_object({}) do |p, map|
+                    map[p.name] = package_metadata(p)
+                end
+
+                FileUtils.mkdir_p File.dirname(@report_path)
+                File.open(@report_path, 'w') do |io|
+                    dump = JSON.dump(
+                        "#{@utility_name}_report" => {
+                            'timestamp' => Time.now,
+                            'packages' => info
+                        }
+                    )
+                    io.write dump
+                end
+            end
+        end
+    end
+end

data/lib/autoproj/configuration.rb

@@ -506,6 +506,19 @@ def utility_enabled_for?(utility, package)
             end
         end
 
+        # Set the given utility to enabled by default
+        #
+        # Unlike {#utility_enable_all} and {#utility_disable_all}, it does
+        # not touch existing exclusions
+        #
+        # @param [String] utility the utility name (e.g. 'doc' or 'test')
+        # @param [Boolean] enabled whether the utility will be enabled (true) or
+        #   disabled (false)
+        # @return [void]
+        def utility_default(utility, enabled)
+            set("#{utility_key(utility)}_default", enabled ? true : false)
+        end
+
         # Enables a utility for all packages
         #
         # This both sets the default value for all packages and resets all

data/lib/autoproj/default.osdeps

@@ -171,6 +171,13 @@ python:
   opensuse: python-devel
   default: ignore # will be installed manually by the user
 
+python-setuptools:
+  arch: python2-distribute
+  debian,ubuntu: python-setuptools
+  fedora: python-setuptools
+  gentoo: dev-python/setuptools
+  default: ignore # will be installed manually by the user
+
 sudo:
   macos-brew: ignore
   default: sudo

data/lib/autoproj/manifest.rb

@@ -1020,23 +1020,14 @@ def load_package_manifest(pkg)
             if manifest
                 pkg.autobuild.description = manifest
             else
-                Autoproj.warn "#{package.name} from #{package_set.name} does not have a manifest"
+                Autoproj.warn "#{package.name} from #{package_set.name} "\
+                              "does not have a manifest"
             end
 
-            manifest = pkg.autobuild.description
-            manifest.each_dependency(pkg.modes) do |name, is_optional|
-                begin
-                    if is_optional
-                        package.optional_dependency name
-                    else
-                        package.depends_on name
-                    end
-                rescue ConfigError => e
-                    raise ConfigError.new(manifest_path),
-                        "manifest #{manifest_path} of #{package.name} from #{package_set.name} lists '#{name}' as dependency, but it is neither a normal package nor an osdeps package. osdeps reports: #{e.message}", e.backtrace
-                end
-            end
-            manifest
+            pkg.apply_dependencies_from_manifest
+            # #description is initialized with a null package manifest
+            # return it even if we haven't overriden it
+            pkg.autobuild.description
         end
 
         def load_all_available_package_manifests

data/lib/autoproj/ops/build.rb

@@ -92,35 +92,29 @@ def build_packages(all_enabled_packages, options = Hash.new)
                 begin
                     Autobuild.apply(all_enabled_packages, "autoproj-build", ['build'], options)
                 ensure
-                    build_report(all_enabled_packages) if @report_path
+                    create_report(all_enabled_packages) if @report_path
                 end
             end
 
-            def build_report(package_list)
+            def create_report(package_list)
                 FileUtils.mkdir_p File.dirname(@report_path)
 
-                packages = package_list.map do |pkg_name|
+                packages = package_list.each_with_object({}) do |pkg_name, h|
                     pkg = manifest.find_autobuild_package(pkg_name)
 
-                    {
-                        name: pkg.name,
-                        import_invoked: pkg.import_invoked?,
-                        prepare_invoked: pkg.prepare_invoked?,
-                        build_invoked: pkg.build_invoked?,
-                        failed: pkg.failed?,
-                        imported: pkg.imported?,
-                        prepared: pkg.prepared?,
-                        built: pkg.built?
+                    h[pkg.name] = {
+                        invoked: !!pkg.install_invoked?,
+                        success: !!pkg.installed?
                     }
                 end
 
-                build_report = JSON.pretty_generate({
+                report = JSON.pretty_generate({
                     build_report: {
                         timestamp: Time.now,
                         packages: packages
                     }
                 })
-                IO.write(@report_path, build_report)
+                IO.write(@report_path, report)
             end
         end
     end

data/lib/autoproj/ops/import.rb

@@ -12,9 +12,10 @@ def auto_exclude?
             end
             attr_writer :auto_exclude
 
-            def initialize(ws)
+            def initialize(ws, report_path: nil)
                 @ws = ws
                 @auto_exclude = false
+                @report_path = report_path
             end
 
             def mark_exclusion_along_revdeps(pkg_name, revdeps, chain = [], reason = nil)
@@ -22,24 +23,24 @@ def mark_exclusion_along_revdeps(pkg_name, revdeps, chain = [], reason = nil)
                 chain.unshift pkg_name
                 if root
                     reason = ws.manifest.exclusion_reason(pkg_name)
+                elsif chain.size == 1
+                    ws.manifest.exclude_package(pkg_name, "its dependency #{reason}")
                 else
-                    if chain.size == 1
-                        ws.manifest.exclude_package(pkg_name, "its dependency #{reason}")
-                    else
-                        ws.manifest.exclude_package(pkg_name, "#{reason} (dependency chain: #{chain.join(">")})")
-                    end
+                    ws.manifest.exclude_package(pkg_name, "#{reason} (dependency chain: "\
+                                                          "#{chain.join('>')})")
                 end
 
-                return if !revdeps.has_key?(pkg_name)
+                return unless revdeps.key?(pkg_name)
+
                 revdeps[pkg_name].each do |dep_name|
-                    if !ws.manifest.excluded?(dep_name)
+                    unless ws.manifest.excluded?(dep_name)
                         mark_exclusion_along_revdeps(dep_name, revdeps, chain.dup, reason)
                     end
                 end
             end
 
             VALID_OSDEP_AVAILABILITY =
-                [OSPackageResolver::AVAILABLE, OSPackageResolver::IGNORE]
+                [OSPackageResolver::AVAILABLE, OSPackageResolver::IGNORE].freeze
 
             def import_next_step(pkg, reverse_dependencies)
                 new_packages = []
@@ -85,23 +86,32 @@ def pre_package_import(selection, manifest, pkg, reverse_dependencies)
                 elsif manifest.ignored?(pkg.name)
                     false
                 elsif !pkg.importer && !File.directory?(pkg.srcdir)
-                    raise ConfigError.new, "#{pkg.name} has no VCS, but is not checked out in #{pkg.srcdir}"
+                    raise ConfigError.new, "#{pkg.name} has no VCS, but is not "\
+                                           "checked out in #{pkg.srcdir}"
                 else
                     true
                 end
             end
 
-            def post_package_import(selection, manifest, pkg, reverse_dependencies, auto_exclude: auto_exclude?)
-                Rake::Task["#{pkg.name}-import"].instance_variable_set(:@already_invoked, true)
+            def post_package_import(selection, manifest, pkg, reverse_dependencies,
+                                    auto_exclude: auto_exclude?)
+                Rake::Task["#{pkg.name}-import"]
+                    .instance_variable_set(:@already_invoked, true)
                 if pkg.checked_out?
                     begin
                         manifest.load_package_manifest(pkg.name)
-                    rescue Exception => e
-                        raise if !auto_exclude
-                        manifest.add_exclusion(pkg.name, "#{pkg.name} failed to import with #{e} and auto_exclude was true")
+                    rescue StandardError => e
+                        raise unless auto_exclude
+
+                        manifest.add_exclusion(pkg.name, "#{pkg.name} failed to import "\
+                            "with #{e} and auto_exclude was true")
                     end
                 end
 
+                if !manifest.excluded?(pkg.name) && !manifest.ignored?(pkg.name)
+                    process_post_import_blocks(pkg) if pkg.checked_out?
+                end
+
                 # The package setup mechanisms might have added an exclusion
                 # on this package. Handle this.
                 if manifest.excluded?(pkg.name)
@@ -113,10 +123,8 @@ def post_package_import(selection, manifest, pkg, reverse_dependencies, auto_exc
                 elsif manifest.ignored?(pkg.name)
                     false
                 else
-                    if pkg.checked_out?
-                        process_post_import_blocks(pkg)
-                    end
-                    import_next_step(pkg, reverse_dependencies)
+                    pkg.apply_dependencies_from_manifest
+                    import_next_step(pkg.autobuild, reverse_dependencies)
                 end
             end
 
@@ -163,16 +171,16 @@ def install_internal_dependencies_for(*packages, **osdeps_options)
             # @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|
+            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.importer.retry_count = retry_count if retry_count
                     import_pkg.autobuild.import(**import_options)
                 end
                 import_future.add_observer do |time, result, reason|
@@ -193,8 +201,10 @@ def import_selected_packages(selection,
                                          auto_exclude: auto_exclude?,
                                          **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}"
+                unless %i[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
@@ -220,6 +230,7 @@ def import_selected_packages(selection,
                 all_processed_packages = Set.new
                 main_thread_imports = Array.new
                 package_queue = selected_packages.to_a.sort_by(&:name)
+
                 failures = Array.new
                 missing_vcs = Array.new
                 installed_vcs_packages = Set['none', 'local']
@@ -228,24 +239,25 @@ def import_selected_packages(selection,
                     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)
+
+                        vcs_installed = installed_vcs_packages.include?(pkg.vcs.type)
+                        if (non_imported_packages != :checkout) && !pkg.checked_out?
+                            all_processed_packages << pkg
                             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)
+                            next
+                        elsif install_vcs_packages && !vcs_installed
                             missing_vcs << pkg
                             next
                         end
                         all_processed_packages << pkg
 
                         importer = pkg.autobuild.importer
-                        if !pre_package_import(selection, manifest, pkg.autobuild, reverse_dependencies)
+                        if !pre_package_import(selection, manifest, pkg.autobuild,
+                                               reverse_dependencies)
                             next
                         elsif !importer
                             # The validity of this is checked in
@@ -255,7 +267,7 @@ def import_selected_packages(selection,
                         elsif importer.interactive?
                             main_thread_imports << pkg
                             next
-                        elsif pkg.autobuild.checked_out? && import_options[:checkout_only]
+                        elsif pkg.checked_out? && import_options[:checkout_only]
                             main_thread_imports << pkg
                             next
                         end
@@ -263,20 +275,21 @@ def import_selected_packages(selection,
                         pending_packages << pkg
                         begin
                             queue_import_work(
-                                executor, completion_queue, pkg, retry_count: retry_count,
+                                executor, completion_queue, pkg,
+                                retry_count: retry_count,
                                 **import_options.merge(allow_interactive: false))
                         rescue Exception
                             pending_packages.delete(pkg)
                             raise
                         end
-                        true
                     end
                     package_queue.clear
 
                     if completion_queue.empty? && pending_packages.empty?
-                        if !missing_vcs.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_vcs_packages))
                             package_queue.concat(missing_vcs)
                             missing_vcs.clear
                             next
@@ -289,15 +302,17 @@ def import_selected_packages(selection,
                             break
                         else
                             main_thread_imports.delete_if do |pkg|
+                                # rubocop:disable Lint/HandleExceptions
                                 begin
                                     if retry_count
                                         pkg.autobuild.importer.retry_count = retry_count
                                     end
                                     result = pkg.autobuild.import(
                                         **import_options.merge(allow_interactive: true))
-                                rescue Exception => reason
+                                rescue StandardError => e
                                 end
-                                completion_queue << [pkg, Time.now, result, reason]
+                                completion_queue << [pkg, Time.now, result, e]
+                                # rubocop:enable Lint/HandleExceptions
                             end
                         end
                     end
@@ -309,20 +324,21 @@ def import_selected_packages(selection,
                         if reason.kind_of?(Autobuild::InteractionRequired)
                             main_thread_imports << pkg
                         elsif auto_exclude
-                            manifest.add_exclusion(pkg.name, "#{pkg.name} failed to import with #{reason} and auto_exclude was true")
+                            manifest.add_exclusion(
+                                pkg.name, "#{pkg.name} failed to import with "\
+                                          "#{reason} and auto_exclude was true")
                             selection.filter_excluded_and_ignored_packages(manifest)
                         else
                             # One importer failed... terminate
                             Autoproj.error "import of #{pkg.name} failed"
-                            if !reason.kind_of?(Interrupt)
-                                Autoproj.error "#{reason}"
-                            end
+                            Autoproj.error reason.to_s unless reason.kind_of?(Interrupt)
                             failures << reason
                         end
                     else
-                        if new_packages = post_package_import(
-                                selection, manifest, pkg.autobuild, reverse_dependencies,
-                                auto_exclude: auto_exclude)
+                        new_packages = post_package_import(
+                            selection, manifest, pkg, reverse_dependencies,
+                            auto_exclude: auto_exclude)
+                        if new_packages
                             # 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
@@ -336,10 +352,10 @@ def import_selected_packages(selection,
                 end
 
                 all_processed_packages.delete_if do |processed_pkg|
-                    ws.manifest.excluded?(processed_pkg.name) || ws.manifest.ignored?(processed_pkg.name)
+                    ws.manifest.excluded?(processed_pkg.name) ||
+                        ws.manifest.ignored?(processed_pkg.name)
                 end
-                return all_processed_packages, failures
-
+                [all_processed_packages, failures]
             ensure
                 if failures && !failures.empty? && !keep_going
                     Autoproj.error "waiting for pending import jobs to finish"
@@ -354,13 +370,16 @@ def finalize_package_load(processed_packages, auto_exclude: auto_exclude?)
                 manifest = ws.manifest
 
                 all = Set.new
-                package_queue = manifest.all_layout_packages(false).each_source_package_name.to_a +
+                package_queue =
+                    manifest.all_layout_packages(false)
+                            .each_source_package_name.to_a +
                     processed_packages.map(&:name).to_a
-                while !package_queue.empty?
+
+                until package_queue.empty?
                     pkg_name = package_queue.shift
                     next if all.include?(pkg_name)
-                    all << pkg_name
 
+                    all << pkg_name
                     next if manifest.ignored?(pkg_name) || manifest.excluded?(pkg_name)
 
                     pkg_definition = manifest.find_package_definition(pkg_name)
@@ -370,27 +389,28 @@ def finalize_package_load(processed_packages, auto_exclude: auto_exclude?)
                             manifest.load_package_manifest(pkg.name)
                             process_post_import_blocks(pkg)
                         rescue Exception => e
-                            raise if !auto_exclude
-                            manifest.exclude_package(pkg.name, "#{pkg.name} had an error when being loaded (#{e.message}) and auto_exclude is true")
+                            raise unless auto_exclude
+
+                            manifest.exclude_package(
+                                pkg.name, "#{pkg.name} had an error when "\
+                                          "being loaded (#{e.message}) and "\
+                                          "auto_exclude is true")
                             next
                         end
                     end
 
                     packages, osdeps = pkg.partition_optional_dependencies
-                    packages.each do |dep_pkg_name|
-                        if !manifest.ignored?(dep_pkg_name) && !manifest.excluded?(dep_pkg_name)
-                            pkg.depends_on dep_pkg_name
-                        end
-                    end
-                    osdeps.each do |osdep_pkg_name|
-                        if !manifest.ignored?(osdep_pkg_name) && !manifest.excluded?(osdep_pkg_name)
-                            pkg.os_packages << osdep_pkg_name
-                        end
+                    (packages + osdeps).each do |dep_pkg_name|
+                        next if manifest.ignored?(dep_pkg_name)
+                        next if manifest.excluded?(dep_pkg_name)
+
+                        pkg.depends_on dep_pkg_name
                     end
 
                     if File.directory?(pkg.srcdir)
                         pkg.prepare
-                        Rake::Task["#{pkg.name}-prepare"].instance_variable_set(:@already_invoked, true)
+                        Rake::Task["#{pkg.name}-prepare"]
+                            .instance_variable_set(:@already_invoked, true)
                     end
                     pkg.update_environment
                     package_queue.concat(pkg.dependencies)
@@ -419,9 +439,7 @@ def import_packages(selection,
                     auto_exclude: auto_exclude,
                     **import_options)
 
-                if !keep_going && !failures.empty?
-                    raise failures.first
-                end
+                raise failures.first if !keep_going && !failures.empty?
 
                 install_internal_dependencies_for(*all_processed_packages)
                 finalize_package_load(all_processed_packages, auto_exclude: auto_exclude)
@@ -437,14 +455,17 @@ def import_packages(selection,
                 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
+                            Autoproj.warn "#{pkg_name}, which was selected "\
+                                          "for #{sel}, cannot be built: "\
+                                          "#{manifest.exclusion_reason(pkg_name)}", :bold
                         end
                     end
                 end
                 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
+                            Autoproj.warn "#{pkg_name}, which was selected for #{sel}, "\
+                                          "is ignored", :bold
                         end
                     end
                 end
@@ -452,41 +473,67 @@ def import_packages(selection,
                 if !failures.empty?
                     raise PackageImportFailed.new(
                         failures, source_packages: all_enabled_sources,
-                        osdep_packages: all_enabled_osdeps)
+                                  osdep_packages: all_enabled_osdeps)
                 else
                     return all_enabled_sources, all_enabled_osdeps
                 end
-
             ensure
-                if ws.config.import_log_enabled? && Autoproj::Ops::Snapshot.update_log_available?(manifest)
-                    update_log_for_processed_packages(all_processed_packages || Array.new, $!)
+                create_report(all_processed_packages || []) if @report_path
+
+                update_log = ws.config.import_log_enabled? &&
+                             Autoproj::Ops::Snapshot.update_log_available?(manifest)
+                if update_log
+                    update_log_for_processed_packages(
+                        all_processed_packages || Array.new, $!)
                 end
             end
 
+            # Call post-import blcoks registered for the given package
+            #
+            # @param [PackageDefinition] pkg
             def process_post_import_blocks(pkg)
                 Autoproj.each_post_import_block(pkg) do |block|
                     block.call(pkg)
                 end
             end
 
+            def create_report(package_list)
+                FileUtils.mkdir_p File.dirname(@report_path)
+
+                packages = package_list.each_with_object({}) do |pkg_name, h|
+                    pkg = @ws.manifest.find_autobuild_package(pkg_name)
+
+                    h[pkg.name] = {
+                        invoked: !!pkg.import_invoked?,
+                        success: !!pkg.imported?
+                    }
+                end
+
+                report = JSON.pretty_generate({
+                    import_report: {
+                        timestamp: Time.now,
+                        packages: packages
+                    }
+                })
+                IO.write(@report_path, report)
+            end
+
             def update_log_for_processed_packages(all_processed_packages, exception)
                 all_updated_packages = all_processed_packages.find_all do |processed_pkg|
                     processed_pkg.autobuild.updated?
                 end
 
-                if !all_updated_packages.empty?
+                unless all_updated_packages.empty?
                     failure_message =
                         if exception
                             " (#{exception.message.split("\n").first})"
                         end
                     ops = Ops::Snapshot.new(ws.manifest, keep_going: true)
                     ops.update_package_import_state(
-                        "#{$0} #{ARGV.join(" ")}#{failure_message}",
+                        "#{$0} #{ARGV.join(' ')}#{failure_message}",
                         all_updated_packages.map(&:name))
                 end
             end
         end
     end
 end
-
-