autoproj 2.0.3 → 2.1.0.rc1

data/lib/autoproj/cli/base.rb

@@ -14,6 +14,7 @@ class Base
 
             def initialize(ws = Workspace.default)
                 @ws = ws
+                @env_sh_updated = nil
             end
 
             # Normalizes the arguments given by the user on the command line
@@ -192,6 +193,20 @@ def self.validate_options(args, options)
 
                 return args, remaining.to_sym_keys
             end
+
+            def export_env_sh(shell_helpers: ws.config.shell_helpers?)
+                @env_sh_updated = ws.export_env_sh(shell_helpers: shell_helpers)
+            end
+
+            def notify_env_sh_updated
+                return if @env_sh_updated.nil?
+
+                if @env_sh_updated
+                    Autoproj.message "  updated: #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
+                else
+                    Autoproj.message "  left unchanged: #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
+                end
+            end
         end
     end
 end

data/lib/autoproj/cli/bootstrap.rb

@@ -80,6 +80,9 @@ def run(buildconf_info, options)
                     raise
                 end
             end
+
+            def notify_env_sh_updated
+            end
         end
     end
 end

data/lib/autoproj/cli/build.rb

@@ -8,6 +8,10 @@ def validate_options(selected_packages, options)
                 selected_packages, options =
                     super(selected_packages, options.merge(
                         checkout_only: true, aup: options[:amake]))
+
+                if options[:no_deps_shortcut]
+                    options[:deps] = false
+                end
                 if options[:deps].nil?
                     options[:deps] = 
                         !(options[:rebuild] || options[:force])
@@ -70,6 +74,8 @@ def run(selected_packages, options)
                 Autobuild.do_build = true
                 ops.build_packages(source_packages, parallel: parallel)
                 Autobuild.apply(source_packages, "autoproj-build", ['install'])
+            ensure
+                export_env_sh
             end
         end
     end

data/lib/autoproj/cli/clean.rb

@@ -1,4 +1,5 @@
 require 'autoproj/cli/inspection_tool'
+require 'tty/prompt'
 
 module Autoproj
     module CLI
@@ -6,8 +7,8 @@ class Clean < InspectionTool
             def validate_options(packages, options)
                 packages, options = super
                 if packages.empty? && !options[:all]
-                    opt = BuildOption.new("", "boolean", {:doc => "this is going to clean all packages. Is that really what you want ?"}, nil)
-                    if !opt.ask(false)
+                    prompt = TTY::Prompt.new
+                    if !prompt.yes?("this is going to clean all packages. Is that really what you want ?")
                         raise Interrupt
                     end
                 end
@@ -17,10 +18,17 @@ def validate_options(packages, options)
             def run(selection, options = Hash.new)
                 initialize_and_load
                 packages, _ = normalize_command_line_package_selection(selection)
+
+                deps = if options.has_key?(:deps)
+                           options[:deps]
+                       else
+                           selection.empty?
+                       end
+
                 source_packages, * = resolve_selection(
-                    selection,
-                    recursive: false)
-                if packages.empty?
+                    packages,
+                    recursive: deps)
+                if source_packages.empty?
                     raise ArgumentError, "no packages or OS packages match #{selection.join(" ")}"
                 end
 

data/lib/autoproj/cli/doc.rb

@@ -3,6 +3,14 @@
 module Autoproj
     module CLI
         class Doc < InspectionTool
+            def validate_options(packages, options)
+                packages, options = super
+                if options[:no_deps_shortcut]
+                    options[:deps] = false
+                end
+                return packages, options
+            end
+
             def run(user_selection, deps: true)
                 initialize_and_load
                 packages, _ =

data/lib/autoproj/cli/envsh.rb

@@ -7,13 +7,11 @@ def validate_options(_unused, options = Hash.new)
                 options
             end
 
-            def run(options = Hash.new)
+            def run(**options)
                 initialize_and_load
+                shell_helpers = options.fetch(:shell_helpers, ws.config.shell_helpers?)
                 finalize_setup(Array.new)
-
-                options = Kernel.validate_options options,
-                    shell_helpers: ws.config.shell_helpers?
-                ws.export_env_sh(shell_helpers: options[:shell_helpers])
+                export_env_sh(shell_helpers: shell_helpers)
             end
         end
     end

