autoproj 2.9.0 → 2.10.0

data/lib/autoproj/default.osdeps

@@ -162,6 +162,15 @@ pip:
   freebsd: pip
   default: ignore # assume pip will be installed by the user
 
+python:
+  arch: python2
+  debian,ubuntu: python-dev
+  fedora: python-devel
+  freebsd: python-devel
+  gentoo: dev-lang/python
+  opensuse: python-devel
+  default: ignore # will be installed manually by the user
+
 sudo:
   macos-brew: ignore
   default: sudo

data/lib/autoproj/manifest.rb

@@ -19,11 +19,11 @@ class Manifest
 
         # Loads the manifest file located at +file+ and returns the Manifest
         # instance that represents it
-	def self.load(file)
-	    manifest = Manifest.new
+        def self.load(file)
+            manifest = Manifest.new
             manifest.load(file)
             manifest
-	end
+        end
 
         # A normalized version of the layout as represented in the manifest file
         #
@@ -176,7 +176,7 @@ def initialize(ws, os_package_resolver: OSPackageResolver.new)
             @ws = ws
             @vcs = VCSDefinition.none
             @file = nil
-	    @data = Hash.new
+            @data = Hash.new
             @has_layout = false
             @normalized_layout = Hash.new
             @packages = Hash.new
@@ -198,7 +198,7 @@ def initialize(ws, os_package_resolver: OSPackageResolver.new)
 
             @constant_definitions = Hash.new
             @package_sets << LocalPackageSet.new(ws)
-	end
+        end
 
         # @api private
         #
@@ -994,7 +994,7 @@ def load_package_manifest(pkg)
 
             # Look for the package's manifest.xml, but fallback to a manifest in
             # the package set if present
-            if package.use_package_xml?
+            if package.use_package_xml? && package.checked_out?
                 manifest_path = File.join(package.srcdir, "package.xml")
                 raise NoPackageXML.new(package.srcdir), "#{package.name} from "\
                     "#{package_set.name} has use_package_xml set, but the package has "\

data/lib/autoproj/ops/build.rb

@@ -13,9 +13,9 @@ class Build
 
             # @param [String] report_dir the log directory in which to build
             #   the build report. If left to nil, no report will be generated
-            def initialize(manifest, report_dir: nil)
+            def initialize(manifest, report_path: nil)
                 @manifest = manifest
-                @report_dir = report_dir
+                @report_path = report_path
             end
 
             # Triggers a rebuild of all packages
@@ -92,22 +92,12 @@ def build_packages(all_enabled_packages, options = Hash.new)
                 begin
                     Autobuild.apply(all_enabled_packages, "autoproj-build", ['build'], options)
                 ensure
-                    build_report(all_enabled_packages) if @report_dir
+                    build_report(all_enabled_packages) if @report_path
                 end
             end
 
-            REPORT_BASENAME = "build_report.json"
-
-            # The path to the report file
-            #
-            # @return [String,nil] the path, or nil if the report should not
-            #    be generated
-            def report_path
-                File.join(@report_dir, REPORT_BASENAME) if @report_dir
-            end
-
             def build_report(package_list)
-                FileUtils.mkdir_p @report_dir
+                FileUtils.mkdir_p File.dirname(@report_path)
 
                 packages = package_list.map do |pkg_name|
                     pkg = manifest.find_autobuild_package(pkg_name)
@@ -130,7 +120,7 @@ def build_report(package_list)
                         packages: packages
                     }
                 })
-                IO.write(report_path, build_report)
+                IO.write(@report_path, build_report)
             end
         end
     end

data/lib/autoproj/ops/import.rb

@@ -73,7 +73,7 @@ def import_next_step(pkg, reverse_dependencies)
                 end
                 new_packages
             end
-            
+
             def pre_package_import(selection, manifest, pkg, reverse_dependencies)
                 # Try to auto-exclude the package early. If the autobuild file
                 # contained some information that allows us to exclude it now,
@@ -133,12 +133,30 @@ def install_vcs_packages_for(*packages, **osdeps_options)
                 vcs_to_install
             end
 
+            # Install the internal dependencies for the given packages
+            #
+            # @param [Hash] osdeps_options the options that will be passed to
+            #   {Workspace#install_os_packages}
+            # @return [Set] the set of installed OS packages
+            def install_internal_dependencies_for(*packages, **osdeps_options)
+                packages_to_install = packages.map do |pkg|
+                    pkg.autobuild.internal_dependencies
+                end.flatten.uniq
+                return if packages_to_install.empty?
+
+                # This assumes that the internal dependencies do not depend on a
+                # 'strict' package mangers such as e.g. BundlerManager and that
+                # the package manager itself does not have any dependencies
+                ws.install_os_packages(packages_to_install, all: nil, **osdeps_options)
+                packages_to_install
+            end
+
             # @api private
             #
             # Queue the work necessary to import the given package, making sure
             # that the execution results end up in a given queue
             #
-            # @param executor the future executor 
+            # @param executor the future executor
             # @param [Queue] completion_queue the queue where the completion
             #   results should be pushed, as a (package, time, result,
             #   error_reason) tuple
