autoproj 2.9.0 → 2.10.0

data/lib/autoproj/cli/bootstrap.rb

@@ -32,16 +32,22 @@ def validate_options(args, options)
                 end
                 return args, options
             end
-            
-            def run(buildconf_info, options)
+
+            def run(buildconf_info, interactive: nil, **options)
                 ws = Workspace.new(root_dir)
+                ws.config.interactive = interactive unless interactive.nil?
                 ws.setup
 
                 seed_config = options.delete(:seed_config)
 
                 switcher = Ops::MainConfigSwitcher.new(ws)
+                check_root_dir_empty =
+                    ws.config.interactive? && switcher.check_root_dir_empty?
+
                 begin
-                    switcher.bootstrap(buildconf_info, options)
+                    switcher.bootstrap(buildconf_info,
+                        check_root_dir_empty: check_root_dir_empty,
+                        **options)
                     if seed_config
                         FileUtils.cp seed_config, File.join(ws.config_dir, 'config.yml')
                     end

data/lib/autoproj/cli/build.rb

@@ -9,22 +9,21 @@ def validate_options(selected_packages, options)
                     super(selected_packages, options.merge(
                         checkout_only: true, aup: options[:amake]))
 
-                if options[:no_deps_shortcut]
-                    options[:deps] = false
-                end
+                options[:deps] = false if options[:no_deps_shortcut]
                 if options[:deps].nil?
                     options[:deps] =
                         !(options[:rebuild] || options[:force])
                 end
-                return selected_packages, options
+                [selected_packages, options]
             end
 
-            def run(selected_packages, options)
+            def run(selected_packages, **options)
                 build_options, options = filter_options options,
                     force: false,
                     rebuild: false,
                     parallel: nil,
-                    confirm: true
+                    confirm: true,
+                    not: Array.new
 
                 command_line_selection, source_packages, _osdep_packages =
                     super(selected_packages,
@@ -36,15 +35,17 @@ def run(selected_packages, options)
 
                 return if source_packages.empty?
 
+                active_packages = source_packages - build_options[:not]
+
                 # Disable all packages that are not selected
                 ws.manifest.each_autobuild_package do |pkg|
-                    next if source_packages.include?(pkg.name)
+                    next if active_packages.include?(pkg.name)
                     pkg.disable
                 end
 
                 Autobuild.ignore_errors = options[:keep_going]
 
-                ops = Ops::Build.new(ws.manifest, report_dir: ws.log_dir)
+                ops = Ops::Build.new(ws.manifest, report_path: ws.build_report_path)
                 if build_options[:rebuild] || build_options[:force]
                     packages_to_rebuild =
                         if options[:deps] || command_line_selection.empty?
@@ -59,10 +60,12 @@ def run(selected_packages, options)
                                     else 'force-build'
                                     end
                         if build_options[:confirm] != false
-                            opt = BuildOption.new("", "boolean", {:doc => "this is going to trigger a #{mode_name} of all packages. Is that really what you want ?"}, nil)
-                            if !opt.ask(false)
-                                raise Interrupt
-                            end
+                            opt = BuildOption.new("", "boolean",
+                                {
+                                    doc: "this is going to trigger a #{mode_name} "\
+                                        "of all packages. Is that really what you want ?"
+                                }, nil)
+                            raise Interrupt unless opt.ask(false)
                         end
 
                         if build_options[:rebuild]
@@ -82,7 +85,8 @@ def run(selected_packages, options)
                 ops.build_packages(source_packages, parallel: parallel)
                 Main.run_post_command_hook(:build, ws, source_packages: source_packages)
             ensure
-                export_env_sh
+                # Update env.sh, but only if we managed to load the configuration
+                export_env_sh if source_packages
             end
         end
     end

data/lib/autoproj/cli/envsh.rb

@@ -4,7 +4,7 @@ module CLI
         class Envsh < InspectionTool
             def validate_options(_unused, options = Hash.new)
                 _, options = super(_unused, options)
-                options
+                [options]
             end
 
             def run(**options)

data/lib/autoproj/cli/exec.rb

@@ -8,7 +8,7 @@ module CLI
         class Exec
             def initialize
                 @root_dir = Autoproj.find_workspace_dir
-                if !@root_dir
+                unless @root_dir
                     require 'autoproj/workspace'
                     # Will do all sorts of error reporting,
                     # or may be able to resolve
@@ -18,18 +18,16 @@ def initialize
 
             def load_cached_env
                 env = Ops.load_cached_env(@root_dir)
-                return if !env
+                return unless env
 
                 Autobuild::Environment.
                     environment_from_export(env, ENV)
             end
 
             def run(cmd, *args, use_cached_env: Ops.watch_running?(@root_dir))
-                if use_cached_env
-                    env = load_cached_env
-                end
+                env = load_cached_env if use_cached_env
 
-                if !env
+                unless env
                     require 'autoproj'
                     require 'autoproj/cli/inspection_tool'
                     ws = Workspace.from_dir(@root_dir)
@@ -40,7 +38,7 @@ def run(cmd, *args, use_cached_env: Ops.watch_running?(@root_dir))
                 end
 
                 path = env['PATH'].split(File::PATH_SEPARATOR)
-                program = 
+                program =
                     begin Ops.which(cmd, path_entries: path)
                     rescue ::Exception => e
                         require 'autoproj'

data/lib/autoproj/cli/main.rb

@@ -30,10 +30,24 @@ class Main < Thor
                 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)'
