autoproj 2.10.1 → 2.13.0

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.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

@@ -1,5 +1,6 @@
 require 'autoproj/cli'
 require 'autoproj/cli/base'
+require 'autoproj/cli/status'
 require 'autoproj/ops/import'
 
 module Autoproj
@@ -66,17 +67,20 @@ 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, ask: false, **options)
                 ws.manifest.accept_unavailable_osdeps = !options[:osdeps]
                 ws.setup
                 ws.autodetect_operating_system(force: true)
-                if options[:bundler]
-                    ws.update_bundler
-                end
-                if options[:autoproj]
-                    ws.update_autoproj
+
+                if ask
+                    prompt = TTY::Prompt.new
+                    options[:bundler] &&= prompt.yes?("Update bundler ?")
+                    options[:autoproj] &&= prompt.yes?("Update autoproj ?")
                 end
 
+                ws.update_bundler if options[:bundler]
+                ws.update_autoproj if options[:autoproj]
+
                 begin
                     ws.load_package_sets(
                         mainline: options[:mainline],
@@ -84,7 +88,8 @@ def run(selected_packages, run_hook: false, **options)
                         checkout_only: !options[:config] || options[:checkout_only],
                         reset: options[:reset],
                         keep_going: options[:keep_going],
-                        retry_count: options[:retry_count])
+                        retry_count: options[:retry_count]
+                    )
                 rescue ImportFailed => configuration_import_failure
                     if !options[:keep_going]
                         raise
@@ -121,7 +126,9 @@ 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],
+                        ask: ask,
+                        report: report)
 
                 ws.finalize_setup
                 ws.export_installation_manifest
@@ -192,16 +199,65 @@ def normalize_osdeps_options(
                 osdeps_options
             end
 
+            class AskUpdateFilter
+                def initialize(prompt, parallel: 1, only_local: false)
+                    @prompt = prompt
+                    @only_local = only_local
+                    @executor = Concurrent::FixedThreadPool.new(parallel, max_length: 0)
+
+                    @parallel = parallel
+                    @futures = {}
+                    @lookahead_queue = []
+                end
+
+                def call(pkg)
+                    unless (status = @futures.delete(pkg).value)
+                        raise v.reason
+                    end
+
+                    clean = !status.unexpected &&
+                            (status.sync || (status.local && !status.remote))
+                    if clean
+                        msg = Autobuild.color('already up-to-date', :green)
+                        pkg.autobuild.message "#{msg} %s"
+                        return false
+                    end
+
+                    Autobuild.progress_display_synchronize do
+                        status.msg.each { |m| puts m }
+                        @prompt.yes?("Update #{pkg.name} ?")
+                    end
+                end
+
+                def lookahead(pkg)
+                    @futures[pkg] = Concurrent::Future.execute(executor: @executor) do
+                        Status.status_of_package(
+                            pkg, snapshot: false, only_local: @only_local
+                        )
+                    end
+                end
+            end
+
             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, ask: false)
 
-                if from
-                    setup_update_from(from)
-                end
+                setup_update_from(from) if from
+
+                filter =
+                    if ask
+                        prompt = TTY::Prompt.new
+                        filter = AskUpdateFilter.new(
+                            prompt, parallel: parallel, only_local: only_local
+                        )
+                    else
+                        ->(pkg) { true }
+                    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,
@@ -212,15 +268,17 @@ def update_packages(selected_packages,
                                         parallel: parallel,
                                         retry_count: retry_count,
                                         install_vcs_packages: (osdeps_options if osdeps),
-                                        auto_exclude: auto_exclude)
-                return source_packages, osdep_packages, nil
+                                        auto_exclude: auto_exclude,
+                                        filter: filter)
+                [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/cli/utility.rb

@@ -0,0 +1,136 @@
+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)) # rubocop:disable Style/DoubleNegation
+                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
+                return if package_names.empty?
+
+                packages = package_names.map do |pkg_name|
+                    ws.manifest.find_package_definition(pkg_name)
+                end
+
+                apply_to_packages(packages, parallel: options[:parallel])
+            end
+
+            def apply_to_packages(packages, parallel: ws.config.parallel_build_level)
+                if @report_path
+                    reporting = Ops::PhaseReporting.new(
+                        @utility_name, @report_path,
+                        method(:package_metadata)
+                    )
+                end
+
+                reporting&.initialize_incremental_report
+                Autobuild.apply(
+                    packages.map(&:name), "autoproj-#{@utility_name}",
+                    [@utility_name], parallel: parallel
+                ) do |pkg, phase|
+                    reporting&.report_incremental(pkg) if phase == utility_name
+                end
+            ensure
+                reporting&.create_report(packages.map(&:autobuild))
+            end
+
+            def package_metadata(autobuild_package)
+                # rubocop:disable Style/DoubleNegation
+                u = autobuild_package.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?
+                }
+                # rubocop:enable Style/DoubleNegation
+            end
+        end
+    end
+end

data/lib/autoproj/configuration.rb

@@ -196,7 +196,9 @@ def configure(option_name)
                     Autoproj.info "       using: #{value} (noninteractive mode)"
                 end
                 @modified = true
-                if !is_default
+                if is_default
+                    value = opt.validate(value)
+                else
                     config[option_name] = [value, true]
                     displayed_options[option_name] = value
                 end
@@ -242,10 +244,10 @@ def save(path = self.path, force: false)
             @modified = false
         end
 
-        def each_reused_autoproj_installation
+        def each_reused_autoproj_installation(&block)
             if has_value_for?('reused_autoproj_installations')
-                get('reused_autoproj_installations').each(&proc)
-            else [].each(&proc)
+                get('reused_autoproj_installations').each(&block)
+            else [].each(&block)
             end
         end
 
@@ -353,6 +355,10 @@ def shell_helpers=(flag)
             set 'shell_helpers', flag, true
         end
 
+        def bundler_version
+            get 'bundler_version', nil
+        end
+
         def apply_autobuild_configuration
             if has_value_for?('autobuild')
                 params = get('autobuild')
@@ -369,6 +375,11 @@ def importer_cache_dir
             get('importer_cache_dir', nil)
         end
 
+        # Set import and gem cache directory
+        def importer_cache_dir=(path)
+            set('importer_cache_dir', path, true)
+        end
+
         # Sets the directory in which packages will be installed
         def prefix_dir=(path)
             set('prefix', path, true)
@@ -506,6 +517,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