data/lib/autoproj/cli/inspection_tool.rb

@@ -44,22 +44,6 @@ def finalize_setup(packages = [], non_imported_packages: :ignore, recursive: tru
                     return source_packages, osdep_packages, resolved_selection, config_selected
                 end
             end
-
-            def load_all_available_package_manifests
-                # Load the manifest for packages that are already present on the
-                # file system
-                ws.manifest.each_autobuild_package do |pkg|
-                    if pkg.checked_out?
-                        begin
-                            ws.manifest.load_package_manifest(pkg.name)
-                        rescue Interrupt
-                            raise
-                        rescue Exception => e
-                            Autoproj.warn "cannot load package manifest for #{pkg.name}: #{e.message}"
-                        end
-                    end
-                end
-            end
         end
     end
 end

data/lib/autoproj/cli/main.rb

@@ -11,21 +11,16 @@ def self.basic_setup
         end
 
         class Main < Thor
-            class_option :verbose, type: :boolean,
-                desc: 'turns verbose output',
-                default: false
-            class_option :debug, type: :boolean,
-                desc: 'turns debugging output',
-                default: false
-            class_option :silent, type: :boolean,
-                desc: 'tell autoproj to not display anything',
-                default: false
-            class_option :color, type: :boolean,
-                desc: 'enables or disables colored display (enabled by default if the terminal supports it)',
-                default: TTY::Color.color?
-            class_option :progress, type: :boolean,
-                desc: 'enables or disables progress display (enabled by default if the terminal supports it)',
-                default: TTY::Color.color?
+            class_option :verbose, type: :boolean, default: false,
+                desc: 'turns verbose output'
+            class_option :debug, type: :boolean, default: false,
+                desc: 'turns debugging output'
+            class_option :silent, type: :boolean, default: false,
+                desc: 'tell autoproj to not display anything'
+            class_option :color, type: :boolean, default: TTY::Color.color?,
+                desc: 'enables or disables colored display (enabled by default if the terminal supports it)'
+            class_option :progress, type: :boolean, default: TTY::Color.color?,
+                desc: 'enables or disables progress display (enabled by default if the terminal supports it)'
 
             no_commands do
                 def run_autoproj_cli(filename, classname, report_options, *args, **extra_options)
@@ -38,18 +33,20 @@ def run_autoproj_cli(filename, classname, report_options, *args, **extra_options
                             options[:only_local] = options.delete('local')
                         end
                         cli = CLI.const_get(classname).new
-                        run_args = cli.validate_options(args, options.merge(extra_options))
-                        cli.run(*run_args)
+                        begin
+                            run_args = cli.validate_options(args, options.merge(extra_options))
+                            cli.run(*run_args)
+                        ensure
+                            cli.notify_env_sh_updated
+                        end
                     end
                 end
             end
 
             desc 'bootstrap VCS_TYPE VCS_URL VCS_OPTIONS', 'bootstraps a new autoproj installation. This is usually not called directly, but called from the autoproj_bootstrap standalone script'
-            option :reuse,
-                banner: 'DIR',
+            option :reuse, banner: 'DIR',
                 desc: 'reuse packages already built within the DIR autoproj workspace in this installation, if DIR is not given, reuses the installation whose env.sh is currently sourced'
-            option :seed_config,
-                banner: 'SEED_CONFIG',
+            option :seed_config, banner: 'SEED_CONFIG',
                 desc: "a configuration file used to seed the bootstrap's configuration"
             def bootstrap(*args)
                 if !File.directory?(File.join(Dir.pwd, '.autoproj'))
@@ -76,16 +73,19 @@ def envsh
                 desc: "use the VCS information as 'versions --no-local' would detect it instead of the one in the configuration"
             option :parallel, aliases: :p, type: :numeric,
                 desc: 'maximum number of parallel jobs'
-            option :deps, type: :boolean,
-                desc: 'whether only the status of the given packages should be displayed, or of their dependencies as well',
-                default: true
+            option :deps, type: :boolean, default: true,
+                desc: 'whether only the status of the given packages should be displayed, or of their dependencies as well. -n is a shortcut for --no-deps'
+            option :no_deps_shortcut, hide: true, aliases: '-n', type: :boolean,
+                desc: 'provide -n for --no-deps'
             def status(*packages)
                 run_autoproj_cli(:status, :Status, Hash[], *packages)
             end
 
             desc 'doc [PACKAGES]', 'generate API documentation for packages that support it'
-            option :deps, desc: 'control whether documentation should be generated only for the packages given on the command line, or also for their dependencies',
-                type: :boolean, default: true
+            option :deps, type: :boolean, default: true,
+                desc: 'control whether documentation should be generated only for the packages given on the command line, or also for their dependencies. -n is a shortcut for --no-deps'
+            option :no_deps_shortcut, hide: true, aliases: '-n', type: :boolean,
+                desc: 'provide -n for --no-deps'
             def doc(*packages)
                 run_autoproj_cli(:doc, :Doc, Hash[], *packages)
             end
@@ -95,15 +95,15 @@ def doc(*packages)
                 desc: 'behave like aup'
             option :all, default: false, hide: true, type: :boolean,
                 desc: 'when in aup mode, update all packages instead of only the local one'
-            option :keep_going, aliases: :k, type: :boolean,
-                banner: '',
+            option :keep_going, aliases: :k, type: :boolean, banner: '',
                 desc: 'do not stop on build or checkout errors'
             option :config, type: :boolean,
                 desc: "(do not) update configuration. The default is to update configuration if explicitely selected or if no additional arguments are given on the command line, and to not do it if packages are explicitely selected on the command line"
+            option :bundler, type: :boolean,
+                desc: "(do not) update bundler. This is automatically enabled only if no arguments are given on the command line"
             option :autoproj, type: :boolean,
                 desc: "(do not) update autoproj. This is automatically enabled only if no arguments are given on the command line"
-            option :osdeps, type: :boolean,
-                default: true,
+            option :osdeps, type: :boolean, default: true,
                 desc: "enable or disable osdeps handling"
             option :from, type: :string,
                 desc: 'use this existing autoproj installation to check out the packages (for importers that support this)'
@@ -114,7 +114,9 @@ def doc(*packages)
             option :osdeps_filter_uptodate, default: true, type: :boolean,
                 desc: 'controls whether the osdeps subsystem should filter up-to-date packages or not'
             option :deps, default: true, type: :boolean,
-                desc: 'whether the package dependencies should be recursively updated (the default) or not'
+                desc: 'whether the package dependencies should be recursively updated (the default) or not. -n is a shortcut for --no-deps'
+            option :no_deps_shortcut, hide: true, aliases: '-n', type: :boolean,
+                desc: 'provide -n for --no-deps'
             option :reset, default: false, type: :boolean,
                 desc: "forcefully resets the repository to the state expected by autoproj's configuration",
                 long_desc: "The default is to update the repository if possible, and leave it alone otherwise. With --reset, autoproj update might come back to an older commit than the repository's current state"
@@ -144,9 +146,18 @@ def update(*packages)
             option :osdeps, type: :boolean,
                 desc: 'controls whether missing osdeps should be installed. In rebuild mode, also controls whether the osdeps should be reinstalled or not (the default is to reinstall them)' 
             option :deps, type: :boolean,
-                desc: 'in force or rebuild modes, control whether the force/rebuild action should apply only on the packages given on the command line, or on their dependencies as well (the default is --no-deps)'
+                desc: "controls whether the operation should apply to the package's dependencies as well. -n is a shortcut for --no-deps",
+                long_desc: <<-EOD
+Without --force or --rebuild, the default is true (the build will apply to all packages).
+With --force or --rebuild, control whether the force/rebuild action should apply
+only on the packages given on the command line, or on their dependencies as well.
+In this case, the default is false
+                EOD
+            option :no_deps_shortcut, hide: true, aliases: '-n', type: :boolean,
+                desc: 'provide -n for --no-deps'
             option :parallel, aliases: :p, type: :numeric,
                 desc: 'maximum number of parallel jobs'
+
             def build(*packages)
                 run_autoproj_cli(:build, :Build, Hash[silent: false], *packages)
             end
@@ -161,7 +172,22 @@ def cache(*cache_dir)
             end
 
             desc 'clean [PACKAGES]', 'remove build byproducts for the given packages'
-            option :all,
+            long_desc <<-EODESC
+                Remove build byproducts from disk
+
+                To avoid mistakes, 'clean' will ask for confirmation if no packages
+                are provided on the command line. Use --all to bypass this check (e.g.
+                in automated scripts)
+
+                When packages are explicitely provided on the command line, autoproj
+                will by default not clean the package dependencies. However, when
+                no packages are provided on the command line, all the workspace
+                packages will be cleaned. Use --deps=f or --deps=t to override
+                these defaults.
+            EODESC
+            option :deps, type: :boolean,
+                desc: "clean the given packages as well as their dependencies"
+            option :all, type: :boolean,
                 desc: 'bypass the safety question when you mean to clean all packages'
             def clean(*packages)
                 run_autoproj_cli(:clean, :Clean, Hash[], *packages)
@@ -195,9 +221,10 @@ def reconfigure
                 desc: "compare to the given baseline. if 'true', the comparison will ignore any override, otherwise it will take into account overrides only up to the given package set"
             option :env, type: :boolean,
                 desc: "display the package's own environment", default: false
-            option :short, desc: 'display a package summary with one package line'
-            option :recursive, desc: 'display the package and their dependencies (the default is to only display selected packages)',
-                type: :boolean, default: false
+            option :short,
+                desc: 'display a package summary with one package line'
+            option :recursive, type: :boolean, default: false,
+                desc: 'display the package and their dependencies (the default is to only display selected packages)'
             def show(*packages)
                 run_autoproj_cli(:show, :Show, Hash[], *packages)
             end
@@ -210,9 +237,7 @@ def osdeps(*packages)
             end
 
             desc 'versions [PACKAGES]', 'generate a version file for the given packages, or all packages if none are given'
-            option :config, type: :boolean,
-                default: nil,
-                banner: '',
+            option :config, type: :boolean, default: nil, banner: '',
                 desc: "controls whether the package sets should be versioned as well",
                 long_desc: <<-EOD
 This is the default if no packages are given on the command line, or if the
@@ -223,22 +248,18 @@ def osdeps(*packages)
    autoproj versions autoproj/ # versions only the configuration
    autoproj versions autoproj a/package # versions the configuration and the specified package(s)
                 EOD
-            option :keep_going, aliases: :k, type: :boolean,
-                default: false,
-                banner: '',
+            option :keep_going, aliases: :k, type: :boolean, default: false, banner: '',
                 desc: 'do not stop if some package cannot be versioned'
-            option :replace, type: :boolean,
-                default: false,
+            option :replace, type: :boolean, default: false,
                 desc: 'in combination with --save, controls whether an existing file should be updated or replaced'
-            option :deps, type: :boolean,
-                default: false,
+            option :deps, type: :boolean, default: false,
                 desc: 'whether both packages and their dependencies should be versioned, or only the selected packages (the latter is the default)'
             option :local, type: :boolean, default: false,
                 desc: 'whether we should access the remote server to verify that the snapshotted state is present'
             option :save, type: :string,
                 desc: 'save to the given file instead of displaying it on the standard output'
             def versions(*packages)
-                run_autoproj_cli(:versions, :Versions, Hash[], *packages)
+                run_autoproj_cli(:versions, :Versions, Hash[], *packages, deps: true)
             end
 
             stop_on_unknown_option! :log
@@ -270,8 +291,7 @@ def reset(version_id)
 EOD
             option :package_sets, type: :boolean,
                 desc: 'commit the package set state as well (enabled by default)'
-            option :keep_going, aliases: :k, type: :boolean,
-                banner: '',
+            option :keep_going, aliases: :k, type: :boolean, banner: '',
                 desc: 'do not stop on build or checkout errors'
             option :message, aliases: :m, type: :string,
                 desc: 'the message to use for the new commit (the default is to mention the creation of the tag)'
@@ -290,13 +310,12 @@ def tag(tag_name = nil, *packages)
 EOD
             option :package_sets, type: :boolean,
                 desc: 'commit the package set state as well (enabled by default)'
-            option :keep_going, aliases: :k, type: :boolean,
-                banner: '',
+            option :keep_going, aliases: :k, type: :boolean, banner: '',
                 desc: 'do not stop on build or checkout errors'
             option :message, aliases: :m, type: :string,
                 desc: 'the message to use for the new commit (the default is to mention the creation of the tag)'
             def commit(*packages)
-                run_autoproj_cli(:commit, :Commit, Hash[], *packages)
+                run_autoproj_cli(:commit, :Commit, Hash[], *packages, deps: true)
             end
 
             desc 'switch-config VCS URL [OPTIONS]', 'switches the main build configuration'

data/lib/autoproj/cli/main_test.rb

@@ -50,6 +50,9 @@ def list(*packages)
             end
 
             desc 'exec [PACKAGES]', 'execute the tests for the given packages, or all if no packages are given on the command line'
+            option :keep_going, aliases: :k, type: :boolean,
+                banner: '',
+                desc: 'do not stop on build or checkout errors'
             option :deps, type: :boolean, default: false,
                 desc: 'controls whether to execute the tests of the dependencies of the packages given on the command line (the default is not)'
             option :fail, type: :boolean, default: true,
@@ -61,6 +64,7 @@ def exec(*packages)
                 report do
                     cli = Test.new
                     Autobuild.pass_test_errors = options[:fail]
+                    Autobuild.ignore_errors = options[:keep_going]
                     Autobuild::TestUtility.coverage_enabled = options[:coverage]
                     args = cli.validate_options(packages, deps: options[:deps])
                     cli.run(*args)

data/lib/autoproj/cli/osdeps.rb

@@ -3,19 +3,18 @@
 module Autoproj
     module CLI
         class OSDeps < InspectionTool
-            def run(user_selection, options = Hash.new)
+            def run(user_selection, update: true, **options)
                 initialize_and_load
                 _, osdep_packages, resolved_selection, _ =
                     finalize_setup(user_selection)
 
-                options = Kernel.validate_options options,
-                    update: true,
-                    shell_helpers: ws.config.shell_helpers?
+                shell_helpers = options.fetch(:shell_helpers, ws.config.shell_helpers?)
+
                 ws.install_os_packages(
                     osdep_packages,
                     run_package_managers_without_packages: true,
-                    install_only: !options[:update])
-                ws.export_env_sh(shell_helpers: options[:shell_helpers])
+                    install_only: !update)
+                export_env_sh(shell_helpers: shell_helpers)
             end
         end
     end

data/lib/autoproj/cli/show.rb

@@ -31,7 +31,7 @@ def run(user_selection, short: false, recursive: false, mainline: false, env: fa
                     Autoproj.error "no package set, packages or OS packages match #{user_selection.join(" ")}"
                     return
                 elsif !source_packages.empty? || !all_matching_osdeps.empty?
-                    load_all_available_package_manifests
+                    ws.load_all_available_package_manifests
                     revdeps = ws.manifest.compute_revdeps
                 end
 

data/lib/autoproj/cli/status.rb

@@ -1,10 +1,15 @@
 require 'autoproj/cli/inspection_tool'
+require 'tty-spinner'
 
 module Autoproj
     module CLI
         class Status < InspectionTool
             def validate_options(packages, options)
                 packages, options = super
+                options[:progress] = Autobuild.progress_display_enabled?
+                if options[:no_deps_shortcut]
+                    options[:deps] = false
+                end
                 if options[:deps].nil? && packages.empty?
                     options[:deps] = true
                 end
@@ -28,13 +33,21 @@ def run(user_selection, options = Hash.new)
 
                 if !options.has_key?(:parallel) && options[:only_local]
                     options[:parallel] = 1
+                else
+                    options[:parallel] ||= ws.config.parallel_import_level
                 end
 
                 if options[:config]
                     pkg_sets = ws.manifest.each_package_set.to_a
                     if !pkg_sets.empty?
                         Autoproj.message("autoproj: displaying status of configuration", :bold)
-                        display_status(pkg_sets, parallel: options[:parallel], snapshot: options[:snapshot], only_local: options[:only_local])
+                        display_status(
+                            pkg_sets,
+                            parallel: options[:parallel],
+                            snapshot: options[:snapshot],
+                            only_local: options[:only_local],
+                            progress: options[:progress])
+
                         STDERR.puts
                     end
                 end
@@ -43,7 +56,12 @@ def run(user_selection, options = Hash.new)
                 packages = packages.sort.map do |pkg_name|
                     ws.manifest.find_package_definition(pkg_name)
                 end
-                display_status(packages, parallel: options[:parallel], snapshot: options[:snapshot], only_local: options[:only_local])
+                display_status(
+                    packages,
+                    parallel: options[:parallel],
+                    snapshot: options[:snapshot],
+                    only_local: options[:only_local],
+                    progress: options[:progress])
             end
 
             def snapshot_overrides_vcs?(importer, vcs, snapshot)
@@ -132,34 +150,85 @@ def status_of_package(package_description, only_local: false, snapshot: false)
                 package_status
             end
 
-            StatusResult = Struct.new :uncommitted, :local, :remote
-            def display_status(packages, options = Hash.new)
+            def each_package_status(packages, parallel: ws.config.parallel_import_level, snapshot: false, only_local: false, progress: nil)
+                return enum_for(__method__) if !block_given?
+
                 result = StatusResult.new
 
-                parallel = options[:parallel] || ws.config.parallel_import_level
                 executor = Concurrent::FixedThreadPool.new(parallel, max_length: 0)
                 interactive, noninteractive = packages.partition do |pkg|
                     pkg.autobuild.importer && pkg.autobuild.importer.interactive?
                 end
                 noninteractive = noninteractive.map do |pkg|
                     future = Concurrent::Future.execute(executor: executor) do
-                        status_of_package(pkg, snapshot: options[:snapshot], only_local: options[:only_local])
+                        status_of_package(pkg, snapshot: snapshot, only_local: only_local)
                     end
                     [pkg, future]
                 end
 
-                sync_packages = ""
                 (noninteractive + interactive).each do |pkg, future|
                     if future 
+                        if progress
+                            wait_timeout = 1
+                            while true
+                                future.wait(wait_timeout)
+                                if future.complete?
+                                    break
+                                else
+                                    wait_timeout = 0.2
+                                    progress.call(pkg)
+                                end
+                            end
+                        end
+
                         if !(status = future.value)
                             raise future.reason
                         end
-                    else status = status_of_package(pkg, snapshot: options[:snapshot], only_local: options[:only_local])
+                    else status = status_of_package(pkg, snapshot: snapshot, only_local: only_local)
                     end
 
                     result.uncommitted ||= status.uncommitted
                     result.local       ||= status.local
                     result.remote      ||= status.remote
+                    yield(pkg, status)
+                end
+                result
+
+            rescue Interrupt
+                Autoproj.warn "Interrupted, waiting for pending jobs to finish"
+                raise
+            rescue Exception => e
+                Autoproj.error "internal error: #{e}, waiting for pending jobs to finish"
+                raise
+            ensure
+                executor.shutdown
+                executor.wait_for_termination
+            end
+
+            StatusResult = Struct.new :uncommitted, :local, :remote
+            def display_status(packages, parallel: ws.config.parallel_import_level, snapshot: false, only_local: false, progress: true)
+                sync_packages = ""
+                spinner = nil
+
+                if progress
+                    progress = lambda do |pkg|
+                        if !spinner
+                            if !sync_packages.empty?
+                                Autoproj.message("#{sync_packages}: #{Autoproj.color("local and remote are in sync", :green)}")
+                                sync_packages = ""
+                            end
+
+                            spinner = TTY::Spinner.new("[:spinner] #{pkg.name}", clear: true)
+                        end
+                        spinner.spin
+                    end
+                end
+
+                result = each_package_status(packages, parallel: parallel, progress: progress) do |pkg, status|
+                    if spinner
+                        spinner.stop
+                        spinner = nil
+                    end
 
                     pkg_name = pkg.name
                     if status.sync && status.msg.empty?
@@ -197,18 +266,7 @@ def display_status(packages, options = Hash.new)
                     Autoproj.message("#{sync_packages}: #{Autoproj.color("local and remote are in sync", :green)}")
                 end
                 return result
-
-            rescue Interrupt
-                Autoproj.warn "Interrupted, waiting for pending jobs to finish"
-                raise
-            rescue Exception => e
-                Autoproj.error "internal error: #{e}, waiting for pending jobs to finish"
-                raise
-            ensure
-                executor.shutdown
-                executor.wait_for_termination
             end
-
         end
     end
 end