autoproj 2.12.0 → 2.15.0

data/lib/autoproj/cli/update.rb

@@ -1,6 +1,7 @@
-require 'autoproj/cli'
-require 'autoproj/cli/base'
-require 'autoproj/ops/import'
+require "autoproj/cli"
+require "autoproj/cli/base"
+require "autoproj/cli/status"
+require "autoproj/ops/import"
 
 module Autoproj
     module CLI
@@ -8,13 +9,11 @@ module Autoproj
             def validate_options(selection, options)
                 selection, options = super
 
-                if from = options[:from]
+                if (from = options[:from])
                     options[:from] = Autoproj::InstallationManifest.from_workspace_root(from)
                 end
 
-                if options[:no_deps_shortcut]
-                    options[:deps] = false
-                end
+                options[:deps] = false if options[:no_deps_shortcut]
 
                 if options[:aup] && !options[:config] && !options[:all] && selection.empty?
                     if Dir.pwd == ws.root_dir
@@ -24,12 +23,10 @@ module Autoproj
                     end
                 end
 
-                if options.delete(:force_reset)
-                    options[:reset] = :force
-                end
+                options[:reset] = :force if options.delete(:force_reset)
 
-                if mainline = options[:mainline]
-                    if mainline == 'mainline' || mainline == 'true'
+                if (mainline = options[:mainline])
+                    if mainline == "mainline" || mainline == "true"
                         options[:mainline] = true
                     end
                 end
@@ -63,20 +60,23 @@ module Autoproj
                 options[:autoproj] = update_autoproj
                 options[:config]   = update_config
                 options[:packages] = update_packages
-                return selection, options
+                [selection, options]
             end
 
-            def run(selected_packages, run_hook: false, report: true, **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,11 +84,10 @@ module Autoproj
                         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
-                    end
+                    raise unless options[:keep_going]
                 ensure
                     ws.config.save
                 end
@@ -99,14 +98,16 @@ module Autoproj
                 else
                     ws.setup_all_package_directories
                     ws.finalize_package_setup
-                    command_line_selection, selected_packages = [], PackageSelection.new
+                    command_line_selection = []
+                    selected_packages = PackageSelection.new
                 end
 
                 osdeps_options = normalize_osdeps_options(
                     checkout_only: options[:checkout_only],
                     osdeps_mode: options[:osdeps_mode],
                     osdeps: options[:osdeps],
-                    osdeps_filter_uptodate: options[:osdeps_filter_uptodate])
+                    osdeps_filter_uptodate: options[:osdeps_filter_uptodate]
+                )
 
                 source_packages, osdep_packages, import_failure =
                     update_packages(
@@ -122,7 +123,9 @@ module Autoproj
                         parallel: options[:parallel] || ws.config.parallel_import_level,
                         retry_count: options[:retry_count],
                         auto_exclude: options[:auto_exclude],
-                        report: report)
+                        ask: ask,
+                        report: report
+                    )
 
                 ws.finalize_setup
                 ws.export_installation_manifest
@@ -135,12 +138,12 @@ module Autoproj
                 if run_hook
                     if options[:osdeps]
                         CLI::Main.run_post_command_hook(:update, ws,
-                            source_packages: source_packages,
-                            osdep_packages: osdep_packages)
+                                                        source_packages: source_packages,
+                                                        osdep_packages: osdep_packages)
                     else
                         CLI::Main.run_post_command_hook(:update, ws,
-                            source_packages: source_packages,
-                            osdep_packages: [])
+                                                        source_packages: source_packages,
+                                                        osdep_packages: [])
                     end
                 end
 
@@ -156,7 +159,7 @@ module Autoproj
                     end
                 end
 
-                return command_line_selection, source_packages, osdep_packages
+                [command_line_selection, source_packages, osdep_packages]
             end
 
             def finish_loading_configuration(selected_packages)
@@ -167,21 +170,22 @@ module Autoproj
                 # overrides.rb files might have changed it
                 ws.finalize_package_setup
                 # Finally, filter out exclusions
-                resolved_selected_packages, _ =
+                resolved_selected_packages, =
                     resolve_user_selection(selected_packages)
                 validate_user_selection(selected_packages, resolved_selected_packages)
 
-                if !selected_packages.empty?
-                    command_line_selection = resolved_selected_packages.dup
-                else
+                if selected_packages.empty?
                     command_line_selection = Array.new
+                else
+                    command_line_selection = resolved_selected_packages.dup
                 end
