autoproj 2.10.1 → 2.13.0

data/lib/autoproj/aruba_minitest.rb

@@ -25,6 +25,17 @@ def teardown
             super
         end
 
+        def generate_local_gemfile
+            path = expand_path("Gemfile.local")
+            File.open(path, 'w') do |io|
+                io.write <<~GEMFILE
+                source "https://rubygems.org"
+                gem "autoproj", path: "#{File.expand_path("../../", __dir__)}"
+                GEMFILE
+            end
+            path
+        end
+
         def run_command_and_stop(*args, fail_on_error: true, **kwargs)
             cmd = run_command(*args, **kwargs)
             cmd.stop
@@ -38,6 +49,10 @@ def run_command(*args, **kwargs)
             @aruba_api.run_command(*args, **kwargs)
         end
 
+        def cd(*args) # also defined by Rake
+            @aruba_api.cd(*args)
+        end
+
         def chmod(*args) # also defined by Rake
             @aruba_api.chmod(*args)
         end

data/lib/autoproj/autobuild_extensions/dsl.rb

@@ -35,24 +35,30 @@ def self.package_name_from_options(spec)
     # @deprecated use Autoproj.workspace.in_package_set or add a proper Loader
     #   object to your class
     def self.in_package_set(package_set, path, &block)
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use Autoproj.workspace.in_package_set instead"
+        )
         Autoproj.workspace.in_package_set(package_set, path, &block)
     end
 
     # @deprecated use Autoproj.workspace.current_file or add a proper Loader
     #   object to your class
     def self.current_file
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use AUtoproj.workspace.current_file instead"
+        )
         Autoproj.workspace.current_file
     end
 
     # @deprecated use Autoproj.workspace.current_package_set or add a proper
     #   Loader object to your class
     def self.current_package_set
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use Autoproj.workspace.current_package_set instead"
+        )
         Autoproj.workspace.current_package_set
     end
 
@@ -60,22 +66,27 @@ def self.current_package_set
     #   Beware that the return value changed from Autobuild::Package to
     #   Autoproj::PackageDefinition
     def self.define(package_type, spec, &block)
-        Autoproj.warn_deprecated __method__, "use Autoproj.workspace.define_package "\
+        Autoproj.warn_deprecated(
+            __method__, "use Autoproj.workspace.define_package "\
             "instead (and beware that the return value changed from "\
             "Autobuild::Package to Autoproj::PackageDefinition)"
+        )
         workspace.define_package(package_type, spec, block, *current_file).
             autobuild
     end
 
     def self.loaded_autobuild_files
-        Autoproj.warn_deprecated __method__,
-            "use Autoproj.workspace.loaded_autobuild_files"
+        Autoproj.warn_deprecated(
+            __method__, "use Autoproj.workspace.loaded_autobuild_files"
+        )
         Autoproj.workspace.loaded_autobuild_files
     end
 
     def self.import_autobuild_file(package_set, path)
-        Autoproj.warn_deprecated __method__,
+        Autoproj.warn_deprecated(
+            __method__,
             "use Autoproj.workspace.import_autobuild_file"
+        )
         Autoproj.workspace.import_autobuild_file(package_set, path)
     end
 
@@ -149,11 +160,13 @@ def ignore(*paths)
 
 # Adds a new setup block to an existing package
 def setup_package(package_name, workspace: Autoproj.workspace, &block)
-    raise ConfigError.new, "you must give a block to #setup_package" unless block
+    unless block
+        raise Autoproj::ConfigError.new, 'you must give a block to #setup_package'
+    end
 
     package_definition = workspace.manifest.find_package_definition(package_name)
     if !package_definition
-        raise ConfigError.new, "#{package_name} is not a known package"
+        raise Autoproj::ConfigError.new, "#{package_name} is not a known package"
     elsif package_definition.autobuild.kind_of?(Autobuild::DummyPackage)
         # Nothing to do!
     else
@@ -185,10 +198,24 @@ def import_package(name, workspace: Autoproj.workspace, &block)
 def python_package(name, workspace: Autoproj.workspace)
     package_common(:python, name, workspace: workspace) do |pkg|
         pkg.internal_dependency 'python'