@@ -331,7 +349,7 @@ def import_selected_packages(selection,
                     executor.wait_for_termination
                 end
             end
-            
+
             def finalize_package_load(processed_packages, auto_exclude: auto_exclude?)
                 manifest = ws.manifest
 
@@ -405,6 +423,7 @@ def import_packages(selection,
                     raise failures.first
                 end
 
+                install_internal_dependencies_for(*all_processed_packages)
                 finalize_package_load(all_processed_packages, auto_exclude: auto_exclude)
 
                 all_enabled_osdeps = selection.each_osdep_package_name.to_set

data/lib/autoproj/ops/install.rb

@@ -229,6 +229,9 @@ def parse_options(args = ARGV)
                     opt.on '--skip-stage2', 'do not run the stage2 install' do
                         @skip_stage2 = true
                     end
+                    opt.on '--debug', 'Run in debug mode' do
+                        @autoproj_options << '--debug'
+                    end
                     opt.on '--gem-source=URL', String, "use this source for RubyGems "\
                         "instead of rubygems.org" do |url|
                         @gem_source = url
@@ -265,19 +268,25 @@ def parse_options(args = ARGV)
                     end
                     opt.on '--[no-]color', 'do not use colored output (enabled by "\
                         "default if the terminal supports it)' do |color|
-                        if color then autoproj_options << "--color"
-                        else autoproj_options << '--no-color'
+                        if color then @autoproj_options << "--color"
+                        else @autoproj_options << '--no-color'
                         end
                     end
                     opt.on '--[no-]progress', 'do not use progress output (enabled by "\
-                        "default if the terminal supports it)' do |color|
-                        if color then autoproj_options << "--progress"
-                        else autoproj_options << '--no-progress'
+                        "default if the terminal supports it)' do |progress|
+                        if progress then @autoproj_options << "--progress"
+                        else @autoproj_options << '--no-progress'
+                        end
+                    end
+                    opt.on '--[no-]interactive', 'if non-interactive, use default "\
+                           "answer for questions' do |flag|
+                        if flag then @autoproj_options << "--interactive"
+                        else @autoproj_options << "--no-interactive"
                         end
                     end
                 end
                 args = options.parse(ARGV)
-                autoproj_options + args
+                @autoproj_options + args
             end
 
             def find_bundler(gem_program)
@@ -667,7 +676,7 @@ def autoproj_path
 
             def run_autoproj(*args)
                 system env_for_child.merge('BUNDLE_GEMFILE' => autoproj_gemfile_path),
-                    Gem.ruby, autoproj_path, *args, *autoproj_options
+                    Gem.ruby, autoproj_path, *args, *@autoproj_options
             end
 
             def v1_workspace?
@@ -691,7 +700,7 @@ def call_stage2
                 clean_env = env_for_child
                 stage2_vars = clean_env.map { |k, v| "#{k}=#{v}" }
                 puts "starting the newly installed autoproj for stage2 install"
-                if !run_autoproj('install-stage2', root_dir, *stage2_vars)
+                if !run_autoproj('install-stage2', root_dir, *stage2_vars, *@autoproj_options)
                     raise "failed to execute autoproj install-stage2"
                 end
             end
@@ -701,7 +710,7 @@ def stage2(*vars)
                 puts "saving temporary env.sh and .autoproj/env.sh"
                 save_env_sh(*vars)
                 puts "running 'autoproj envsh' to generate a proper env.sh"
-                if !system(Gem.ruby, autoproj_path, 'envsh', *autoproj_options)
+                if !system(Gem.ruby, autoproj_path, 'envsh', *@autoproj_options)
                     STDERR.puts "failed to run autoproj envsh on the newly installed "\
                         "autoproj (#{autoproj_path})"
                     exit 1
@@ -709,7 +718,7 @@ def stage2(*vars)
                 # This is really needed on an existing install to install the
                 # gems that were present in the v1 layout
                 puts "running 'autoproj osdeps' to re-install missing gems"
-                if !system(Gem.ruby, autoproj_path, 'osdeps')
+                if !system(Gem.ruby, autoproj_path, 'osdeps', *@autoproj_options)
                     STDERR.puts "failed to run autoproj osdeps on the newly installed "\
                         "autoproj (#{autoproj_path})"
                     exit 1

data/lib/autoproj/ops/main_config_switcher.rb

@@ -16,16 +16,20 @@ def initialize(ws)
             EXPECTED_ROOT_ENTRIES = [".", "..", "autoproj_bootstrap",
                                      ".autoproj", "bootstrap.sh", ENV_FILENAME].to_set
 
+
+            def check_root_dir_empty?
+                (ENV['AUTOPROJ_NONINTERACTIVE'] != '1') &&
+                    (ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] != '1')
+            end
+
             # Verifies that {#root_dir} contains only expected entries, to make
             # sure that the user bootstraps into a new directory
             #
             # If the environment variable AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR
             # is set to 1, the check is skipped
             def check_root_dir_empty
-                return if ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] == '1'
-
                 require 'set'
-                curdir_entries = Dir.entries(ws.root_dir).map { |p| File.basename(p) }.to_set - 
+                curdir_entries = Dir.entries(ws.root_dir).map { |p| File.basename(p) }.to_set -
                     EXPECTED_ROOT_ENTRIES
                 return if curdir_entries.empty?
 
@@ -73,8 +77,10 @@ def validate_autoproj_current_root(reuse)
 
             MAIN_CONFIGURATION_TEMPLATE = File.expand_path(File.join("..", "..", "..", "samples", 'autoproj'), File.dirname(__FILE__))
 
-            def bootstrap(buildconf_info, reuse: Array.new)
-                check_root_dir_empty
+            def bootstrap(buildconf_info,
+                          check_root_dir_empty: check_root_dir_empty?,
+                          reuse: Array.new)
+                self.check_root_dir_empty if check_root_dir_empty
                 validate_autoproj_current_root(reuse)
 
                 ws.config.validate_ruby_executable
