autoproj 2.9.0 → 2.10.0

data/bin/autoproj_install.in

@@ -1,7 +1,7 @@
 #! /usr/bin/ruby
 
-if RUBY_VERSION < "2.1.0"
-    STDERR.puts "autoproj requires Ruby >= 2.1.0"
+if RUBY_VERSION < "2.3.0"
+    STDERR.puts "autoproj requires Ruby >= 2.3.0"
     exit 1
 elsif ENV['AUTOPROJ_CURRENT_ROOT'] && (ENV['AUTOPROJ_CURRENT_ROOT'] != Dir.pwd)
     STDERR.puts "it seems that you've already loaded an env.sh script in this console, open a new console and try again"

data/lib/autoproj/aruba_minitest.rb

@@ -25,8 +25,8 @@ def teardown
             super
         end
 
-        def run_command_and_stop(*args, fail_on_error: true)
-            cmd = run_command(*args)
+        def run_command_and_stop(*args, fail_on_error: true, **kwargs)
+            cmd = run_command(*args, **kwargs)
             cmd.stop
             if fail_on_error
                 assert_command_finished_successfully(cmd)
@@ -34,8 +34,8 @@ def run_command_and_stop(*args, fail_on_error: true)
             cmd
         end
 
-        def run_command(*args)
-            @aruba_api.run(*args)
+        def run_command(*args, **kwargs)
+            @aruba_api.run_command(*args, **kwargs)
         end
 
         def chmod(*args) # also defined by Rake

data/lib/autoproj/autobuild_extensions/dsl.rb

@@ -32,22 +32,27 @@ def self.package_name_from_options(spec)
         end
     end
 
-    # @deprecated use Autoproj.workspace.in_package_set or add a proper Loader object to your
-    #   class
+    # @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__, "use Autoproj.workspace.in_package_set instead"
+        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
+
+    # @deprecated use Autoproj.workspace.current_file or add a proper Loader
+    #   object to your class
     def self.current_file
-        Autoproj.warn_deprecated __method__, "use AUtoproj.workspace.current_file instead"
+        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
+
+    # @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__, "use Autoproj.workspace.current_package_set instead"
+        Autoproj.warn_deprecated __method__,
+            "use Autoproj.workspace.current_package_set instead"
         Autoproj.workspace.current_package_set
     end
 
@@ -55,18 +60,22 @@ 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 instead (and beware that the return value changed from Autobuild::Package to Autoproj::PackageDefinition)"
+        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__, "use Autoproj.workspace.import_autobuild_file"
+        Autoproj.warn_deprecated __method__,
+            "use Autoproj.workspace.import_autobuild_file"
         Autoproj.workspace.import_autobuild_file(package_set, path)
     end
 
@@ -75,14 +84,11 @@ def self.find_topmost_directory_containing(dir, glob_pattern = nil)
         while dir != "/"
             match = false
             if glob_pattern
-                if !Dir.glob(File.join(dir, glob_pattern)).empty?
-                    match = true
-                end
+                match = true unless Dir.glob(File.join(dir, glob_pattern)).empty?
             end
 
-            if !match && block_given? && yield(dir)
-                match = true
-            end
+            match = true if !match && block_given? && yield(dir)
+
             if !match && result
                 return result
             elsif match
@@ -95,29 +101,42 @@ def self.find_topmost_directory_containing(dir, glob_pattern = nil)
 
     # Tries to find a handler automatically for 'full_path'
     def self.package_handler_for(full_path)
+        pyglob = File.join(File.basename(full_path), "*.py")
         if !Dir.enum_for(:glob, File.join(full_path, "*.orogen")).to_a.empty?
-            return "orogen_package", full_path
+            ["orogen_package", full_path]
+        elsif File.file?(File.join(full_path, "Makefile.am"))
+            toplevel_dir = find_topmost_directory_containing(full_path) do |dir|
+                configure_ac = File.join(dir, 'configure.ac')
+                configure_in = File.join(dir, 'configure.in')
+                File.file?(configure_ac) || File.file?(configure_in)
+            end
+            ['autotools_package', toplevel_dir] if toplevel_dir
+        elsif File.file?(File.join(full_path, "configure.ac")) ||
+              File.file?(File.join(full_path, "configure.in"))
+            ['autotools_package', full_path]
         elsif File.file?(File.join(full_path, "CMakeLists.txt"))
             toplevel_dir = find_topmost_directory_containing(full_path) do |dir|
                 cmakelists = File.join(dir, 'CMakeLists.txt')
                 File.file?(cmakelists) &&
                     (File.read(cmakelists) =~ /PROJECT/i)
             end