-                return command_line_selection, resolved_selected_packages
+                [command_line_selection, resolved_selected_packages]
             end
 
             def normalize_osdeps_options(
                 checkout_only: false, osdeps: true, osdeps_mode: nil,
-                osdeps_filter_uptodate: true)
+                osdeps_filter_uptodate: true
+            )
 
                 osdeps_options = Hash[install_only: checkout_only]
                 if osdeps_mode
@@ -193,20 +197,68 @@ module Autoproj
                 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::Promises.future_on(@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,
-                report: true)
+                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, report_path: (ws.import_report_path if report))
+                    ws, report_path: (ws.import_report_path if report)
+                )
                 source_packages, osdep_packages =
-                        ops.import_packages(selected_packages,
+                    ops.import_packages(selected_packages,
                                         checkout_only: checkout_only,
                                         only_local: only_local,
                                         reset: reset,
@@ -215,21 +267,23 @@ module Autoproj
                                         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)
                 manifest.each_autobuild_package do |pkg|
                     if pkg.importer.respond_to?(:pick_from_autoproj_root)
-                        if !pkg.importer.pick_from_autoproj_root(pkg, other_root)
+                        unless pkg.importer.pick_from_autoproj_root(pkg, other_root)
                             pkg.update = false
                         end
                     else
@@ -240,4 +294,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/cli/utility.rb

@@ -1,4 +1,4 @@
-require 'autoproj/cli/inspection_tool'
+require "autoproj/cli/inspection_tool"
 
 module Autoproj
     module CLI
@@ -10,6 +10,7 @@ module Autoproj
             end
 
             attr_reader :utility_name
+
             def default(enabled)
                 ws.load_config
                 ws.config.utility_default(utility_name, enabled)
@@ -68,9 +69,9 @@ module Autoproj
                 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')
+                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))
+                    puts(format(out_format, name, (!!enabled).to_s, (!!available).to_s)) # rubocop:disable Style/DoubleNegation
                 end
             end
 
@@ -87,7 +88,7 @@ module Autoproj
                 validate_user_selection(user_selection, resolved_selection)
                 if package_names.empty?
                     raise CLIInvalidArguments, "autoproj: the provided package "\
-                        "is not selected for build"
+                                               "is not selected for build"
                 end
                 return if package_names.empty?
 
@@ -113,22 +114,23 @@ module Autoproj
                 ) 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?,
+                    "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

data/lib/autoproj/cli/version.rb

@@ -1,52 +1,54 @@
-require 'autoproj/cli/base'
-require 'rubygems'
+require "autoproj/cli/base"
+require "rubygems"
 
 module Autoproj
-module CLI
-    class Version < Base
-        # List the version of autoproj and optionally include
-        # the installed dependencies with information about the requirement
-        # and the actual used version
-        def run(args, options = Hash.new)
-            puts "autoproj version: #{Autoproj::VERSION}"
-            return unless options[:deps]
+    module CLI
+        class Version < Base
+            # List the version of autoproj and optionally include
+            # the installed dependencies with information about the requirement
+            # and the actual used version
+            def run(args, options = Hash.new)
+                puts "autoproj version: #{Autoproj::VERSION}"
+                return unless options[:deps]
 
-            dependency = Gem::Deprecate.skip_during do
-                Gem::Dependency.new "autoproj", Autoproj::VERSION
-            end
-            autoproj_spec = dependency.matching_specs
-            return if autoproj_spec.empty?
+                dependency = Gem::Deprecate.skip_during do
+                    Gem::Dependency.new "autoproj", Autoproj::VERSION
+                end
+                autoproj_spec = dependency.matching_specs
+                return if autoproj_spec.empty?
 
-            installed_deps = collect_dependencies(dependency)
-            puts "    specified dependencies:"
-            autoproj_spec.first.dependencies.each do |dep|
-                puts "        #{dep}: #{installed_deps[dep.name] || 'n/a'}"
-                installed_deps.delete(dep.name)
-            end
-            puts "    implicit dependencies:"
-            installed_deps.keys.sort.each do |name|
-                puts "        #{name}: #{installed_deps[name]}" unless name == "autoproj"
+                installed_deps = collect_dependencies(dependency)
+                puts "    specified dependencies:"
+                autoproj_spec.first.dependencies.each do |dep|
+                    puts "        #{dep}: #{installed_deps[dep.name] || 'n/a'}"
+                    installed_deps.delete(dep.name)
+                end
+                puts "    implicit dependencies:"
+                installed_deps.keys.sort.each do |name|
+                    unless name == "autoproj"
+                        puts "        #{name}: #{installed_deps[name]}"
+                    end
+                end
             end
-        end
 