+            class_option 'interactive', type: :boolean,
+                default: (ENV['AUTOPROJ_NONINTERACTIVE'] != '1'),
+                desc: 'tell autoproj to run (non)interactively'
 
             stop_on_unknown_option! :exec
             check_unknown_options!  except: :exec
 
+            class << self
+                # @api private
+                #
+                # Override the CLI logic to determine what should be done
+                # on package failure (between raising or exiting)
+                #
+                # This is used mainly in tests, to make sure that the CLI won't
+                # be calling exit(). Set to nil to restore the default behavior
+                attr_accessor :default_report_on_package_failures
+            end
+
             # @api private
             #
             # Run hooks defined for a given hook name
@@ -74,13 +88,28 @@ def self.register_post_command_hook(hook_name, &block)
 
             no_commands do
                 def default_report_on_package_failures
-                    if options[:debug]
+                    if (override = Main.default_report_on_package_failures)
+                        override
+                    elsif options[:debug]
                         :raise
                     else
                         :exit
                     end
                 end
 
+                # Generate a command line for Ops::Install, which has an
+                # internal option parser based on OptionParse (to be
+                # self-sufficient)
+                def thor_options_to_optparse
+                    flags = []
+                    %i[color progress debug interactive].each do |option|
+                        if options[option] then flags << "--#{option}"
+                        else flags << "--no-#{option}"
+                        end
+                    end
+                    flags
+                end
+
                 def run_autoproj_cli(filename, classname, report_options, *args, tool_failure_mode: :exit_silent, **extra_options)
                     require "autoproj/cli/#{filename}"
                     if Autobuild::Subprocess.transparent_mode = options[:tool]
@@ -118,9 +147,9 @@ def bootstrap(*args)
                 if !File.directory?(File.join(Dir.pwd, '.autoproj'))
                     require 'autoproj/ops/install'
                     ops = Autoproj::Ops::Install.new(Dir.pwd)
-                    ops.parse_options(args)
+                    bootstrap_options = ops.parse_options(thor_options_to_optparse + args)
                     ops.run
-                    exec Gem.ruby, $0, 'bootstrap', *args
+                    exec Gem.ruby, $0, 'bootstrap', *bootstrap_options
                 end
                 run_autoproj_cli(:bootstrap, :Bootstrap, Hash[], *args)
             end
@@ -243,6 +272,8 @@ def update(*packages)
                 desc: "act as a build tool, transparently passing the subcommand's outputs to STDOUT"
             option :confirm, type: :boolean, default: nil,
                 desc: '--force and --rebuild will ask confirmation if applied to the whole workspace. Use --no-confirm to disable this confirmation'
+            option :not, type: :array, default: nil,
+                desc: 'do not build the packages listed'
             def build(*packages)
                 report_options = Hash[silent: false, on_package_failures: default_report_on_package_failures]
                 if options[:auto_exclude]
@@ -351,6 +382,13 @@ def osdeps(*packages)
                 run_autoproj_cli(:osdeps, :OSDeps, Hash[silent: options[:system_info]], *packages)
             end
 
+            desc 'version', 'display the current version of autobuild and optionally with dependencies'
+            option :deps, type: :boolean, default: false, banner:'',
+                desc: "controls whether to list dependant gems as well"
+            def version(*args)
+                run_autoproj_cli(:version, :Version, Hash[], *args)
+            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: '',
                 desc: "controls whether the package sets should be versioned as well",
@@ -373,6 +411,8 @@ def osdeps(*packages)
                 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'
+            option :fingerprint, type: :boolean, default: false,
+                desc: 'calculate unique fingerprint for each package'
             def versions(*packages)
                 run_autoproj_cli(:versions, :Versions, Hash[], *packages, deps: true)
             end
@@ -500,12 +540,7 @@ def query(query_string = nil)
             def install_stage2(root_dir, *vars)
                 require 'autoproj/ops/install'
                 ops = Autoproj::Ops::Install.new(root_dir)
-                if options[:color] then ops.autoproj_options << "--color"
-                else ops.autoproj_options << "--no-color"
-                end
-                if options[:progress] then ops.autoproj_options << "--progress"
-                else ops.autoproj_options << "--no-progress"
-                end
+                ops.parse_options(thor_options_to_optparse)
                 ops.stage2(*vars)
             end
 

data/lib/autoproj/cli/main_test.rb

@@ -64,6 +64,8 @@ def list(*packages)
                 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 :parallel, aliases: :p, type: :numeric,