+        pkg.post_import do
+            pkg.depends_on 'python-setuptools' if pkg.install_mode?
+        end
         yield(pkg) if block_given?
     end
 end
 
+def common_make_default_test_task(pkg)
+    unless pkg.test_utility.source_dir
+        test_dir = File.join(pkg.srcdir, 'test')
+        if File.directory?(test_dir)
+            pkg.test_utility.source_dir = File.join(pkg.builddir, 'test', 'results')
+        end
+    end
+
+    pkg.with_tests if pkg.test_utility.source_dir
+end
+
 def common_make_based_package_setup(pkg)
     unless pkg.has_doc? && pkg.doc_dir
         pkg.with_doc do
@@ -198,14 +225,11 @@ def common_make_based_package_setup(pkg)
     end
 
     unless pkg.test_utility.has_task?
-        unless pkg.test_utility.source_dir
-            test_dir = File.join(pkg.srcdir, 'test')
-            if File.directory?(test_dir)
-                pkg.test_utility.source_dir = File.join(pkg.builddir, 'test', 'results')
-            end
+        pkg.post_import do
+            common_make_default_test_task(pkg)
         end
-
-        pkg.with_tests if pkg.test_utility.source_dir
+        # BACKWARD COMPATIBILITY ONLY. REMOVE FOR AUTOPROJ 3.0
+        common_make_default_test_task(pkg)
     end
 end
 
@@ -264,6 +288,18 @@ def env_add(name, value)
     Autoproj.env.add(name, value)
 end
 
+def ruby_package_default_test_task(pkg)
+    unless pkg.test_utility.source_dir
+        test_dir = File.join(pkg.srcdir, 'test')
+        if File.directory?(test_dir)
+            pkg.test_utility.source_dir = File.join(pkg.srcdir, '.test-results')
+            FileUtils.mkdir_p pkg.test_utility.source_dir
+        end
+    end
+
+    pkg.with_tests if pkg.test_utility.source_dir
+end
+
 # Defines a Ruby package
 #
 # Example:
@@ -284,15 +320,11 @@ def ruby_package(name, workspace: Autoproj.workspace)
         pkg.with_doc if !pkg.has_doc? && pkg.rake_doc_task
 
         unless pkg.test_utility.has_task?
-            unless pkg.test_utility.source_dir
-                test_dir = File.join(pkg.srcdir, 'test')
-                if File.directory?(test_dir)
-                    pkg.test_utility.source_dir = File.join(pkg.srcdir, '.test-results')
-                    FileUtils.mkdir_p pkg.test_utility.source_dir
-                end
+            pkg.post_import do
+                ruby_package_default_test_task(pkg)
             end
-
-            pkg.with_tests if pkg.test_utility.source_dir
+            # BACKWARD COMPATIBILITY ONLY. REMOVE FOR AUTOPROJ 3.0
+            ruby_package_default_test_task(pkg)
         end
 
         yield(pkg) if block_given?
@@ -389,9 +421,9 @@ def source_package(options, workspace: Autoproj.workspace)
 end
 
 # @deprecated use Autoproj.config.declare instead
-def configuration_option(*opts, &block)
+def configuration_option(*opts, **kw, &block)
     Autoproj.warn_deprecated __method__, "use Autoproj.config.declare instead"
-    Autoproj.config.declare(*opts, &block)
+    Autoproj.config.declare(*opts, **kw, &block)
 end
 
 # @deprecated use Autoproj.config.get instead
@@ -469,11 +501,13 @@ def renamed_package(current_name, old_name, options)
         explicitely_selected_in_layout?(old_name)
     if options[:obsolete] && !explicit_selection
         import_package old_name
-        Autoproj.workspace.manifest.exclude_package old_name,
+        Autoproj.workspace.manifest.exclude_package(
+            old_name,
             "#{old_name} has been renamed to #{current_name}, you still have "\
             "the option of using the old name by adding '- #{old_name}' explicitely "\
             "in the layout in autoproj/manifest, but be warned that the name will "\
             "stop being usable at all in the near future"
+        )
     else
         metapackage old_name, current_name
     end

