autoproj 2.14.0 → 2.15.0

data/lib/autoproj/package_managers/yum_manager.rb

@@ -4,8 +4,8 @@ module Autoproj
         class YumManager < ShellScriptManager
             def initialize(ws)
                 super(ws, true,
-                      %w{yum install},
-                      %w{yum install -y})
+                      %w[yum install],
+                      %w[yum install -y])
             end
 
             def filter_uptodate_packages(packages)
@@ -17,15 +17,17 @@ module Autoproj
                     line = line.strip
                     if line =~ /package (.*) is not installed/
                         package_name = $1
-                        if !packages.include?(package_name) # something is wrong, fallback to installing everything
+                        unless packages.include?(package_name) # something is wrong, fallback to installing everything
                             return packages
                         end
+
                         new_packages << package_name
-                    else 
+                    else
                         package_name = line.strip
-                        if !packages.include?(package_name) # something is wrong, fallback to installing everything
+                        unless packages.include?(package_name) # something is wrong, fallback to installing everything
                             return packages
                         end
+
                         installed_packages << package_name
                     end
                 end
@@ -33,21 +35,17 @@ module Autoproj
             end
 
             def install(packages, filter_uptodate_packages: false, install_only: false)
-                if filter_uptodate_packages
-                    packages = filter_uptodate_packages(packages)
-                end
+                packages = filter_uptodate_packages(packages) if filter_uptodate_packages
 
                 patterns, packages = packages.partition { |pkg| pkg =~ /^@/ }
                 patterns = patterns.map { |str| str[1..-1] }
                 result = false
-                if !patterns.empty?
+                unless patterns.empty?
                     result |= super(patterns,
-                                    auto_install_cmd: %w{yum groupinstall -y},
-                                    user_install_cmd: %w{yum groupinstall})
-                end
-                if !packages.empty?
-                    result |= super(packages)
+                                    auto_install_cmd: %w[yum groupinstall -y],
+                                    user_install_cmd: %w[yum groupinstall])
                 end
+                result |= super(packages) unless packages.empty?
                 if result
                     # Invalidate caching of installed packages, as we just
                     # installed new packages !
@@ -57,4 +55,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/package_managers/zypper_manager.rb

@@ -1,21 +1,21 @@
 module Autoproj
     module PackageManagers
-        #Package manger for OpenSuse and Suse (untested)
+        # Package manger for OpenSuse and Suse (untested)
         class ZypperManager < ShellScriptManager
             def initialize(ws)
                 super(ws, true,
-                        %w{zypper install},
-                        %w{zypper -n install})
+                        %w[zypper install],
+                        %w[zypper -n install])
             end
 
             def filter_uptodate_packages(packages)
                 `LANG=C rpm -q --whatprovides '#{packages.join("' '")}'`
                 has_all_pkgs = $?.success?
 
-                if !has_all_pkgs
-                    return packages # let zypper filter, we need root now anyways
-                else 
-                    return []
+                if has_all_pkgs
+                    []
+                else
+                    packages # let zypper filter, we need root now anyways
                 end
             end
 
@@ -27,14 +27,12 @@ module Autoproj
                 patterns, packages = packages.partition { |pkg| pkg =~ /^@/ }
                 patterns = patterns.map { |str| str[1..-1] }
                 result = false
-                if !patterns.empty?
+                unless patterns.empty?
                     result |= super(patterns,
-                                    auto_install_cmd: %w{zypper --non-interactive install --type pattern},
-                                    user_install_cmd: %w{zypper install --type pattern})
-                end
-                if !packages.empty?
-                    result |= super(packages)
+                                    auto_install_cmd: %w[zypper --non-interactive install --type pattern],
+                                    user_install_cmd: %w[zypper install --type pattern])
                 end
+                result |= super(packages) unless packages.empty?
                 if result
                     # Invalidate caching of installed packages, as we just
                     # installed new packages !
@@ -44,4 +42,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/package_manifest.rb