-            toplevel_dir ||= find_topmost_directory_containing(full_path, 'CMakeLists.txt')
+            toplevel_dir ||= find_topmost_directory_containing(
+                full_path, 'CMakeLists.txt')
 
             manifest_xml = File.join(toplevel_dir, 'manifest.xml')
             package_xml = File.join(toplevel_dir, 'package.xml')
             if File.file?(package_xml) && !File.file?(manifest_xml)
                 return "catkin_package", toplevel_dir
             end
-            return "cmake_package", toplevel_dir
-        elsif dir = find_topmost_directory_containing(full_path, "Rakefile") ||
-            find_topmost_directory_containing(full_path, "lib/*.rb")
-
-            return "ruby_package", dir
-        elsif (dir = find_topmost_directory_containing(full_path, 'setup.py')) ||
-             (dir = find_topmost_directory_containing(full_path, File.join(File.basename(full_path), "*.py")))
-            return 'python_package', dir
+
+            ["cmake_package", toplevel_dir]
+        elsif (dir = (find_topmost_directory_containing(full_path, "Rakefile") ||
+                      find_topmost_directory_containing(full_path, "lib/*.rb")))
+
+            ["ruby_package", dir]
+        elsif (dir = (find_topmost_directory_containing(full_path, 'setup.py') ||
+                      find_topmost_directory_containing(full_path, pyglob)))
+            ['python_package', dir]
         end
     end
 end
@@ -130,9 +149,7 @@ def ignore(*paths)
 
 # Adds a new setup block to an existing package
 def setup_package(package_name, workspace: Autoproj.workspace, &block)
-    if !block
-        raise ConfigError.new, "you must give a block to #setup_package"
-    end
+    raise ConfigError.new, "you must give a block to #setup_package" unless block
 
     package_definition = workspace.manifest.find_package_definition(package_name)
     if !package_definition
@@ -148,10 +165,11 @@ def setup_package(package_name, workspace: Autoproj.workspace, &block)
 def package_common(package_type, spec, workspace: Autoproj.workspace, &block)
     package_name = Autoproj.package_name_from_options(spec)
 
-    if existing_package = workspace.manifest.find_package_definition(package_name)
+    if (existing_package = workspace.manifest.find_package_definition(package_name))
         current_file = workspace.current_file[1]
         old_file     = existing_package.file
-        Autoproj.warn "#{package_name} from #{current_file} is overridden by the definition in #{old_file}"
+        Autoproj.warn "#{package_name} from #{current_file} is overridden "\
+            "by the definition in #{old_file}"
         return existing_package.autobuild
     end
 
@@ -161,33 +179,33 @@ def package_common(package_type, spec, workspace: Autoproj.workspace, &block)
 end
 
 def import_package(name, workspace: Autoproj.workspace, &block)
-    package_common(:import, name, workspace: Autoproj.workspace, &block)
+    package_common(:import, name, workspace: workspace, &block)
 end
 
-def python_package(name, workspace: Autoproj.workspace, &block)
-    package_common(:python, name, workspace: Autoproj.workspace, &block)
+def python_package(name, workspace: Autoproj.workspace)
+    package_common(:python, name, workspace: workspace) do |pkg|
+        pkg.internal_dependency 'python'
+        yield(pkg) if block_given?
+    end
 end
 
 def common_make_based_package_setup(pkg)
     unless pkg.has_doc? && pkg.doc_dir
         pkg.with_doc do
             doc_html = File.join(pkg.builddir, 'doc', 'html')
-            if File.directory?(doc_html)
-                pkg.doc_dir = doc_html
-            end
+            pkg.doc_dir = doc_html if File.directory?(doc_html)
         end
     end
-    if !pkg.test_utility.has_task?
-        if !pkg.test_utility.source_dir
+
+    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
         end
 