-        # Collect the dependencies of a given dependency
-        # @param [Gem::Dependency] dependency a gem depencency
-        # @param [Array<Gem::Dependency] list of already known dependencies
-        #
-        # @return [Array<Gem::Dependency>] all known dependencies
-        def collect_dependencies(dependency, known_dependencies: {})
-            dep_spec = dependency.matching_specs
-            return known_dependencies if dep_spec.empty?
+            # Collect the dependencies of a given dependency
+            # @param [Gem::Dependency] dependency a gem depencency
+            # @param [Array<Gem::Dependency] list of already known dependencies
+            #
+            # @return [Array<Gem::Dependency>] all known dependencies
+            def collect_dependencies(dependency, known_dependencies: {})
+                dep_spec = dependency.matching_specs
+                return known_dependencies if dep_spec.empty?
 
-            dep_spec = dep_spec.first
-            known_dependencies[dep_spec.name] = dep_spec.version
-            dep_spec.dependencies.each do |dep|
-                if !known_dependencies.has_key?(dep.name)
-                    collect_dependencies(dep, known_dependencies: known_dependencies)
+                dep_spec = dep_spec.first
+                known_dependencies[dep_spec.name] = dep_spec.version
+                dep_spec.dependencies.each do |dep|
+                    unless known_dependencies.has_key?(dep.name)
+                        collect_dependencies(dep, known_dependencies: known_dependencies)
+                    end
                 end
+                known_dependencies
             end
-            known_dependencies
         end
     end
 end
-end

data/lib/autoproj/cli/versions.rb

@@ -1,7 +1,7 @@
-require 'autoproj'
-require 'autoproj/cli/inspection_tool'
-require 'autoproj/ops/tools'
-require 'autoproj/ops/snapshot'
+require "autoproj"
+require "autoproj/cli/inspection_tool"
+require "autoproj/ops/tools"
+require "autoproj/ops/snapshot"
 
 module Autoproj
     module CLI
@@ -9,22 +9,22 @@ module Autoproj
             DEFAULT_VERSIONS_FILE_BASENAME = Ops::Snapshot::DEFAULT_VERSIONS_FILE_BASENAME
 
             def default_versions_file
-                File.join( ws.overrides_dir, DEFAULT_VERSIONS_FILE_BASENAME )
+                File.join(ws.overrides_dir, DEFAULT_VERSIONS_FILE_BASENAME)
             end
 
             def validate_options(packages, options = Hash.new)
                 packages, options = super
-                if !options[:save].nil?
+                unless options[:save].nil?
                     options[:save] = case options[:save]
-                                     when '.'
+                                     when "."
                                          nil
-                                     when 'save'
+                                     when "save"
                                          default_versions_file
                                      else
                                          options[:save].to_str
                                      end
                 end
-                return packages, options
+                [packages, options]
             end
 
             def run(user_selection, options)
@@ -51,13 +51,13 @@ module Autoproj
                     versions += ops.snapshot_package_sets(nil, only_local: options[:only_local])
                 end
                 if snapshot_packages
-                    versions += ops.snapshot_packages(packages, 
-                        nil, 
-                        only_local: options[:only_local],
-                        fingerprint: options[:fingerprint])
+                    versions += ops.snapshot_packages(packages,
+                                                      nil,
+                                                      only_local: options[:only_local],
+                                                      fingerprint: options[:fingerprint])
                 end
 
-                if output_file = options[:save]
+                if (output_file = options[:save])
                     ops.save_versions(versions, output_file, replace: options[:replace])
                 else
                     versions = ops.sort_versions(versions)
@@ -67,4 +67,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/cli/watch.rb

@@ -1,6 +1,6 @@
-require 'rbconfig'
-require 'autoproj/cli/inspection_tool'
-require 'autoproj/ops/watch'
+require "rbconfig"
+require "autoproj/cli/inspection_tool"
+require "autoproj/ops/watch"
 module Autoproj
     module CLI
         class Watch < InspectionTool
@@ -13,7 +13,7 @@ module Autoproj
 
             def validate_options(unused, options = {})
                 _, options = super(unused, options)
-                @show_events   = options[:show_events]
+                @show_events = options[:show_events]
                 nil
             end
 
@@ -24,13 +24,11 @@ module Autoproj
             def update_workspace
                 initialize_and_load
 
-                source_packages, _ = finalize_setup([])
+                source_packages, = finalize_setup([])
                 @source_packages_dirs = source_packages.map do |pkg_name|
                     ws.manifest.find_autobuild_package(pkg_name).srcdir
                 end
-                @pkg_sets_dirs = ws.manifest.each_package_set.map do |pkg_set|
-                    pkg_set.raw_local_dir
-                end
+                @pkg_sets_dirs = ws.manifest.each_package_set.map(&:raw_local_dir)
                 export_env_sh(shell_helpers: ws.config.shell_helpers?)
             end
 