@@ -31,13 +31,13 @@ module Autoproj
         # @return [PackageManifest]
         # @see load
         def self.parse(package, contents,
-                       path: '<loaded from string>', loader_class: Loader)
+            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'),
+                raise Autobuild::PackageException.new(package.name, "prepare"),
                       "invalid #{file}: #{e.message}"
             end
             manifest
@@ -185,52 +185,53 @@ module Autoproj
             end
 
             def parse_depend_tag(tag_name, attributes, modes: [], optional: false)
-                package = attributes['package'] || attributes['name']
+                package = attributes["package"] || attributes["name"]
                 unless package
                     raise InvalidPackageManifest,
                           "found '#{tag_name}' tag in #{path} "\
                           "without a 'package' attribute"
                 end
 
-                if (tag_modes = attributes['modes'])
-                    modes += tag_modes.split(',')
+                if (tag_modes = attributes["modes"])
+                    modes += tag_modes.split(",")
                 end
 
                 manifest.add_dependency(
                     package,
-                    optional: optional || (attributes['optional'] == '1'),
-                    modes: modes)
+                    optional: optional || (attributes["optional"] == "1"),
+                    modes: modes
+                )
             end
 
             def parse_contact_field(text)
-                text.strip.split(',').map do |str|
-                    name, email = str.split('/').map(&:strip)
+                text.strip.split(",").map do |str|
+                    name, email = str.split("/").map(&:strip)
                     email = nil if email&.empty?
                     ContactInfo.new(name, email)
                 end
             end
 
-            TEXT_FIELDS = Set['url', 'license', 'version', 'description']
-            AUTHOR_FIELDS = Set['author', 'maintainer', 'rock_maintainer']
+            TEXT_FIELDS = Set["url", "license", "version", "description"]
+            AUTHOR_FIELDS = Set["author", "maintainer", "rock_maintainer"]
 
             def toplevel_tag_start(name, attributes)
-                if name == 'depend'
+                if name == "depend"
                     parse_depend_tag(name, attributes)
-                elsif name == 'depend_optional'
+                elsif name == "depend_optional"
                     parse_depend_tag(name, attributes, optional: true)
-                elsif name == 'rosdep'
+                elsif name == "rosdep"
                     parse_depend_tag(name, attributes)
                 elsif name =~ /^(\w+)_depend$/
                     parse_depend_tag(name, attributes, modes: [$1])
-                elsif name == 'description'
-                    if (brief = attributes['brief'])
+                elsif name == "description"
+                    if (brief = attributes["brief"])
                         manifest.brief_description = brief
                     end
-                    @tag_text = ''
+                    @tag_text = ""
                 elsif TEXT_FIELDS.include?(name) || AUTHOR_FIELDS.include?(name)
-                    @tag_text = ''
-                elsif name == 'tags'
-                    @tag_text = ''
+                    @tag_text = ""
+                elsif name == "tags"
+                    @tag_text = ""
                 else
                     @tag_text = nil
                 end
@@ -242,8 +243,8 @@ module Autoproj
                 elsif TEXT_FIELDS.include?(name)
                     field = @tag_text.strip
                     manifest.send("#{name}=", field) unless field.empty?
-                elsif name == 'tags'
-                    manifest.tags.concat(@tag_text.strip.split(',').map(&:strip))
+                elsif name == "tags"
+                    manifest.tags.concat(@tag_text.strip.split(",").map(&:strip))
                 end
                 @tag_text = nil
             end
@@ -261,12 +262,12 @@ module Autoproj
 
             def toplevel_tag_start(name, attributes)
                 if DEPEND_TAGS.include?(name)
-                    @tag_text = ''
+                    @tag_text = ""
                 elsif TEXT_FIELDS.include?(name)
-                    @tag_text = ''
+                    @tag_text = ""
                 elsif AUTHOR_FIELDS.include?(name)
-                    @author_email = attributes['email']
-                    @tag_text = ''
+                    @author_email = attributes["email"]
+                    @tag_text = ""
                 else
                     @tag_text = nil
                 end

data/lib/autoproj/package_selection.rb

@@ -1,222 +1,222 @@
 module Autoproj