-        if pkg.test_utility.source_dir
-            pkg.with_tests
-        end
+        pkg.with_tests if pkg.test_utility.source_dir
     end
 end
 
@@ -246,7 +264,6 @@ def env_add(name, value)
     Autoproj.env.add(name, value)
 end
 
-
 # Defines a Ruby package
 #
 # Example:
@@ -264,11 +281,10 @@ def ruby_package(name, workspace: Autoproj.workspace)
         # Documentation code. Ignore if the user provided its own documentation
         # task, or disabled the documentation generation altogether by setting
         # rake_doc_task to nil
-        if !pkg.has_doc? && pkg.rake_doc_task
-            pkg.with_doc
-        end
-        if !pkg.test_utility.has_task?
-            if !pkg.test_utility.source_dir
+        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')
@@ -276,9 +292,7 @@ def ruby_package(name, workspace: Autoproj.workspace)
                 end
             end
 
-            if pkg.test_utility.source_dir
-                pkg.with_tests
-            end
+            pkg.with_tests if pkg.test_utility.source_dir
         end
 
         yield(pkg) if block_given?
@@ -318,13 +332,13 @@ def only_on(*architectures)
 
     os_names, os_versions = Autoproj.workspace.operating_system
     matching_archs = architectures.find_all { |arch| os_names.include?(arch[0].downcase) }
-    if matching_archs.empty?
-        return
-    elsif matching_archs.none? { |arch| !arch[1] || os_versions.include?(arch[1].downcase) }
-        return
+    return if matching_archs.empty?
+
+    has_matching_arch = matching_archs.any? do |arch|
+        !arch[1] || os_versions.include?(arch[1].downcase)
     end
 
-    yield
+    yield if has_matching_arch
 end
 
 # Declare that the packages declared in the block should not be built in the
@@ -343,22 +357,25 @@ def not_on(*architectures)
 
     os_names, os_versions = Autoproj.workspace.operating_system
     matching_archs = architectures.find_all { |arch| os_names.include?(arch[0].downcase) }
-    if matching_archs.empty?
-        return yield
-    elsif matching_archs.all? { |arch| arch[1] && !os_versions.include?(arch[1].downcase) }
-        return yield
+    return yield if matching_archs.empty?
+
+    matches_arch = matching_archs.all? do |arch|
+        arch[1] && !os_versions.include?(arch[1].downcase)
     end
+    return yield if matches_arch
 
     # Simply get the current list of packages, yield the block, and exclude all
     # packages that have been added
     manifest = Autoproj.workspace.manifest
     current_packages = manifest.each_autobuild_package.map(&:name).to_set
     yield
-    new_packages = manifest.each_autobuild_package.map(&:name).to_set -
+    new_packages =
+        manifest.each_autobuild_package.map(&:name).to_set -
         current_packages
 
     new_packages.each do |pkg_name|
-        manifest.exclude_package(pkg_name, "#{pkg_name} is disabled on this operating system")
+        manifest.exclude_package(
+            pkg_name, "#{pkg_name} is disabled on this operating system")
     end
 end
 
@@ -366,7 +383,7 @@ def not_on(*architectures)
 # not built in any way
 def source_package(options, workspace: Autoproj.workspace)
     package_common(options, workspace: workspace) do |pkg|
-        pkg.srcdir   = pkg.name
+        pkg.srcdir = pkg.name
         yield(pkg) if block_given?
     end
 end
@@ -400,7 +417,7 @@ def package_enabled?(name)
 
 # If used in init.rb, allows to disable automatic imports from specific package
 # sets
-def disable_imports_from(name)
+def disable_imports_from(_name)
     raise NotImplementedError, "not implemented in autoproj v2"
 end
 
@@ -448,12 +465,16 @@ def remove_from_default(*names)
 end
 
 def renamed_package(current_name, old_name, options)
-    if options[:obsolete] && !Autoproj.workspace.manifest.explicitely_selected_in_layout?(old_name)
+    explicit_selection = Autoproj.workspace.manifest.
+        explicitely_selected_in_layout?(old_name)
+    if options[:obsolete] && !explicit_selection
         import_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"
+        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
 end