@@ -179,7 +185,7 @@ def do_switch_config(delete_current, type, url, *options)
                         backup_name = "#{backup_base_name}-#{index}.bak"
                         index += 1
                     end
-                        
+
                     FileUtils.mv config_dir, backup_name
                 end
 

data/lib/autoproj/ops/snapshot.rb

@@ -117,7 +117,7 @@ def error_or_warn(package, error)
             end
         end
 
-        def snapshot_packages(packages, target_dir = nil, only_local: true)
+        def snapshot_packages(packages, target_dir = nil, only_local: true, fingerprint: false)
             result = Array.new
             packages.each do |package_name|
                 package  = manifest.find_package_definition(package_name)
@@ -140,6 +140,10 @@ def snapshot_packages(packages, target_dir = nil, only_local: true)
                         next
                     end
 
+                if fingerprint
+                    vcs_info['fingerprint'] = package.autobuild.fingerprint
+                end
+
                 if vcs_info
                     result << Hash[package_name, vcs_info]
                 else

data/lib/autoproj/os_package_resolver.rb

@@ -5,31 +5,35 @@ module Autoproj
     # Manager for packages provided by external package managers
     class OSPackageResolver
         def self.load(file, suffixes: [], **options)
-	    if !File.file?(file)
-		raise ArgumentError, "no such file or directory #{file}"
-	    end
+            unless File.file?(file)
+                raise ArgumentError, "no such file or directory #{file}"
+            end
+
+            candidates = [file]
+            candidates.concat(suffixes.map { |s| "#{file}-#{s}" })
 
-	    candidates = [file]
-	    candidates.concat(suffixes.map { |s| "#{file}-#{s}" })
+            error_t =
+                if defined? Psych::SyntaxError
+                    [ArgumentError, Psych::SyntaxError]
+                else ArgumentError
+                end
 
-            error_t = if defined? Psych::SyntaxError then [ArgumentError, Psych::SyntaxError]
-                      else ArgumentError
-                      end
+            result = new(**options)
+            candidates.each do |file_candidate|
+                next unless File.file?(file_candidate)
 
-	    result = new(**options)
-	    candidates.each do |file_candidate|
-                next if !File.file?(file_candidate)
                 file_candidate = File.expand_path(file_candidate)
                 begin
-                    data = YAML.load(File.read(file_candidate)) || Hash.new
+                    data = YAML.safe_load(File.read(file_candidate)) || Hash.new
                     verify_definitions(data)
                 rescue *error_t => e
-                    raise ConfigError.new, "error in #{file_candidate}: #{e.message}", e.backtrace
+                    raise ConfigError.new, "error in #{file_candidate}: "\
+                        "#{e.message}", e.backtrace
                 end
 
                 result.merge(new(data, file_candidate, **options))
-	    end
-	    result
+            end
+            result
         end
 
         # The underlying workspace
@@ -43,11 +47,12 @@ def self.autodetect_ruby_program
             ruby_executable
         end
 
-        AUTOPROJ_OSDEPS = File.join(File.expand_path(File.dirname(__FILE__)), 'default.osdeps')
+        AUTOPROJ_OSDEPS = File.join(__dir__, 'default.osdeps')
         def self.load_default
             file = ENV['AUTOPROJ_DEFAULT_OSDEPS'] || AUTOPROJ_OSDEPS
-            if !File.file?(file)
-                Autoproj.warn "#{file} (from AUTOPROJ_DEFAULT_OSDEPS) is not a file, falling back to #{AUTOPROJ_OSDEPS}"
+            unless File.file?(file)
+                Autoproj.warn "#{file} (from AUTOPROJ_DEFAULT_OSDEPS) is not a file, "\
+                    "falling back to #{AUTOPROJ_OSDEPS}"
                 file = AUTOPROJ_OSDEPS
             end
             load(file)
@@ -58,7 +63,7 @@ def load_default
         end
 
         PACKAGE_MANAGERS = OSPackageInstaller::PACKAGE_MANAGERS.keys
-        
+
         # Mapping from OS name to package manager name
         #
         # Package handlers and OSes MUST have different names. The former are
@@ -71,15 +76,15 @@ def load_default
         #
         # we need to be able to separate between OS and package manager names.
         OS_PACKAGE_MANAGERS = {
-            'debian'     => 'apt-dpkg',
-            'gentoo'     => 'emerge',
-            'arch'       => 'pacman',
-            'fedora'     => 'yum',
+            'debian' => 'apt-dpkg',
+            'gentoo' => 'emerge',
+            'arch' => 'pacman',
+            'fedora' => 'yum',
             'macos-port' => 'macports',
             'macos-brew' => 'brew',
-            'opensuse'   => 'zypper',
-            'freebsd'    => 'pkg'
-        }
+            'opensuse' => 'zypper',
+            'freebsd' => 'pkg'
+        }.freeze
 
         # The information contained in the OSdeps files, as a hash
         attr_reader :definitions
@@ -93,16 +98,20 @@ def load_default
         # Controls whether the package resolver will prefer installing
         # OS-independent packages (such as e.g. Gems) over their OS-provided
         # equivalent (e.g. the packaged version of a gem)
-        def prefer_indep_over_os_packages?; !!@prefer_indep_over_os_packages end
+        def prefer_indep_over_os_packages?
+            @prefer_indep_over_os_packages
+        end
         # (see prefer_indep_over_os_packages?)