-        # Class holding information about which packages have been selected, and
-        # why. It is used to decide whether some non-availability of packages
-        # are errors or simply warnings (i.e. if the user really wants a given
-        # package, or merely might be adding it by accident)
-        class PackageSelection
-            include Enumerable
-
-            # The set of matches, i.e. a mapping from a user-provided string to
-            # the set of packages it selected
-            attr_reader :matches
-            # The set of selected packages, as a hash of the package name to the
-            # set of user-provided strings that caused that package to be
-            # selected
-            attr_reader :selection
-            # A flag that tells #filter_excluded_and_ignored_packages whether
-            # the a given package selection is weak or not.
-            #
-            # If true, a selection that have some excluded packages will not
-            # generate an error. Otherwise (the default), an error is generated
-            attr_reader :weak_dependencies
-            # After a call to #filter_excluded_and_ignored_packages, this
-            # contains the set of package exclusions that have been ignored
-            # because the corresponding metapackage has a weak dependency policy
-            attr_reader :exclusions
-            # After a call to #filter_excluded_and_ignored_packages, this
-            # contains the set of package ignores that have been ignored because
-            # the corresponding metapackage has a weak dependency policy
-            attr_reader :ignores
-            # The set of source packages that have been selected
-            attr_reader :source_packages
-            # The set of osdeps that have been selected
-            attr_reader :osdeps
-
-            def initialize
-                @selection = Hash.new { |h, k| h[k] = Set.new }
-                @matches = Hash.new { |h, k| h[k] = Set.new }
-                @weak_dependencies = Hash.new
-                @ignores = Hash.new { |h, k| h[k] = Set.new }
-                @exclusions = Hash.new { |h, k| h[k] = Set.new }
-                @source_packages = Set.new
-                @osdeps = Set.new
-            end
+    # Class holding information about which packages have been selected, and
+    # why. It is used to decide whether some non-availability of packages
+    # are errors or simply warnings (i.e. if the user really wants a given
+    # package, or merely might be adding it by accident)
+    class PackageSelection
+        include Enumerable
+
+        # The set of matches, i.e. a mapping from a user-provided string to
+        # the set of packages it selected
+        attr_reader :matches
+        # The set of selected packages, as a hash of the package name to the
+        # set of user-provided strings that caused that package to be
+        # selected
+        attr_reader :selection
+        # A flag that tells #filter_excluded_and_ignored_packages whether
+        # the a given package selection is weak or not.
+        #
+        # If true, a selection that have some excluded packages will not
+        # generate an error. Otherwise (the default), an error is generated
+        attr_reader :weak_dependencies
+        # After a call to #filter_excluded_and_ignored_packages, this
+        # contains the set of package exclusions that have been ignored
+        # because the corresponding metapackage has a weak dependency policy
+        attr_reader :exclusions
+        # After a call to #filter_excluded_and_ignored_packages, this
+        # contains the set of package ignores that have been ignored because
+        # the corresponding metapackage has a weak dependency policy
+        attr_reader :ignores
+        # The set of source packages that have been selected
+        attr_reader :source_packages
+        # The set of osdeps that have been selected
+        attr_reader :osdeps
+
+        def initialize
+            @selection = Hash.new { |h, k| h[k] = Set.new }
+            @matches = Hash.new { |h, k| h[k] = Set.new }
+            @weak_dependencies = Hash.new
+            @ignores = Hash.new { |h, k| h[k] = Set.new }
+            @exclusions = Hash.new { |h, k| h[k] = Set.new }
+            @source_packages = Set.new
+            @osdeps = Set.new
+        end
 
-            def include?(pkg_name)
-                selection.has_key?(pkg_name)
-            end
+        def include?(pkg_name)
+            selection.has_key?(pkg_name)
+        end
 
-            def empty?
-                selection.empty?
-            end
+        def empty?
+            selection.empty?
+        end
 
-            # Test if a package is in the ignore list
-            #
-            # @param [String] pkg_name Name of the package
-            # @return [Bool] true, if package is in the ignore list, false
-            # otherwise
-            def ignored?(pkg_name)
-                ignores.include?(pkg_name)
-            end
+        # Test if a package is in the ignore list
+        #
+        # @param [String] pkg_name Name of the package
+        # @return [Bool] true, if package is in the ignore list, false
+        # otherwise
+        def ignored?(pkg_name)
+            ignores.include?(pkg_name)
+        end
 