data/lib/autoproj/base.rb

@@ -6,12 +6,11 @@ module Autoproj
         else
             ArgumentError
         end
-            
+
     # Yields, and if the given block raises a ConfigError with no file assigned,
     # add that file to both the object and the exception message
     def self.in_file(file, exception_t = ConfigError)
         yield
-
     rescue exception_t => e
         if exception_t != ConfigError
             raise ConfigError.new(file), "in #{file}: #{e.message}", e.backtrace
@@ -28,21 +27,51 @@ class << self
         attr_reader :post_import_blocks
     end
 
+    # Enumerate the post-import blocks registered for the given package
+    #
+    # @param [PackageDefinition] pkg
+    # @see post_import
     def self.each_post_import_block(pkg, &block)
+        # We use Autobuild packages as keys
+        pkg = pkg.autobuild if pkg.respond_to?(:autobuild)
+
         @post_import_blocks[nil].each(&block)
-        if @post_import_blocks.has_key?(pkg)
-            @post_import_blocks[pkg].each(&block)
-        end
+        @post_import_blocks[pkg]&.each(&block)
     end
 
+    # Register a block that should be called after a set of package(s) have
+    # been imported
+    #
+    # @overload post_import(&block) register the block for all packages
+    # @overload post_import(*packages, &block)
+    #   @param [Array<Autobuild::Package,PackageDefinition>] packages
     def self.post_import(*packages, &block)
         if packages.empty?
             @post_import_blocks[nil] << block
         else
             packages.each do |pkg|
+                # We use Autobuild packages as keys
+                pkg = pkg.autobuild if pkg.respond_to?(:autobuild)
                 @post_import_blocks[pkg] << block
             end
         end
     end
-end
 
+    # Shim for a smooth upgrade path to bundler 2.1+
+    def self.bundler_unbundled_system(*args, **options)
+        if Bundler.respond_to?(:unbundled_system)
+            Bundler.unbundled_system(*args, **options)
+        else
+            Bundler.clean_system(*args, **options)
+        end
+    end
+
+    # Shim for a smooth upgrade path to bundler 2.1+
+    def self.bundler_with_unbundled_env(&block)
+        if Bundler.respond_to?(:with_unbundled_env)
+            Bundler.with_unbundled_env(&block)
+        else
+            Bundler.with_clean_env(&block)
+        end
+    end
+end

data/lib/autoproj/cli/base.rb

@@ -151,7 +151,7 @@ def resolve_selection(user_selection, checkout_only: true, only_local: false, re
                     non_imported_packages: non_imported_packages,
                     auto_exclude: auto_exclude)
 
-                return source_packages, osdep_packages, resolved_selection
+                [source_packages, osdep_packages, resolved_selection]
             rescue ExcludedSelection => e
                 raise CLIInvalidSelection, e.message, e.backtrace
             end

data/lib/autoproj/cli/build.rb

@@ -18,17 +18,20 @@ def validate_options(selected_packages, options)
             end
 
             def run(selected_packages, **options)
-                build_options, options = filter_options options,
+                build_options, options = filter_options(
+                    options,
                     force: false,
                     rebuild: false,
                     parallel: nil,
                     confirm: true,
                     not: Array.new
+                )
 
                 command_line_selection, source_packages, _osdep_packages =
                     super(selected_packages,
                           ignore_errors: options[:keep_going],
                           checkout_only: true,
+                          report: false,
                           **options)
 
                 parallel = build_options[:parallel] || ws.config.parallel_build_level
@@ -40,6 +43,7 @@ def run(selected_packages, **options)
                 # Disable all packages that are not selected
                 ws.manifest.each_autobuild_package do |pkg|
                     next if active_packages.include?(pkg.name)
+
                     pkg.disable
                 end
 
@@ -60,11 +64,13 @@ def run(selected_packages, **options)
                                     else 'force-build'
                                     end
                         if build_options[:confirm] != false