-
-

data/lib/autoproj/autobuild_extensions/package.rb

@@ -3,7 +3,6 @@ module AutobuildExtensions
         module Package
             # Tags explicitely added with #add_tag
             attr_reader :added_tags
-
             attr_reader :optional_dependencies
 
             attr_reader :os_packages
@@ -24,6 +23,7 @@ def initialize(spec = Hash.new)
                 @optional_dependencies = Set.new
                 @description = PackageManifest.new(self, null: true)
                 @use_package_xml = false
+                @internal_dependencies = []
             end
 
             # Whether we should use a package.xml file present in this package
@@ -34,6 +34,10 @@ def use_package_xml?
                 @use_package_xml
             end
 
+            def internal_dependencies
+                @internal_dependencies.dup
+            end
+
             # Set {#use_package_xml?}
             attr_writer :use_package_xml
 
@@ -136,6 +140,21 @@ def remove_dependency(name)
                 os_packages.delete name
             end
 
+            # @api private
+            #
+            # Adds and 'internal' dependency to the package
+            # 'Internal' dependencies are actually autobuild dependencies
+            # for a given package type. It is assumed that only
+            # osdeps that do not rely on strict package managers will be
+            # declared as internal dependencies.
+            #
+            # The difference between a regular "os dependency" is that
+            # the internal dependency is installed right after the impport
+            # phase (before the actual osdeps phase)
+            def internal_dependency(osdeps_name)
+                @internal_dependencies << osdeps_name
+            end
+
             def optional_dependency(name)
                 optional_dependencies << name
             end

data/lib/autoproj/build_option.rb

@@ -45,18 +45,35 @@ def doc
             end
         end
 
+        # Return either the current value if it is not nil, or use
+        # a default value
+        #
+        # @return [value, Boolean] Current value, and flag whether this is a
+        # default value
+        def ensure_value(current_value)
+            if !current_value.nil?
+                return current_value.to_s, false
+            elsif options[:default]
+                return options[:default].to_str, true
+            else
+                return '', true
+            end
+        end
+
+        # Ask the user for the setting of this option
+        # by providing the current value as input and falling
+        # back to default values if needed
+        #
+        # @param [String] current_value the option's current value
+        # @param [String] doc a string to override the default option banner
         def ask(current_value, doc = nil)
-            default_value =
-                if !current_value.nil? then current_value.to_s
-                elsif options[:default] then options[:default].to_str
-                else ''
-                end
+            value,_ = ensure_value(current_value)
 
-            STDOUT.print "  #{doc || self.doc} [#{default_value}] "
+            STDOUT.print "  #{doc || self.doc} [#{value}] "
             STDOUT.flush
             answer = STDIN.readline.chomp
             if answer == ''
-                answer = default_value
+                answer = value
             end
             validate(answer)
 

data/lib/autoproj/cli/base.rb

@@ -156,9 +156,18 @@ def resolve_selection(user_selection, checkout_only: true, only_local: false, re
                 raise CLIInvalidSelection, e.message, e.backtrace
             end
 
+            # Check whether the user selection refers to non-existant/unknown
+            # packages
+            #
+            # @param [Array<String>] user_selection List of selected packages
+            # @param [Autoproj::PackageSelection] resolved_selection The
+            #   selection of known packages
+            # @raises [CLIInvalidArguments] if no match for a package could be found
             def validate_user_selection(user_selection, resolved_selection)
                 not_matched = user_selection.find_all do |pkg_name|
-                    !resolved_selection.has_match_for?(pkg_name)
+                    !resolved_selection.has_match_for?(pkg_name) &&
+                        !(resolved_selection.ignored?(pkg_name) ||
+                          resolved_selection.excluded?(pkg_name))
                 end
                 if !not_matched.empty?
                     raise CLIInvalidArguments, "autoproj: wrong package selection on command line, cannot find a match for #{not_matched.to_a.sort.join(", ")}"
@@ -166,6 +175,8 @@ def validate_user_selection(user_selection, resolved_selection)
             end
 
             def validate_options(args, options)
+                interactive = options.delete(:interactive)
+                ws.config.interactive = interactive unless interactive.nil?
                 self.class.validate_options(args, options)
             end