autoproj 2.10.1 → 2.13.0

data/lib/autoproj/package_managers/homebrew_manager.rb

@@ -15,7 +15,7 @@ def filter_uptodate_packages(packages)
                 # somewhere else
                 packages = packages.uniq
                 command_line = "brew info --json=v1 #{packages.join(' ')}"
-                result = Bundler.with_clean_env do
+                result = Autoproj.bundler_with_unbundled_env do
                     (Autobuild::Subprocess.run 'autoproj', 'osdeps', command_line).first
                 end
 
@@ -30,7 +30,7 @@ def filter_uptodate_packages(packages)
                     end
                     return packages
                 end
-                
+
                 # fall back if something else went wrong
                 if packages.size != result.size
                     Autoproj.warn "brew info returns less or more packages when requested. Falling back to install all packages"

data/lib/autoproj/package_managers/shell_script_manager.rb

@@ -7,8 +7,10 @@ def self.execute(command_line, with_locking, with_root, env: Autobuild.env)
                 if with_locking
                     File.open('/tmp/autoproj_osdeps_lock', 'w') do |lock_io|
                         begin
-                            while !lock_io.flock(File::LOCK_EX | File::LOCK_NB)
-                                Autoproj.message "  waiting for other autoproj instances to finish their osdeps installation"
+                            until lock_io.flock(File::LOCK_EX | File::LOCK_NB)
+                                Autoproj.message "  waiting for other autoproj "\
+                                                 "instances to finish their osdeps "\
+                                                 "installation"
                                 sleep 5
                             end
                             return execute(command_line, false, with_root, env: env)
@@ -17,7 +19,7 @@ def self.execute(command_line, with_locking, with_root, env: Autobuild.env)
                         end
                     end
                 end
-                
+
                 if with_root
                     sudo = Autobuild.tool_in_path('sudo', env: env)
                     command_line = [sudo, *command_line]
@@ -34,10 +36,12 @@ def self.execute(command_line, with_locking, with_root, env: Autobuild.env)
             # This declares if this package manager cannot be used concurrently.
             # If it is the case, autoproj will ensure that there is no two
             # autoproj instances running this package manager at the same time
-            # 
+            #
             # @return [Boolean]
             # @see needs_locking=
-            def needs_locking?; !!@needs_locking end
+            def needs_locking?
+                @needs_locking
+            end
 
             # Overrides the {#needs_root?} flag
             attr_writer :needs_root
@@ -45,10 +49,12 @@ def needs_locking?; !!@needs_locking end
             #
             # This declares if the command line(s) for this package manager
             # should be started as root. Root access is provided using sudo
-            # 
+            #
             # @return [Boolean]
             # @see needs_root=
-            def needs_root?; !!@needs_root end
+            def needs_root?
+                @needs_root
+            end
 
             # Command line used by autoproj to install packages
             #
@@ -83,10 +89,13 @@ def needs_root?; !!@needs_root end
             #   itself, see {#auto_install_cmd}.
             # @param [Boolean] needs_root if the command lines should be started
             #   as root or not. See {#needs_root?}
-            def initialize(ws, needs_locking, user_install_cmd, auto_install_cmd,needs_root=true)
+            def initialize(ws, needs_locking, user_install_cmd,
+                           auto_install_cmd, needs_root = true)
                 super(ws)
-                @needs_locking, @user_install_cmd, @auto_install_cmd,@needs_root =
-                    needs_locking, user_install_cmd, auto_install_cmd, needs_root
+                @needs_locking = needs_locking
+                @user_install_cmd = user_install_cmd
+                @auto_install_cmd = auto_install_cmd
+                @needs_root = needs_root
             end
 
             # Generate the shell script that would allow the user to install