-            # Test if a package is in the exclusions list
-            #
-            # @param [String] pkg_name Name of the package
-            # @return [Bool] true, if package is in the exclusion list, false
-            # otherwise
-            def excluded?(pkg_name)
-                exclusions.include?(pkg_name)
-            end
+        # Test if a package is in the exclusions list
+        #
+        # @param [String] pkg_name Name of the package
+        # @return [Bool] true, if package is in the exclusion list, false
+        # otherwise
+        def excluded?(pkg_name)
+            exclusions.include?(pkg_name)
+        end
 
-            # Returns the source packages selected explicitely or through
-            # dependencies
-            #
-            # @param [Manifest] manifest
-            # @return [Array<PackageDefinition>]
-            def all_selected_source_packages(manifest)
-                names = Set.new
-                roots = each_source_package_name.to_set
-                roots.each do |pkg_name|
-                    manifest.find_autobuild_package(pkg_name).all_dependencies(names)
-                end
-                names.merge(roots).map do |pkg_name|
-                    manifest.find_package_definition(pkg_name)
-                end
+        # Returns the source packages selected explicitely or through
+        # dependencies
+        #
+        # @param [Manifest] manifest
+        # @return [Array<PackageDefinition>]
+        def all_selected_source_packages(manifest)
+            names = Set.new
+            roots = each_source_package_name.to_set
+            roots.each do |pkg_name|
+                manifest.find_autobuild_package(pkg_name).all_dependencies(names)
             end
-
-            # Returns the source packages selected explicitely or through
-            # dependencies
-            #
-            # @param [Manifest] manifest
-            # @return [Array<String>]
-            def all_selected_osdep_packages(manifest)
-                all_sources = all_selected_source_packages(manifest)
-                from_source = all_sources.each_with_object(Set.new) do |pkg, s|
-                    s.merge(pkg.autobuild.os_packages)
-                end
-                from_source | osdeps
+            names.merge(roots).map do |pkg_name|
+                manifest.find_package_definition(pkg_name)
             end
+        end
 
-            def each(&block)
-                Autoproj.warn_deprecated "PackageSelection#each", "use PackageSelection#each_source_package_name instead", 0
-                each_source_package_name(&block)
-            end
+        # Returns the source packages selected explicitely or through
+        # dependencies
+        #
+        # @param [Manifest] manifest
+        # @return [Array<String>]
+        def all_selected_osdep_packages(manifest)
+            all_sources = all_selected_source_packages(manifest)
+            from_source = all_sources.each_with_object(Set.new) do |pkg, s|
+                s.merge(pkg.autobuild.os_packages)
+            end
+            from_source | osdeps
+        end
 
-            def each_package_name(&block)
-                return enum_for(__method__) if !block
-                each_source_package_name(&block)
-                each_osdep_package_name(&block)
-            end
+        def each(&block)
+            Autoproj.warn_deprecated "PackageSelection#each", "use PackageSelection#each_source_package_name instead", 0
+            each_source_package_name(&block)
+        end
 
-            def selected_source_package?(pkg)
-                source_packages.include?(pkg.name)
-            end
+        def each_package_name(&block)
+            return enum_for(__method__) unless block
 
-            def each_source_package_name(&block)
-                source_packages.each(&block)
-            end
+            each_source_package_name(&block)
+            each_osdep_package_name(&block)
+        end
 
-            def each_osdep_package_name(&block)
-                osdeps.each(&block)
-            end
+        def selected_source_package?(pkg)
+            source_packages.include?(pkg.name)
+        end
 
-            def packages
-                Autoproj.warn_deprecated "PackageSelection#packages", "use PackageSelection#source_packages instead", 0
-                source_packages
-            end
+        def each_source_package_name(&block)
+            source_packages.each(&block)
+        end
 