-                            opt = BuildOption.new("", "boolean",
+                            opt = BuildOption.new(
+                                "", "boolean",
                                 {
                                     doc: "this is going to trigger a #{mode_name} "\
                                         "of all packages. Is that really what you want ?"
-                                }, nil)
+                                }, nil
+                            )
                             raise Interrupt unless opt.ask(false)
                         end
 

data/lib/autoproj/cli/cache.rb

@@ -1,32 +1,104 @@
+# frozen_string_literal: true
+
 require 'autoproj/cli/inspection_tool'
 require 'autoproj/ops/cache'
 
 module Autoproj
     module CLI
         class Cache < InspectionTool
+            def parse_gem_compile(string)
+                scanner = StringScanner.new(string)
+                name = scanner.scan(/[^\[]+/)
+
+                level = 0
+                artifacts = []
+                artifact_include = nil
+                artifact_name = ''.dup
+                until scanner.eos?
+                    c = scanner.getch
+                    if level == 0
+                        raise ArgumentError, "expected '[' but got '#{c}'" unless c == '['
+
+                        level = 1
+                        include_c = scanner.getch
+                        if %w[+ -].include?(include_c)
+                            artifact_include = (include_c == '+')
+                        elsif include_c == ']'
+                            raise ArgumentError, "empty [] found in '#{string}'"
+                        else
+                            raise ArgumentError,
+                                  "expected '+' or '-' but got '#{c}' in '#{string}'"
+                        end
+                        next
+                    end
+
+                    if c == ']'
+                        level -= 1
+                        if level == 0
+                            artifacts << [artifact_include, artifact_name]
+                            artifact_name = ''.dup
+                            next
+                        end
+                    end
+
+                    artifact_name << c
+                end
+
+                raise ArgumentError, "missing closing ']' in #{string}" if level != 0
+
+                [name, artifacts: artifacts]
+            end
+
             def validate_options(argv, options = Hash.new)
                 argv, options = super
 
                 if argv.empty?
                     default_cache_dirs = Autobuild::Importer.default_cache_dirs
                     if !default_cache_dirs || default_cache_dirs.empty?
-                        raise CLIInvalidArguments, "no cache directory defined with e.g. the AUTOBUILD_CACHE_DIR environment variable, expected one cache directory as argument"
+                        raise CLIInvalidArguments,
+                              "no cache directory defined with e.g. the "\
+                              "AUTOBUILD_CACHE_DIR environment variable, "\
+                              "expected one cache directory as argument"
                     end
-                    Autoproj.warn "using cache directory #{default_cache_dirs.first} from the autoproj configuration"
+                    Autoproj.warn "using cache directory #{default_cache_dirs.first} "\
+                                  "from the autoproj configuration"
                     argv << default_cache_dirs.first
                 end
 
-                return File.expand_path(argv.first, ws.root_dir), *argv[1..-1], options
+                if (compile = options[:gems_compile])
+                    options[:gems_compile] = compile.map do |name|
+                        parse_gem_compile(name)
+                    end
+                end
+
+                [File.expand_path(argv.first, ws.root_dir), *argv[1..-1], options]
             end
 
-            def run(cache_dir, *package_names, all: true, keep_going: false, checkout_only: false)
+            def run(cache_dir, *package_names,
+                    keep_going: false,
+                    packages: true, all: true, checkout_only: false,
+                    gems: false, gems_compile: [], gems_compile_force: false)
                 initialize_and_load
                 finalize_setup
 
-                cache_op = Autoproj::Ops::Cache.new(cache_dir, ws.manifest)
-                cache_op.create_or_update(*package_names, all: all, keep_going: keep_going, checkout_only: checkout_only)
+                cache_op = Autoproj::Ops::Cache.new(cache_dir, ws)
+                if packages
+                    cache_op.create_or_update(
+                        *package_names,
+                        all: all, keep_going: keep_going,
+                        checkout_only: checkout_only
+                    )
+                end
+
+                if gems
+                    Autoproj.message "caching gems in #{cache_op.gems_cache_dir}"
+                    cache_op.create_or_update_gems(
+                        keep_going: keep_going,
+                        compile: gems_compile,
+                        compile_force: gems_compile_force
+                    )
+                end
             end
         end
     end
 end
-