@@ -98,7 +107,8 @@ def initialize(ws, needs_locking, user_install_cmd, auto_install_cmd,needs_root=
             #   command-line pattern that should be used to generate the script.
             #   If given, it overrides the default value stored in
             #   {#user_install_cmd]
-            def generate_user_os_script(os_packages, user_install_cmd: self.user_install_cmd)
+            def generate_user_os_script(os_packages,
+                                        user_install_cmd: self.user_install_cmd)
                 if user_install_cmd
                     user_install_cmd.join(" ") + " " + os_packages.join("' '")
                 else generate_auto_os_script(os_packages)
@@ -114,7 +124,8 @@ def generate_user_os_script(os_packages, user_install_cmd: self.user_install_cmd
             #   command-line pattern that should be used to generate the script.
             #   If given, it overrides the default value stored in
             #   {#auto_install_cmd]
-            def generate_auto_os_script(os_packages, auto_install_cmd: self.auto_install_cmd)
+            def generate_auto_os_script(os_packages,
+                                        auto_install_cmd: self.auto_install_cmd)
                 auto_install_cmd.join(" ") + " " + os_packages.join("' '")
             end
 
@@ -139,9 +150,9 @@ def osdeps_interaction(os_packages, shell_script)
                 # anyway, do so now
                 puts <<-EOMSG
 
-                #{Autoproj.color("The build process and/or the packages require some other software to be installed", :bold)}
-                #{Autoproj.color("and you required autoproj to not install them itself", :bold)}
-                #{Autoproj.color("\nIf these packages are already installed, simply ignore this message\n", :red) if !respond_to?(:filter_uptodate_packages)}
+                #{Autoproj.color('The build process and/or the packages require some other software to be installed', :bold)}
+                #{Autoproj.color('and you required autoproj to not install them itself', :bold)}
+                #{Autoproj.color('\nIf these packages are already installed, simply ignore this message\n', :red) unless respond_to?(:filter_uptodate_packages)}
     The following packages are available as OS dependencies, i.e. as prebuilt
     packages provided by your distribution / operating system. You will have to
     install them manually if they are not already installed
@@ -152,8 +163,8 @@ def osdeps_interaction(os_packages, shell_script)
 
                 #{shell_script.split("\n").join("\n|   ")}
 
-            EOMSG
-                print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+                EOMSG
+                print "    #{Autoproj.color('Press ENTER to continue ', :bold)}"
                 STDOUT.flush
                 STDIN.readline
                 puts
@@ -172,23 +183,33 @@ def osdeps_interaction(os_packages, shell_script)
             #   packages. See the option in {#generate_auto_os_script}
             # @return [Boolean] true if packages got installed, false otherwise
             def install(packages, filter_uptodate_packages: false, install_only: false,
-                        auto_install_cmd: self.auto_install_cmd, user_install_cmd: self.user_install_cmd)
+                        auto_install_cmd: self.auto_install_cmd,
+                        user_install_cmd: self.user_install_cmd)
                 return if packages.empty?
 
                 handled_os = ws.supported_operating_system?
                 if handled_os
-                    shell_script = generate_auto_os_script(packages, auto_install_cmd: auto_install_cmd)
-                    user_shell_script = generate_user_os_script(packages, user_install_cmd: user_install_cmd)
+                    shell_script = generate_auto_os_script(
+                        packages, auto_install_cmd: auto_install_cmd
+                    )
+                    user_shell_script = generate_user_os_script(
+                        packages, user_install_cmd: user_install_cmd
+                    )
                 end
                 if osdeps_interaction(packages, user_shell_script)
-                    Autoproj.message "  installing OS packages: #{packages.sort.join(", ")}"
+                    Autoproj.message "  installing OS packages: "\
+                                     "#{packages.sort.join(', ')}"
 
                     if Autoproj.verbose
-                        Autoproj.message "Generating installation script for non-ruby OS dependencies"
+                        Autoproj.message "Generating installation script for "\
+                                         "non-ruby OS dependencies"
                         Autoproj.message shell_script
                     end
 
-                    ShellScriptManager.execute([*auto_install_cmd, *packages], needs_locking?, needs_root?, env: ws.env)
+                    ShellScriptManager.execute(
+                        [*auto_install_cmd, *packages], needs_locking?,
+                        needs_root?, env: ws.env
+                    )
                     return true
                 end
                 false
@@ -196,4 +217,3 @@ def install(packages, filter_uptodate_packages: false, install_only: false,
         end
     end
 end
-

data/lib/autoproj/package_manifest.rb

@@ -30,13 +30,15 @@ def self.load(package, file, ros_manifest: false)
         # @param [Boolean] ros_manifest whether the file follows the ROS format
         # @return [PackageManifest]
         # @see load
-        def self.parse(package, contents, path: '<loaded from string>', loader_class: Loader)
-            manifest = PackageManifest.new(package)
+        def self.parse(package, contents,
+                       path: '<loaded from string>', loader_class: Loader)
+            manifest = PackageManifest.new(package, path)
             loader = loader_class.new(path, manifest)
             begin
                 REXML::Document.parse_stream(contents, loader)
             rescue REXML::ParseException => e
-                raise Autobuild::PackageException.new(package.name, 'prepare'), "invalid #{file}: #{e.message}"
+                raise Autobuild::PackageException.new(package.name, 'prepare'),
+                      "invalid #{file}: #{e.message}"
             end
             manifest
         end
@@ -45,7 +47,8 @@ def self.parse(package, contents, path: '', loader_class: Lo
         Dependency  = Struct.new :name, :optional, :modes
 
         # The Autobuild::Package instance this manifest applies on
-        attr_reader :package
+        attr_accessor :package
+        attr_reader :path
         attr_accessor :description
         attr_accessor :brief_description
         attr_reader :dependencies
@@ -63,7 +66,7 @@ def add_dependency(name, optional: false, modes: [])
         end
 
         def has_documentation?
-            !!description
+            description
         end
 
         def documentation
@@ -71,16 +74,18 @@ def documentation
         end
 
         def has_short_documentation?
-            !!brief_description
+            brief_description
         end
 
         def short_documentation
             brief_description ||
-                "no documentation available for package '#{package.name}' in its manifest.xml file"
+                "no documentation available for package '#{package.name}' "\
+                "in its manifest.xml file"
         end
 
-        def initialize(package, null: false)
+        def initialize(package, path = nil, null: false)
             @package = package
+            @path = path
             @dependencies = []
             @authors = []
             @maintainers = []
@@ -92,11 +97,12 @@ def initialize(package, null: false)
         # Whether this is a null manifest (used for packages that have actually
         # no manifest) or not
         def null?
-            !!@null
+            @null
         end
 
-        def each_dependency(in_modes = Array.new, &block)
-            return enum_for(__method__, in_modes) if !block_given?
+        def each_dependency(in_modes = [])
+            return enum_for(__method__, in_modes) unless block_given?
+
             dependencies.each do |dep|
                 if dep.modes.empty? || in_modes.any? { |m| dep.modes.include?(m) }
                     yield(dep.name, dep.optional)
@@ -105,24 +111,28 @@ def each_dependency(in_modes = Array.new, &block)
         end
 
         def each_os_dependency(modes = Array.new, &block)
-            Autoproj.warn_deprecated "#{self.class}##{__method__}", "call #each_dependency instead"
-            return each_dependency(modes, &block)
+            Autoproj.warn_deprecated "#{self.class}##{__method__}",
+                                     "call #each_dependency instead"
+            each_dependency(modes, &block)
         end
 
         def each_package_dependency(modes = Array.new, &block)
-            Autoproj.warn_deprecated "#{self.class}##{__method__}", "call #each_dependency instead"
-            return each_dependency(modes, &block)
+            Autoproj.warn_deprecated "#{self.class}##{__method__}",
+                                     "call #each_dependency instead"
+            each_dependency(modes, &block)
         end
 
         def each_rock_maintainer
-            return enum_for(__method__) if !block_given?
+            return enum_for(__method__) unless block_given?
+
             rock_maintainers.each do |m|
                 yield(m.name, m.email)
             end
         end
 
         def each_maintainer
-            return enum_for(__method__) if !block_given?
+            return enum_for(__method__) unless block_given?
+
             maintainers.each do |m|
                 yield(m.name, m.email)
             end
@@ -131,7 +141,8 @@ def each_maintainer
         # Enumerates the name and email of each author. If no email is present,
         # yields (name, nil)
         def each_author
-            return enum_for(__method__) if !block_given?
+            return enum_for(__method__) unless block_given?
+
             authors.each do |m|
                 yield(m.name, m.email)
             end
@@ -175,11 +186,13 @@ def initialize(path, manifest)
 
             def parse_depend_tag(tag_name, attributes, modes: [], optional: false)
                 package = attributes['package'] || attributes['name']
-                if !package
-                    raise InvalidPackageManifest, "found '#{tag_name}' tag in #{path} without a 'package' attribute"
+                unless package
+                    raise InvalidPackageManifest,
+                          "found '#{tag_name}' tag in #{path} "\
+                          "without a 'package' attribute"
                 end
 
-                if tag_modes = attributes['modes']
+                if (tag_modes = attributes['modes'])
                     modes += tag_modes.split(',')
                 end
 
@@ -192,7 +205,7 @@ def parse_depend_tag(tag_name, attributes, modes: [], optional: false)
             def parse_contact_field(text)
                 text.strip.split(',').map do |str|
                     name, email = str.split('/').map(&:strip)
-                    email = nil if email && email.empty?
+                    email = nil if email&.empty?
                     ContactInfo.new(name, email)
                 end
             end
@@ -210,7 +223,7 @@ def toplevel_tag_start(name, attributes)
                 elsif name =~ /^(\w+)_depend$/
                     parse_depend_tag(name, attributes, modes: [$1])
                 elsif name == 'description'
-                    if brief = attributes['brief']
+                    if (brief = attributes['brief'])
                         manifest.brief_description = brief
                     end
                     @tag_text = ''
@@ -222,14 +235,13 @@ def toplevel_tag_start(name, attributes)
                     @tag_text = nil
                 end
             end
+
             def toplevel_tag_end(name)
                 if AUTHOR_FIELDS.include?(name)
                     manifest.send("#{name}s").concat(parse_contact_field(@tag_text))
                 elsif TEXT_FIELDS.include?(name)
                     field = @tag_text.strip
-                    if !field.empty?
-                        manifest.send("#{name}=", field)
-                    end
+                    manifest.send("#{name}=", field) unless field.empty?
                 elsif name == 'tags'
                     manifest.tags.concat(@tag_text.strip.split(',').map(&:strip))
                 end
@@ -242,10 +254,10 @@ def toplevel_tag_end(name)
         # REXML stream parser object used to load the XML contents into a
         # {PackageManifest} object
         class RosLoader < Loader
-            SUPPORTED_MODES = ['test'].freeze
-            DEPEND_TAGS = Set['depend', 'build_depend', 'build_export_depend',
-                              'buildtool_depend', 'buildtool_export_depend',
-                              'exec_depend', 'test_depend', 'run_depend']
+            SUPPORTED_MODES = %w[test doc].freeze
+            DEPEND_TAGS = %w[depend build_depend build_export_depend
+                             buildtool_depend buildtool_export_depend
+                             exec_depend test_depend run_depend doc_depend].to_set.freeze
 
             def toplevel_tag_start(name, attributes)
                 if DEPEND_TAGS.include?(name)
@@ -262,18 +274,21 @@ def toplevel_tag_start(name, attributes)
 
             def toplevel_tag_end(name)
                 if DEPEND_TAGS.include?(name)
-                    raise InvalidPackageManifest, "found '#{name}' tag in #{path} without content" if @tag_text.strip.empty?
+                    if @tag_text.strip.empty?
+                        raise InvalidPackageManifest, "found '#{name}' tag in #{path} "\
+                                                      "without content"
+                    end
 
                     mode = []
-                    if name =~ /^(\w+)_depend$/
-                        mode = SUPPORTED_MODES & [$1]
+                    if (m = /^(\w+)_depend$/.match(name))
+                        mode = SUPPORTED_MODES & [m[1]]
                     end
 
                     manifest.add_dependency(@tag_text, modes: mode)
                 elsif AUTHOR_FIELDS.include?(name)
                     author_name = @tag_text.strip
                     email = @author_email ? @author_email.strip : nil
-                    email = nil if email && email.empty?
+                    email = nil if email&.empty?
                     contact = ContactInfo.new(author_name, email)
                     manifest.send("#{name}s").concat([contact])
                 elsif TEXT_FIELDS.include?(name)

data/lib/autoproj/package_set.rb

@@ -168,7 +168,7 @@ def initialize(
             @version_control = Array.new
             @overrides = Array.new
             @raw_local_dir = raw_local_dir
-            @default_importer = VCSDefinition.from_raw(type: 'none')
+            @default_importer = VCSDefinition.from_raw({ type: 'none' })
 
             @imports  = Set.new
             @imports_vcs  = Array.new
@@ -239,7 +239,7 @@ def snapshot(target_dir, options = Hash.new)
             else
                 package = create_autobuild_package
                 if package.importer.respond_to?(:snapshot)
-                    package.importer.snapshot(package, target_dir, options)
+                    package.importer.snapshot(package, target_dir, **options)
                 end
             end
         end
@@ -535,7 +535,9 @@ def parse_source_definition(source_definition)
 
                 Autoproj.in_file(source_file) do
                     default_vcs_spec, raw = version_control_field(
-                        'default', version_control, file: source_file)
+                        'default', version_control,
+                        file: source_file, section: 'version_control'
+                    )
                     if default_vcs_spec
                         @default_importer = VCSDefinition.from_raw(default_vcs_spec,
                             raw: raw, from: self)
@@ -653,28 +655,30 @@ def normalize_vcs_list(section_name, file, list)
         #   package in the form (PackageSet,Hash), where PackageSet is self.
         #   The Hash part is nil if there are no matching entries. Hash keys are
         #   normalized to symbols
-        def version_control_field(package_name, entry_list, validate: true, file: source_file)
+        def version_control_field(package_name, entry_list, validate: true,
+                                  file: source_file, section: nil)
             raw = []
-            vcs_spec = Hash.new
+            vcs_spec = entry_list.inject({}) do |resolved_spec, (name_match, spec)|
+                next(resolved_spec) unless name_match === package_name
 
-            entry_list.each do |name_match, spec|
-                if name_match === package_name
-                    raw << VCSDefinition::RawEntry.new(self, file, spec)
-                    vcs_spec =
-                        begin
-                            VCSDefinition.update_raw_vcs_spec(vcs_spec, spec)
-                        rescue ConfigError => e
-                            raise ConfigError.new, "invalid VCS definition in the #{section_name} section for '#{name}': #{e.message}", e.backtrace
-                        end
+                raw << VCSDefinition::RawEntry.new(self, file, spec)
+                begin
+                    VCSDefinition.update_raw_vcs_spec(resolved_spec, spec)
+                rescue ArgumentError => e
+                    raise ConfigError.new,
+                          'invalid VCS definition while resolving package '\
+                          "'#{package_name}', entry '#{name_match}' of "\
+                          "#{section ? "section '#{section}'" : ''}: "\
+                          "#{e.message}", e.backtrace
                 end
             end
 
-            if vcs_spec.empty?
-                return nil, []
-            end
+            return nil, [] if vcs_spec.empty?
 
-            expansions = Hash["PACKAGE" => package_name,
-                "PACKAGE_BASENAME" => File.basename(package_name)]
+            expansions = {
+                'PACKAGE' => package_name,
+                'PACKAGE_BASENAME' => File.basename(package_name)
+            }
 
             vcs_spec = expand(vcs_spec, expansions)
             vcs_spec.dup.each do |name, value|
@@ -682,7 +686,7 @@ def version_control_field(package_name, entry_list, validate: true, file: source
             end
 
             # Resolve relative paths w.r.t. the workspace root dir
-            if url = (vcs_spec.delete('url') || vcs_spec.delete(:url))
+            if (url = (vcs_spec.delete('url') || vcs_spec.delete(:url)))
                 vcs_spec[:url] = VCSDefinition.to_absolute_url(url, ws.root_dir)
             end
 
@@ -691,11 +695,14 @@ def version_control_field(package_name, entry_list, validate: true, file: source
             if validate
                 begin
                     VCSDefinition.from_raw(vcs_spec)
-                rescue ConfigError => e
-                    raise ConfigError.new, "invalid resulting VCS definition for package #{package_name}: #{e.message}", e.backtrace
+                rescue ArgumentError => e
+                    raise ConfigError.new,
+                          'invalid resulting VCS definition for package '\
+                          "'#{package_name}': #{e.message}",
+                          e.backtrace
                 end
             end
-            return vcs_spec, raw
+            [vcs_spec, raw]
         end
 
         # @api private
@@ -706,15 +713,20 @@ def invalidate_importer_definitions_cache
         end
 
         # Returns the VCS definition for +package_name+ as defined in this
-        # source, or nil if the source does not have any.
+        # package set, or nil if the source does not have any.
         #
         # @param [PackageDefinition] package
         # @return [VCSDefinition] the importer definition, or nil if none
         #   could be found
         def importer_definition_for(package, default: default_importer, require_existing: true)
-            package_name = manifest.validate_package_name_argument(package, require_existing: require_existing)
+            package_name = manifest.validate_package_name_argument(
+                package, require_existing: require_existing
+            )
             importer_definitions_cache[package_name] ||= Autoproj.in_file source_file do
-                vcs_spec, raw = version_control_field(package_name, version_control, file: source_file)
+                vcs_spec, raw = version_control_field(
+                    package_name, version_control,
+                    file: source_file, section: 'version_control'
+                )
                 if vcs_spec
                     VCSDefinition.from_raw(vcs_spec, raw: raw, from: self)
                 else
@@ -729,7 +741,9 @@ def importer_definition_for(package, default: default_importer, require_existing
         # @param [VCSDefinition] the vcs to be updated
         # @return [VCSDefinition] the new, updated vcs object
         def overrides_for(package, vcs, require_existing: true)
-            package_name = manifest.validate_package_name_argument(package, require_existing: require_existing)
+            package_name = manifest.validate_package_name_argument(
+                package, require_existing: require_existing
+            )
             resolve_overrides(package_name, vcs)
         end
 
@@ -742,7 +756,10 @@ def resolve_overrides(key, vcs)
             overrides.each do |file, file_overrides|
                 new_spec, new_raw_entry =
                     Autoproj.in_file file do
-                        version_control_field(key, file_overrides, validate: false, file: file)
+                        version_control_field(
+                            key, file_overrides,
+                            validate: false, file: file, section: 'overrides'
+                        )
                     end
 
                 if new_spec
@@ -750,7 +767,9 @@ def resolve_overrides(key, vcs)
                         begin
                             vcs = vcs.update(new_spec, raw: new_raw_entry, from: self)
                         rescue ConfigError => e
-                            raise ConfigError.new, "invalid resulting VCS specification in the overrides section for #{key}: #{e.message}"
+                            raise ConfigError.new, "invalid resulting VCS specification "\
+                                                   "in the overrides section for "\
+                                                   "#{key}: #{e.message}"
                         end
                     end
                 end