@@ -44,10 +42,10 @@ module Autoproj
                 @source_packages_dirs = []
                 @package_sets = []
 
-                @source_packages_dirs = installation_manifest.each_package.
-                    map(&:srcdir)
-                @package_sets = installation_manifest.each_package_set.
-                    map(&:raw_local_dir)
+                @source_packages_dirs = installation_manifest.each_package
+                                                             .map(&:srcdir)
+                @package_sets = installation_manifest.each_package_set
+                                                     .map(&:raw_local_dir)
             end
 
             def callback
@@ -66,11 +64,10 @@ module Autoproj
                 notifier.watch(dir, :move, :create, :delete, :modify, :dont_follow, *inotify_flags) do |e|
                     file_name = e.absolute_name[strip_dir_range]
                     included = included_paths.empty? ||
-                        included_paths.any? { |rx| rx === file_name }
-                    if included
-                        included = !excluded_paths.any? { |rx| rx === file_name }
-                    end
-                    next if !included
+                               included_paths.any? { |rx| rx === file_name }
+                    included = !excluded_paths.any? { |rx| rx === file_name } if included
+                    next unless included
+
                     Autobuild.message "#{e.absolute_name} changed" if show_events?
                     callback
                 end
@@ -79,12 +76,15 @@ module Autoproj
             def create_src_pkg_watchers
                 @source_packages_dirs.each do |pkg_srcdir|
                     next unless File.exist? pkg_srcdir
+
                     create_dir_watcher(pkg_srcdir, included_paths: ["manifest.xml", "package.xml"])
 
-                    manifest_file = File.join(pkg_srcdir, 'manifest.xml')
+                    manifest_file = File.join(pkg_srcdir, "manifest.xml")
                     create_file_watcher(manifest_file) if File.exist? manifest_file
-                    ros_manifest_file = File.join(pkg_srcdir, 'package.xml')
-                    create_file_watcher(ros_manifest_file) if File.exist? ros_manifest_file
+                    ros_manifest_file = File.join(pkg_srcdir, "package.xml")
+                    if File.exist? ros_manifest_file
+                        create_file_watcher(ros_manifest_file)
+                    end
                 end
             end
 
@@ -92,12 +92,12 @@ module Autoproj
                 create_file_watcher(ws.config.path)
                 create_src_pkg_watchers
                 create_dir_watcher(ws.config_dir,
-                    excluded_paths: [/(^|#{File::SEPARATOR})\./],
-                    inotify_flags: [:recursive])
+                                   excluded_paths: [/(^|#{File::SEPARATOR})\./],
+                                   inotify_flags: [:recursive])
                 FileUtils.mkdir_p ws.remotes_dir
                 create_dir_watcher(ws.remotes_dir,
-                    excluded_paths: [/(^|#{File::SEPARATOR})\./],
-                    inotify_flags: [:recursive])
+                                   excluded_paths: [/(^|#{File::SEPARATOR})\./],
+                                   inotify_flags: [:recursive])
             end
 
             def cleanup_notifier
@@ -106,33 +106,29 @@ module Autoproj
             end
 
             def assert_watchers_available
-                return if RbConfig::CONFIG['target_os'] =~ /linux/
+                return if RbConfig::CONFIG["target_os"] =~ /linux/
 
-                puts 'error: Workspace watching not available on this platform'
+                puts "error: Workspace watching not available on this platform"
                 exit 1
             end
 
             def setup_notifier
                 assert_watchers_available
 
-                require 'rb-inotify'
+                require "rb-inotify"
                 @notifier = INotify::Notifier.new
             end
 
             def cleanup
-                if @marker_io
-                    Ops.watch_cleanup_marker(@marker_io)
-                end
-                if @notifier
-                    cleanup_notifier
-                end
+                Ops.watch_cleanup_marker(@marker_io) if @marker_io
+                cleanup_notifier if @notifier
             end
 
             def restart
                 cleanup
                 args = []
                 args << "--show-events" if show_events?
-                exec($PROGRAM_NAME, 'watch', *args)
+                exec($PROGRAM_NAME, "watch", *args)
             end
 
             def run(**)
@@ -146,13 +142,13 @@ module Autoproj
                 setup_notifier
                 start_watchers
 
-                puts 'Watching workspace, press ^C to quit...'
+                puts "Watching workspace, press ^C to quit..."
                 notifier.run
 
-                puts 'Workspace changed...'
+                puts "Workspace changed..."
                 restart
             rescue Interrupt
-                puts 'Exiting...'
+                puts "Exiting..."
             ensure
                 cleanup
             end