-        def prefer_indep_over_os_packages=(flag); @prefer_indep_over_os_packages = flag end
+        attr_writer :prefer_indep_over_os_packages
         # Cached results of {#resolve_package}
         attr_reader :resolve_package_cache
 
         # Use to override the autodetected OS-specific package handler
         def os_package_manager=(manager_name)
             if manager_name && !package_managers.include?(manager_name)
-                raise ArgumentError, "#{manager_name} is not a known package manager, known managers are #{package_managers.to_a.sort.join(", ")}"
+                raise ArgumentError, "#{manager_name} is not a known "\
+                    "package manager, known managers are "\
+                    "#{package_managers.to_a.sort.join(', ')}"
             end
             @os_package_manager = manager_name
         end
@@ -111,13 +120,12 @@ def os_package_manager=(manager_name)
         #
         # @return [String]
         def os_package_manager
-            if !@os_package_manager
-                os_names, _ = operating_system
+            unless @os_package_manager
+                os_names, = operating_system
                 os_name = os_names.find { |name| OS_PACKAGE_MANAGERS[name] }
-                @os_package_manager = OS_PACKAGE_MANAGERS[os_name] ||
-                    'unknown'
+                @os_package_manager = OS_PACKAGE_MANAGERS[os_name] || 'unknown'
             end
-            return @os_package_manager
+            @os_package_manager
         end
 
         # Returns the set of known package managers