-            def select(sel, packages, *_backward, weak: false, osdep: false)
-                unless _backward.empty?
-                    Autoproj.warn_deprecated "calling PackageSelection#select with a boolean as third argument", "use e.g. weak: true instead", 0
-                    weak = _backward.first
-                end
+        def each_osdep_package_name(&block)
+            osdeps.each(&block)
+        end
 
-                packages = Array(packages).to_set
-                matches[sel].merge(packages)
-                packages.each do |pkg_name|
-                    selection[pkg_name] << sel
-                end
-                if osdep
-                    osdeps.merge(packages)
-                else
-                    source_packages.merge(packages)
-                end
+        def packages
+            Autoproj.warn_deprecated "PackageSelection#packages", "use PackageSelection#source_packages instead", 0
+            source_packages
+        end
 
-                weak_dependencies[sel] = weak
+        def select(sel, packages, *_backward, weak: false, osdep: false)
+            unless _backward.empty?
+                Autoproj.warn_deprecated "calling PackageSelection#select with a boolean as third argument", "use e.g. weak: true instead", 0
+                weak = _backward.first
             end
 
-            def initialize_copy(old)
-                old.selection.each do |pkg_name, set|
-                    @selection[pkg_name] = set.dup
-                end
-                old.matches.each do |sel, set|
-                    @matches[sel] = set.dup
-                end
-                @source_packages = old.source_packages.dup
-                @osdeps = old.osdeps.dup
+            packages = Array(packages).to_set
+            matches[sel].merge(packages)
+            packages.each do |pkg_name|
+                selection[pkg_name] << sel
             end
-
-            def has_match_for?(sel)
-                matches.has_key?(sel)
+            if osdep
+                osdeps.merge(packages)
+            else
+                source_packages.merge(packages)
             end
 
-            def match_for(sel)
-                matches[sel]
+            weak_dependencies[sel] = weak
+        end
+
+        def initialize_copy(old)
+            old.selection.each do |pkg_name, set|
+                @selection[pkg_name] = set.dup
+            end
+            old.matches.each do |sel, set|
+                @matches[sel] = set.dup
             end
+            @source_packages = old.source_packages.dup
+            @osdeps = old.osdeps.dup
+        end
 
-            # Remove packages that are explicitely excluded and/or ignored
-            #
-            # Raise an error if an explicit selection expands only to an
-            # excluded package, and display a warning for ignored packages
-            def filter_excluded_and_ignored_packages(manifest)
-                matches.each do |sel, expansion|
-                    excluded, other = expansion.partition { |pkg_name| manifest.excluded?(pkg_name) }
-                    ignored,  ok    = other.partition { |pkg_name| manifest.ignored?(pkg_name) }
-
-                    if !excluded.empty? && (!weak_dependencies[sel] || (ok.empty? && ignored.empty?))
-                        exclusions = excluded.map do |pkg_name|
-                            [pkg_name, manifest.exclusion_reason(pkg_name)]
-                        end
-                        base_msg = "#{sel} is selected in the manifest or on the command line"
-                        if exclusions.size == 1
-                            reason = exclusions[0][1]
-                            if sel == exclusions[0][0]
-                                raise ExcludedSelection.new(sel), "#{base_msg}, but it is excluded from the build: #{reason}"
-                            elsif weak_dependencies[sel]
-                                raise ExcludedSelection.new(sel), "#{base_msg}, but it expands to #{exclusions.map(&:first).join(", ")}, which is excluded from the build: #{reason}"
-                            else
-                                raise ExcludedSelection.new(sel), "#{base_msg}, but its dependency #{exclusions.map(&:first).join(", ")} is excluded from the build: #{reason}"
-                            end
+        def has_match_for?(sel)
+            matches.has_key?(sel)
+        end
+
+        def match_for(sel)
+            matches[sel]
+        end
+
+        # Remove packages that are explicitely excluded and/or ignored
+        #
+        # Raise an error if an explicit selection expands only to an
+        # excluded package, and display a warning for ignored packages
+        def filter_excluded_and_ignored_packages(manifest)
+            matches.each do |sel, expansion|
+                excluded, other = expansion.partition { |pkg_name| manifest.excluded?(pkg_name) }
+                ignored,  ok    = other.partition { |pkg_name| manifest.ignored?(pkg_name) }
+
+                if !excluded.empty? && (!weak_dependencies[sel] || (ok.empty? && ignored.empty?))
+                    exclusions = excluded.map do |pkg_name|
+                        [pkg_name, manifest.exclusion_reason(pkg_name)]
+                    end
+                    base_msg = "#{sel} is selected in the manifest or on the command line"
+                    if exclusions.size == 1
+                        reason = exclusions[0][1]
+                        if sel == exclusions[0][0]
+                            raise ExcludedSelection.new(sel), "#{base_msg}, but it is excluded from the build: #{reason}"
                         elsif weak_dependencies[sel]