+                desc: 'maximum number of parallel jobs'
             option :fail, type: :boolean, default: true,
                 desc: 'return with a nonzero exit code if the test does not pass'
             option :coverage, type: :boolean, default: false,

data/lib/autoproj/cli/test.rb

@@ -46,7 +46,11 @@ def list(user_selection, options = {})
                 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?]
+                    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
@@ -57,14 +61,33 @@ def list(user_selection, options = {})
                 end
             end
 
-            def run(user_selection, deps: true)
+            def run(user_selection, options = {})
+                options[:parallel] ||= ws.config.parallel_build_level
                 initialize_and_load
-                packages, =
-                    finalize_setup(user_selection, recursive: user_selection.empty? || deps)
+
+                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')
+                    ws.manifest.find_autobuild_package(pkg).disable_phases(
+                        'import', 'prepare', 'install'
+                    )
                 end
-                Autobuild.apply(packages, 'autoproj-test', ['test'])
+
+                Autobuild.apply(
+                    packages,
+                    'autoproj-test',
+                    ['test'],
+                    parallel: options[:parallel]
+                )
             end
         end
     end

data/lib/autoproj/cli/version.rb

@@ -0,0 +1,52 @@
+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]
+
+            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"
+            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?
+
+            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)
+                end
+            end
+            known_dependencies
+        end
+    end
+end
+end

data/lib/autoproj/cli/versions.rb

@@ -51,7 +51,10 @@ def run(user_selection, options)
                     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])
+                    versions += ops.snapshot_packages(packages, 
+                        nil, 
+                        only_local: options[:only_local],
+                        fingerprint: options[:fingerprint])
                 end
 
                 if output_file = options[:save]

data/lib/autoproj/cli/watch.rb

@@ -51,7 +51,7 @@ def load_info_from_installation_manifest
             end
 
             def callback
-                notifier.stop
+                Thread.new { notifier.stop }
             end
 
             def create_file_watcher(file)
@@ -107,6 +107,7 @@ def cleanup_notifier
 
             def assert_watchers_available
                 return if RbConfig::CONFIG['target_os'] =~ /linux/
+
                 puts 'error: Workspace watching not available on this platform'
                 exit 1
             end

data/lib/autoproj/configuration.rb

@@ -22,6 +22,9 @@ class Configuration
         attr_reader :displayed_options
         # The path to the underlying configuration file
         attr_reader :path
+        # Whether the configuration should be performed interactively
+        # or not
+        attr_accessor :interactive
 
         def initialize(path = nil)
             @config = Hash.new
@@ -43,16 +46,24 @@ def reset_modified
             @modified = false
         end
 
-        # Deletes the current value for an option
+        # Deletes the current configuration for all options or the one specified
         #
-        # The user will be asked for a new value next time the option is needed
+        # The user will be asked for a new value next time one of the reset
+        # options is needed
         #
-        # @param [String] the option name
+        # @param [String] name the option name (or by default nil to reset all
+        #   options)
         # @return the deleted value
-        def reset(name)
-            @modified ||= config.has_key?(name)
-            config.delete(name)
-            overrides.delete(name)
+        def reset(name = nil)
+            if name
+                @modified ||= config.has_key?(name)
+                config.delete(name)
+                overrides.delete(name)
+            else
+                @config.clear
+                @overrides.clear
+                @modified = true
+            end
         end
 
         # Sets a configuration option
@@ -177,10 +188,18 @@ def configure(option_name)
                 if current_value = config[option_name]
                     current_value = current_value.first
                 end
-                value = opt.ask(current_value)
+                is_default = false
+                if interactive?
+                    value = opt.ask(current_value, nil)
+                else
+                    value, is_default = opt.ensure_value(current_value)
+                    Autoproj.info "       using: #{value} (noninteractive mode)"
+                end
                 @modified = true
-                config[option_name] = [value, true]
-                displayed_options[option_name] = value
+                if !is_default
+                    config[option_name] = [value, true]
+                    displayed_options[option_name] = value
+                end
                 value
             else
                 raise ConfigError.new, "undeclared option '#{option_name}'"
@@ -440,6 +459,21 @@ def randomize_layout=(value)
             set('randomize_layout', value, true)
         end
 
+        # Returns true if the configuration should be performed interactively
+        #
+        # @return [Boolean]
+        # @see interactive=
+        def interactive?
+            if !interactive.nil?
+                return interactive
+            elsif ENV['AUTOPROJ_NONINTERACTIVE'] == '1'
+                return false
+            elsif has_value_for?("interactive")
+                return get('interactive')
+            end
+            true
+        end
+
         DEFAULT_UTILITY_SETUP = Hash[
             'doc' => true,
             'test' => false]
@@ -545,7 +579,11 @@ def prefer_indep_over_os_packages?
         def to_hash
             result = Hash.new
             @config.each do |key, (value, _)|
-                result[key] = value
+                if declared_options.include?(key)
+                    result[key] = declared_options[key].ensure_value(value)
+                else
+                    result[key] = value
+                end
             end
             overrides.each do |key, value|
                 result[key] = value