@@ -143,7 +151,7 @@ def initialize(defs = Hash.new, file = nil,
             @prefer_indep_over_os_packages = false
             @aliases = Hash.new
 
-            @sources     = Hash.new
+            @sources = Hash.new
             @installed_packages = Set.new
             @operating_system = operating_system
             @supported_operating_system = nil
@@ -195,57 +203,58 @@ def invalidate_resolve_package_cache
         # takes precedence
         def merge(info, suffixes: [])
             @definitions = definitions.merge(info.definitions) do |h, v1, v2|
-                if v1 != v2
-                    warn_about_merge_collisions(info, suffixes, h, v1, v2)
-                end
+                warn_about_merge_collisions(info, suffixes, h, v1, v2) if v1 != v2
                 v2
             end
             invalidate_resolve_package_cache
 
             @sources = sources.merge(info.sources)
-            @all_definitions = all_definitions.merge(info.all_definitions) do |package_name, all_defs, new_all_defs|
-                all_defs = all_defs.dup
-                new_all_defs = new_all_defs.dup
-                new_all_defs.delete_if do |files, data|
-                    if entry = all_defs.find { |_, d| d == data }
-                        entry[0] |= files
+            @all_definitions = all_definitions.
+                merge(info.all_definitions) do |_package_name, all_defs, new_all_defs|
+                    all_defs = all_defs.dup
+                    new_all_defs = new_all_defs.dup
+                    new_all_defs.delete_if do |files, data|
+                        if (entry = all_defs.find { |_, d| d == data })
+                            entry[0] |= files
+                        end
                     end
+                    all_defs.concat(new_all_defs)
                 end
-                all_defs.concat(new_all_defs)
-            end
         end
 
         # @api private
         #
         # Warn about a collision (override) detected during #merge
-        def warn_about_merge_collisions(merged_info, suffixes, key, old_value, new_value)
+        def warn_about_merge_collisions(merged_info, suffixes, key,
+                                        _old_value, _new_value)
             old = source_of(key)
             new = merged_info.source_of(key)
 
-            if suffixes.any? { |s| "#{old}#{s}" == new }
-                return
-            end
+            return if suffixes.any? { |s| new == "#{old}#{s}" }
 
             # Warn if the new osdep definition resolves to a different
             # set of packages than the old one
-            old_resolved = resolve_package(key, resolve_recursive: false).inject(Hash.new) do |osdep_h, (handler, status, list)|
-                osdep_h[handler] = [status, list.dup]
-                osdep_h
-            end
-            new_resolved = merged_info.resolve_package(key, resolve_recursive: false).inject(Hash.new) do |osdep_h, (handler, status, list)|
-                osdep_h[handler] = [status, list.dup]
-                osdep_h
-            end
+            old_resolved = resolve_package(key, resolve_recursive: false).
+                each_with_object(Hash.new) do |(handler, status, list), osdep_h|
+                    osdep_h[handler] = [status, list.dup]
+                end
+            new_resolved = merged_info.resolve_package(key, resolve_recursive: false).
+                each_with_object(Hash.new) do |(handler, status, list), osdep_h|
+                    osdep_h[handler] = [status, list.dup]
+                end
             if old_resolved != new_resolved
-                Autoproj.warn "osdeps definition for #{key}, previously defined in #{old} overridden by #{new}:"
+                Autoproj.warn "osdeps definition for #{key}, "\
+                    "previously defined in #{old} overridden by #{new}:"
                 first = true
                 old_resolved.each do |handler, (_, packages)|
-                    Autoproj.warn "  #{first ? 'resp. ' : '      '}#{handler}: #{packages.map(&:to_s).join(", ")}"
+                    Autoproj.warn "  #{first ? 'resp. ' : '      '}#{handler}: "\
+                        "#{packages.map(&:to_s).join(', ')}"
                     first = false
                 end
                 first = true
                 new_resolved.each do |handler, (_, packages)|
-                    Autoproj.warn "  #{first ? 'and   ' : '      '}#{handler}: #{packages.map(&:to_s).join(", ")}"
+                    Autoproj.warn "  #{first ? 'and   ' : '      '}#{handler}: "\
+                        "#{packages.map(&:to_s).join(', ')}"
                     first = false
                 end
             end
@@ -255,25 +264,27 @@ def warn_about_merge_collisions(merged_info, suffixes, key, old_value, new_value
         def self.verify_definitions(hash, path = [])
             hash.each do |key, value|
                 if value && !key.kind_of?(String)
-                    raise ArgumentError, "invalid osdeps definition: found an #{key.class} as a key in #{path.join("/")}. Don't forget to put quotes around numbers"
+                    raise ArgumentError, "invalid osdeps definition: "\
+                        "found an #{key.class} as a key in #{path.join('/')}. "\
+                        "Don't forget to put quotes around numbers"
                 elsif !value && (key.kind_of?(Hash) || key.kind_of?(Array))
                     verify_definitions(key)
                 end
-                next if !value
+                next unless value
 
                 if value.kind_of?(Array) || value.kind_of?(Hash)
                     verify_definitions(value, (path + [key]))
-                else
-                    if !value.kind_of?(String)
-                        raise ArgumentError, "invalid osdeps definition: found an #{value.class} as a value in #{path.join("/")}. Don't forget to put quotes around numbers"
-                    end
+                elsif !value.kind_of?(String)
+                    raise ArgumentError, "invalid osdeps definition: "\
+                        "found an #{value.class} as a value in #{path.join('/')}. "\
+                        "Don't forget to put quotes around numbers"
                 end
             end
         end
 
         # Whether the operating system could be autodetected successfully
         def known_operating_system?
-            os_names, _ = operating_system
+            os_names, = operating_system
             !os_names.empty?
         end
 
@@ -283,24 +294,20 @@ def supported_operating_system?
             if @supported_operating_system.nil?
                 @supported_operating_system = (os_package_manager != 'unknown')
             end
-            return @supported_operating_system
+            @supported_operating_system
         end
 
         def self.guess_operating_system
             if File.exist?('/etc/debian_version')
                 versions = [File.read('/etc/debian_version').strip]
-                if versions.first =~ /sid/
-                    versions = ["unstable", "sid"]
-                end
+                versions = %w[unstable sid] if versions.first =~ /sid/
                 [['debian'], versions]
             elsif File.exist?('/etc/redhat-release')
                 release_string = File.read('/etc/redhat-release').strip
                 release_string =~ /(.*) release ([\d.]+)/
                 name = $1.downcase
                 version = $2
-                if name =~ /Red Hat Entreprise/
-                    name = 'rhel'
-                end
+                name = 'rhel' if name =~ /Red Hat Entreprise/
                 [[name], [version]]
             elsif File.exist?('/etc/gentoo-release')
                 release_string = File.read('/etc/gentoo-release').strip
@@ -309,19 +316,19 @@ def self.guess_operating_system
                 [['gentoo'], [version]]
             elsif File.exist?('/etc/arch-release')
                 [['arch'], []]
-            elsif Autobuild.macos? 
-                version=`sw_vers | head -2 | tail -1`.split(":")[1]
+            elsif Autobuild.macos?
+                version = `sw_vers | head -2 | tail -1`.split(":")[1]
                 manager =
-                    if ENV['AUTOPROJ_MACOSX_PACKAGE_MANAGER']
-                        ENV['AUTOPROJ_MACOSX_PACKAGE_MANAGER']
-                    else 'macos-brew'
-                    end
-                if !OS_PACKAGE_MANAGERS.has_key?(manager)
+                    ENV['AUTOPROJ_MACOSX_PACKAGE_MANAGER'] ||
+                    'macos-brew'
+                unless OS_PACKAGE_MANAGERS.key?(manager)
                     known_managers = OS_PACKAGE_MANAGERS.keys.grep(/^macos/)
-                    raise ArgumentError, "#{manager} is not a known MacOSX package manager. Known package managers are #{known_managers.join(", ")}"
+                    raise ArgumentError, "#{manager} is not a known MacOSX "\
+                        "package manager. Known package managers are "\
+                        "#{known_managers.join(', ')}"
                 end
 
-                managers = 
+                managers =
                     if manager == 'macos-port'
                         [manager, 'port']
                     else [manager]
@@ -331,12 +338,12 @@ def self.guess_operating_system
                 [['windows'], []]
             elsif File.exist?('/etc/SuSE-release')
                 version = File.read('/etc/SuSE-release').strip
-                version =~/.*VERSION\s+=\s+([^\s]+)/
+                version =~ /.*VERSION\s+=\s+([^\s]+)/
                 version = $1
                 [['opensuse'], [version.strip]]
-            elsif Autobuild.freebsd? 
-		version = `uname -r`.strip.split("-")[0]
-		[['freebsd'],[version]]
+            elsif Autobuild.freebsd?
+                version = `uname -r`.strip.split("-")[0]
+                [['freebsd'], [version]]
             end
         end
 
@@ -349,21 +356,17 @@ def self.ensure_derivatives_refer_to_their_parents(names)
                 '/etc/arch-release' => 'arch',
                 '/etc/SuSE-release' => 'opensuse']
             version_files.each do |file, name|
-                if File.exist?(file) && !names.include?(name)
-                    names << name
-                end
+                names << name if File.exist?(file) && !names.include?(name)
             end
             names
         end
-        
+
         def self.normalize_os_representation(names, versions)
             # Normalize the names to lowercase
             names    = names.map(&:downcase)
             versions = versions.map(&:downcase)
-            if !versions.include?('default')
-                versions += ['default']
-            end
-            return names, versions
+            versions += ['default'] unless versions.include?('default')
+            [names, versions]
         end
 
         # The operating system self is targetting
@@ -392,20 +395,18 @@ def operating_system=(values)
         #
         # Examples: ['debian', ['sid', 'unstable']] or ['ubuntu', ['lucid lynx', '10.04']]
         def self.autodetect_operating_system
-            if user_os = ENV['AUTOPROJ_OS']
+            if (user_os = ENV['AUTOPROJ_OS'])
                 if user_os.empty?
                     return false
                 else
                     names, versions = user_os.split(':')
-                    return normalize_os_representation(names.split(','), versions.split(','))
+                    return normalize_os_representation(
+                        names.split(','), versions.split(','))
                 end
             end
 
             names, versions = os_from_os_release
-
-            if !names
-                names, versions = guess_operating_system
-            end
+            names, versions = guess_operating_system unless names
 
             # on Debian, they refuse to put enough information to detect
             # 'unstable' reliably. So, we use the heuristic method for it
@@ -416,21 +417,19 @@ def self.autodetect_operating_system
                 # phase...
                 if File.exist?('/etc/debian_version')
                     debian_versions = [File.read('/etc/debian_version').strip]
-                    if debian_versions.first =~ /sid/
-                        versions = ["unstable", "sid"]
-                    end
+                    versions = %w[unstable sid] if debian_versions.first =~ /sid/
                 end
                 # otherwise "versions" contains the result it previously had
             end
-            return if !names
+            return unless names
 
             names = ensure_derivatives_refer_to_their_parents(names)
             names, versions = normalize_os_representation(names, versions)
-            return [names, versions]
+            [names, versions]
         end
 
         def self.os_from_os_release(filename = '/etc/os-release')
-            return if !File.exist?(filename)
+            return unless File.exist?(filename)
 
             fields = Hash.new
             File.readlines(filename).each do |line|
@@ -438,7 +437,8 @@ def self.os_from_os_release(filename = '/etc/os-release')
                 if line.strip =~ /^(\w+)=(?:["'])?([^"']+)(?:["'])?$/
                     fields[$1] = $2
                 elsif !line.empty?
-                    Autoproj.warn "could not parse line '#{line.inspect}' in /etc/os-release"
+                    Autoproj.warn "could not parse line '#{line.inspect}' "\
+                        "in /etc/os-release"
                 end
             end
 
@@ -448,19 +448,17 @@ def self.os_from_os_release(filename = '/etc/os-release')
             versions << fields['VERSION_ID']
             version = fields['VERSION'] || ''
             versions.concat(version.gsub(/[^\w.]/, ' ').split(' '))
-            return names.compact.uniq, versions.compact.uniq
+            [names.compact.uniq, versions.compact.uniq]
         end
 
         def self.os_from_lsb
-            if !Autobuild.find_in_path('lsb_release')
-                return
-            end
+            return unless Autobuild.find_in_path('lsb_release')
 
             distributor = [`lsb_release -i -s`.strip.downcase]
             codename    = `lsb_release -c -s`.strip.downcase
             version     = `lsb_release -r -s`.strip.downcase
 
-            return [distributor, [codename, version]]
+            [distributor, [codename, version]]
         end
 
         class InvalidRecursiveStatement < Autobuild::Exception; end
@@ -471,8 +469,8 @@ class InvalidRecursiveStatement < Autobuild::Exception; end
         # returns an array contain the path starting with name and
         # ending at the resolved name
         def resolve_name(name)
-            path = [ name ]
-            while aliases.has_key?(name)
+            path = [name]
+            while aliases.key?(name)
                 name = aliases[name]
                 path << name
             end
@@ -482,7 +480,9 @@ def resolve_name(name)
         # Null object class that is used to mark recursive resolution when
         # calling {#resolve_package} with resolve_recursive set to false
         class OSDepRecursiveResolver
-            def self.to_s; 'osdep' end
+            def self.to_s
+                'osdep'.freeze
+            end
         end
 
         # Return the list of packages that should be installed for +name+
@@ -503,17 +503,13 @@ def self.to_s; 'osdep' end
         # name and version. The package list might be empty even if status ==
         # FOUND_PACKAGES, for instance if the ignore keyword is used.
         def resolve_package(name, resolve_recursive: true)
-            if resolve_package_cache.has_key?(name)
-                return resolve_package_cache[name]
-            end
+            return resolve_package_cache[name] if resolve_package_cache.key?(name)
 
             path = resolve_name(name)
             name = path.last
 
             dep_def = definitions[name]
-            if !dep_def
-                return (resolve_package_cache[name] = nil)
-            end
+            return (resolve_package_cache[name] = nil) unless dep_def
 
             os_names, os_versions = operating_system
 
@@ -534,27 +530,28 @@ def resolve_package(name, resolve_recursive: true)
             end
 
             result = []
-            found, pkg = partition_osdep_entry(name, dep_def, nil,
-                                               (package_managers - [os_package_manager]), os_names, os_versions)
-            if found
-                result << [os_package_manager, found, pkg]
-            end
+            found, pkg = partition_osdep_entry(
+                name, dep_def, nil,
+                (package_managers - [os_package_manager]), os_names, os_versions)
+            result << [os_package_manager, found, pkg] if found
 
             package_managers.each do |handler|
-                found, pkg = partition_osdep_entry(name, dep_def, [handler], [], os_names, os_versions)
-                if found
-                    result << [handler, found, pkg]
-                end
+                found, pkg = partition_osdep_entry(
+                    name, dep_def, [handler], [], os_names, os_versions)
+                result << [handler, found, pkg] if found
             end
 
             # Recursive resolutions
-            found, pkg = partition_osdep_entry(name, dep_def, ['osdep'], [], os_names, os_versions)
+            found, pkg = partition_osdep_entry(
+                name, dep_def, ['osdep'], [], os_names, os_versions)
             if found
                 if resolve_recursive
                     pkg.each do |pkg_name|
                         resolved = resolve_package(pkg_name)
-                        if !resolved
-                            raise InvalidRecursiveStatement, "the '#{name}' osdep refers to another osdep, '#{pkg_name}', which does not seem to exist"
+                        unless resolved
+                            raise InvalidRecursiveStatement, "the '#{name}' osdep "\
+                                "refers to another osdep, '#{pkg_name}', which "\
+                                "does not seem to exist"
                         end
                         result.concat(resolved)
                     end
@@ -641,66 +638,20 @@ def partition_osdep_entry(osdep_name, dep_def, handler_names, excluded, *keys)
             found_keys = Hash.new
             Array(dep_def).each do |names, values|
                 if !values
-                    # Raw array of packages. Possible only if we are not at toplevel
-                    # (i.e. if we already have a handler)
-                    if names == 'ignore'
-                        found = true if !handler_names
-                    elsif names == 'nonexistent'
-                        nonexistent = true if !handler_names
-                    elsif !handler_names && names.kind_of?(Array)
-                        result.concat(result)
-                        found = true
-                    elsif names.respond_to?(:to_str)
-                        if excluded.include?(names)
-                        elsif handler_names && handler_names.include?(names)
-                            result << osdep_name
-                            found = true
-                        elsif !handler_names
-                            result << names
-                            found = true
-                        end
-                    elsif names.respond_to?(:to_hash)
-                        rec_found, rec_result = partition_osdep_entry(osdep_name, names, handler_names, excluded, keys, *additional_keys)
-                        if rec_found == FOUND_NONEXISTENT then nonexistent = true
-                        elsif rec_found == FOUND_PACKAGES then found = true
-                        end
-                        result.concat(rec_result)
-                    end
+                    entry_found, entry_nonexistent, entry_names =
+                        partition_osdep_raw_array_entry(names, osdep_name,
+                            handler_names, excluded, keys, additional_keys)
                 else
-                    if names.respond_to?(:to_str) # names could be an array already
-                        names = names.split(',')
-                    end
-
-                    if handler_names
-                        if matching_name = handler_names.find { |k| names.any? { |name_tag| k == name_tag.downcase } }
-                            rec_found, rec_result = partition_osdep_entry(osdep_name, values, nil, excluded, keys, *additional_keys)
-                            if rec_found == FOUND_NONEXISTENT then nonexistent = true
-                            elsif rec_found == FOUND_PACKAGES then found = true
-                            end
-                            result.concat(rec_result)
-                        end
-                    end
-
-                    matching_name = keys.find { |k| names.any? { |name_tag| k == name_tag.downcase } }
-                    if matching_name
-                        rec_found, rec_result = partition_osdep_entry(osdep_name, values, handler_names, excluded, *additional_keys)
-                        # We only consider the first highest-priority entry,
-                        # regardless of whether it has some packages for us or
-                        # not
-                        idx = keys.index(matching_name)
-                        if !rec_found
-                            if !found_keys.has_key?(idx)
-                                found_keys[idx] = nil
-                            end
-                        else
-                            found_keys[idx] ||= [0, []]
-                            found_keys[idx][0] += rec_found
-                            found_keys[idx][1].concat(rec_result)
-                        end
-                    end
+                    entry_found, entry_nonexistent, entry_names =
+                        partition_osdep_map_entry(names, values, osdep_name,
+                            handler_names, excluded, keys, found_keys, additional_keys)
                 end
+                found ||= entry_found
+                nonexistent ||= entry_nonexistent
+                result.concat(entry_names)
             end
-            first_entry = found_keys.keys.sort.first
+
+            first_entry = found_keys.keys.min
             found_keys = found_keys[first_entry]
             if found_keys
                 if found_keys[0] > 0
@@ -717,13 +668,91 @@ def partition_osdep_entry(osdep_name, dep_def, handler_names, excluded, *keys)
                 else false
                 end
 
-            return found, result
+            [found, result]
+        end
+
+        def partition_osdep_raw_array_entry(names, osdep_name, handler_names,
+                                            excluded, keys, additional_keys)
+            have_handler_names = true if handler_names
+
+            # Raw array of packages. Possible only if we are not at toplevel
+            # (i.e. if we already have a handler)
+            if names == 'ignore'
+                [!have_handler_names, false, []]
+            elsif names == 'nonexistent'
+                [false, !have_handler_names, []]
+            elsif !handler_names && names.kind_of?(Array)
+                [true, false, names]
+            elsif names.respond_to?(:to_str)
+                if excluded.include?(names)
+                    [false, false, []]
+                elsif handler_names&.include?(names)
+                    [true, false, [osdep_name]]
+                elsif !handler_names
+                    [true, false, [names]]
+                else
+                    [false, false, []]
+                end
+            elsif names.respond_to?(:to_hash)
+                rec_found, rec_result = partition_osdep_entry(osdep_name,
+                    names, handler_names, excluded, keys, *additional_keys)
+                if rec_found == FOUND_NONEXISTENT
+                    [false, true, rec_result]
+                elsif rec_found == FOUND_PACKAGES
+                    [true, false, rec_result]
+                else
+                    [false, false, []]
+                end
+            else
+                [false, false, []]
+            end
+        end
+
+        def partition_osdep_map_entry(names, values, osdep_name, handler_names,
+                                      excluded, keys, found_keys, additional_keys)
+            # names could be an array already
+            names = names.split(',') if names.respond_to?(:to_str)
+            result = [false, false, []]
+
+            if handler_names
+                matching_handler = handler_names.
+                    find { |k| names.any? { |name_tag| k == name_tag.downcase } }
+                if matching_handler
+                    rec_found, rec_result = partition_osdep_entry(
+                        osdep_name, values, nil, excluded, keys, *additional_keys)
+                    if rec_found == FOUND_NONEXISTENT
+                        result = [false, true, rec_result]
+                    elsif rec_found == FOUND_PACKAGES
+                        result = [true, false, rec_result]
+                    end
+                end
+            end
+
+            matching_name = keys.
+                find { |k| names.any? { |name_tag| k == name_tag.downcase } }
+            return result unless matching_name
+
+            rec_found, rec_result = partition_osdep_entry(
+                osdep_name, values, handler_names, excluded, *additional_keys)
+            # We only consider the first highest-priority entry,
+            # regardless of whether it has some packages for us or
+            # not
+            idx = keys.index(matching_name)
+            if !rec_found
+                found_keys[idx] = nil unless found_keys.key?(idx)
+            else
+                found_keys[idx] ||= [0, []]
+                found_keys[idx][0] += rec_found
+                found_keys[idx][1].concat(rec_result)
+            end
+            result
         end
 
         # Resolves the given OS dependencies into the actual packages that need
         # to be installed on this particular OS.
         #
-        # @param [Array<String>] dependencies the list of osdep names that should be resolved
+        # @param [Array<String>] dependencies the list of osdep names that
+        #   should be resolved
         # @return [Array<#install,Array<String>>] the set of packages, grouped
         #   by the package handlers that should be used to install them
         #
@@ -733,25 +762,33 @@ def resolve_os_packages(dependencies)
             all_packages = []
             dependencies.each do |name|
                 result = resolve_package(name)
-                if !result
+                unless result
                     path = resolve_name(name)
-                    raise MissingOSDep.new, "there is no osdeps definition for #{path.last} (search tree: #{path.join("->")})"
+                    raise MissingOSDep.new, "there is no osdeps definition "\
+                        "for #{path.last} (search tree: #{path.join('->')})"
                 end
 
                 if result.empty?
                     os_names, os_versions = operating_system
                     if os_names.empty?
-                        raise MissingOSDep.new, "there is an osdeps definition for #{name}, but autoproj cannot detect the local operation system"
+                        raise MissingOSDep.new, "there is an osdeps "\
+                            "definition for #{name}, but autoproj cannot "\
+                            "detect the local operation system"
                     else
-                        raise MissingOSDep.new, "there is an osdeps definition for #{name}, but not for this operating system and version (resp. #{os_names.join(", ")} and #{os_versions.join(", ")})"
+                        raise MissingOSDep.new, "there is an osdeps "\
+                            "definition for #{name}, but not for this "\
+                            "operating system and version resp. "\
+                            "#{os_names.join(', ')} and #{os_versions.join(', ')})"
                     end
                 end
 
                 result.each do |handler, status, packages|
                     if status == FOUND_NONEXISTENT
-                        raise MissingOSDep.new, "there is an osdep definition for #{name}, and it explicitely states that this package does not exist on your OS"
+                        raise MissingOSDep.new, "there is an osdep "\
+                            "definition for #{name}, and it explicitely "\
+                            "states that this package does not exist on your OS"
                     end
-                    if entry = all_packages.find { |h, _| h == handler }
+                    if (entry = all_packages.find { |h, _| h == handler })
                         entry[1].concat(packages)
                     else
                         all_packages << [handler, packages.dup]
@@ -759,22 +796,22 @@ def resolve_os_packages(dependencies)
                 end
             end
 
-            all_packages.delete_if do |handler, pkg|
+            all_packages.delete_if do |_handler, pkg|
                 pkg.empty?
             end
-            return all_packages
+            all_packages
         end
 
         # Returns true if the given name has an entry in the osdeps
         def include?(name)
-            definitions.has_key?(name)
+            definitions.key?(name)
         end
 
         # Returns true if +name+ is an acceptable OS package for this OS and
         # version
         def has?(name)
             status = availability_of(name)
-            status == AVAILABLE || status == IGNORE
+            [AVAILABLE, IGNORE].include?(status)
         end
 
         # Value returned by #availability_of if the required package has no
@@ -809,9 +846,7 @@ def has?(name)
         #          be installed for it
         def availability_of(name)
             resolved = resolve_package(name)
-            if !resolved
-                return NO_PACKAGE
-            end
+            return NO_PACKAGE unless resolved
 
             if resolved.empty?
                 if known_operating_system?
@@ -821,7 +856,9 @@ def availability_of(name)
                 end
             end
 
-            resolved = resolved.find_all { |_, status, list| status != FOUND_PACKAGES || !list.empty? }
+            resolved = resolved.find_all do |_, status, list|
+                status != FOUND_PACKAGES || !list.empty?
+            end
             failed = resolved.find_all do |_, status, _|
                 status == FOUND_NONEXISTENT
             end
@@ -837,4 +874,3 @@ def availability_of(name)
         end
     end
 end
-