-                            raise ExcludedSelection.new(sel), "#{base_msg}, but expands to #{exclusions.map(&:first).join(", ")}, and all these packages are excluded from the build:\n  #{exclusions.map { |e_name, e_reason| "#{e_name}: #{e_reason}" }.join("\n  ")}"
+                            raise ExcludedSelection.new(sel), "#{base_msg}, but it expands to #{exclusions.map(&:first).join(', ')}, which is excluded from the build: #{reason}"
                         else
-                            raise ExcludedSelection.new(sel), "#{base_msg}, but it requires #{exclusions.map(&:first).join(", ")}, and all these packages are excluded from the build:\n  #{exclusions.map { |e_name, e_reason| "#{e_name}: #{e_reason}" }.join("\n  ")}"
+                            raise ExcludedSelection.new(sel), "#{base_msg}, but its dependency #{exclusions.map(&:first).join(', ')} is excluded from the build: #{reason}"
                         end
+                    elsif weak_dependencies[sel]
+                        raise ExcludedSelection.new(sel), "#{base_msg}, but expands to #{exclusions.map(&:first).join(', ')}, and all these packages are excluded from the build:\n  #{exclusions.map { |e_name, e_reason| "#{e_name}: #{e_reason}" }.join("\n  ")}"
                     else
-                        self.exclusions[sel] |= excluded.to_set.dup
-                        self.ignores[sel] |= ignored.to_set.dup
-                    end
-
-                    excluded = excluded.to_set
-                    ignored  = ignored.to_set
-                    expansion.delete_if do |pkg_name|
-                        ignored.include?(pkg_name) || excluded.include?(pkg_name)
+                        raise ExcludedSelection.new(sel), "#{base_msg}, but it requires #{exclusions.map(&:first).join(', ')}, and all these packages are excluded from the build:\n  #{exclusions.map { |e_name, e_reason| "#{e_name}: #{e_reason}" }.join("\n  ")}"
                     end
+                else
+                    self.exclusions[sel] |= excluded.to_set.dup
+                    ignores[sel] |= ignored.to_set.dup
                 end
 
-                source_packages.delete_if do |pkg_name|
-                    manifest.excluded?(pkg_name) || manifest.ignored?(pkg_name)
-                end
-                osdeps.delete_if do |pkg_name|
-                    manifest.excluded?(pkg_name) || manifest.ignored?(pkg_name)
-                end
-                selection.delete_if do |pkg_name, _|
-                    manifest.excluded?(pkg_name) || manifest.ignored?(pkg_name)
-                end
-                matches.delete_if do |key, sel|
-                    sel.empty?
+                excluded = excluded.to_set
+                ignored  = ignored.to_set
+                expansion.delete_if do |pkg_name|
+                    ignored.include?(pkg_name) || excluded.include?(pkg_name)
                 end
             end
+
+            source_packages.delete_if do |pkg_name|
+                manifest.excluded?(pkg_name) || manifest.ignored?(pkg_name)
+            end
+            osdeps.delete_if do |pkg_name|
+                manifest.excluded?(pkg_name) || manifest.ignored?(pkg_name)
+            end
+            selection.delete_if do |pkg_name, _|
+                manifest.excluded?(pkg_name) || manifest.ignored?(pkg_name)
+            end
+            matches.delete_if do |key, sel|
+                sel.empty?
+            end
         end
+    end
 end
-