autoproj 2.14.0 → 2.15.0

data/lib/autoproj/package_managers/gem_manager.rb

@@ -27,29 +27,29 @@ module Autoproj
             # of GEM_PATH
             def initialize_environment
                 env = ws.env
-                env.original_env['GEM_PATH'] =
-                    (env['GEM_PATH'] || "").split(File::PATH_SEPARATOR).find_all do |p|
+                env.original_env["GEM_PATH"] =
+                    (env["GEM_PATH"] || "").split(File::PATH_SEPARATOR).find_all do |p|
                         !Autoproj.in_autoproj_installation?(p)
                     end.join(File::PATH_SEPARATOR)
-                env.inherit 'GEM_PATH'
-                env.init_from_env 'GEM_PATH'
+                env.inherit "GEM_PATH"
+                env.init_from_env "GEM_PATH"
 
-                orig_gem_path = env.original_env['GEM_PATH'].split(File::PATH_SEPARATOR)
-                env.system_env['GEM_PATH'] = Gem.default_path
-                env.original_env['GEM_PATH'] = orig_gem_path.join(File::PATH_SEPARATOR)
+                orig_gem_path = env.original_env["GEM_PATH"].split(File::PATH_SEPARATOR)
+                env.system_env["GEM_PATH"] = Gem.default_path
+                env.original_env["GEM_PATH"] = orig_gem_path.join(File::PATH_SEPARATOR)
 
                 ws.config.each_reused_autoproj_installation do |p|
-                    p_gems = File.join(p, '.gems')
+                    p_gems = File.join(p, ".gems")
                     if File.directory?(p_gems)
-                        env.push_path 'GEM_PATH', p_gems
-                        env.push_path 'PATH', File.join(p_gems, 'bin')
+                        env.push_path "GEM_PATH", p_gems
+                        env.push_path "PATH", File.join(p_gems, "bin")
                     end
                 end
 
-                @gem_home = (ENV['AUTOPROJ_GEM_HOME'] || File.join(ws.root_dir, ".gems"))
-                env.push_path 'GEM_PATH', gem_home
-                env.set 'GEM_HOME', gem_home
-                env.push_path 'PATH', "#{gem_home}/bin"
+                @gem_home = (ENV["AUTOPROJ_GEM_HOME"] || File.join(ws.root_dir, ".gems"))
+                env.push_path "GEM_PATH", gem_home
+                env.set "GEM_HOME", gem_home
+                env.push_path "PATH", "#{gem_home}/bin"
 
                 # Now, reset the directories in our own RubyGems instance
                 Gem.paths = env.resolved_env
@@ -59,47 +59,47 @@ module Autoproj
 
             # Override the gem home detected by {initialize_environment}, or set
             # it in cases where calling {initialize_environment} is not possible
-            def self.gem_home=(gem_home)
-                @gem_home = gem_home
+            class << self
+                attr_writer :gem_home
             end
 
             # A global cache directory that should be used to avoid
             # re-downloading gems
             def self.cache_dir
-                if dir = ENV['AUTOBUILD_CACHE_DIR']
-                    dir = File.join(dir, 'gems')
-                    FileUtils.mkdir_p dir
-                    dir
-                end
+                return unless (dir = ENV["AUTOBUILD_CACHE_DIR"])
+
+                dir = File.join(dir, "gems")
+                FileUtils.mkdir_p dir
+                dir
             end
 
             def self.use_cache_dir
                 # If there is a cache directory, make sure .gems/cache points to
                 # it (there are no programmatic ways to override this)
-                if cache = cache_dir
-                    gem_cache_dir = File.join(gem_home, 'cache')
-                    if !File.symlink?(gem_cache_dir) || File.readlink(gem_cache_dir) != cache
-                        FileUtils.mkdir_p gem_home
-                        FileUtils.rm_rf gem_cache_dir
-                        Autoproj.create_symlink(cache, gem_cache_dir)
-                    end
+                return unless (cache = cache_dir)
+
+                gem_cache_dir = File.join(gem_home, "cache")
+                if !File.symlink?(gem_cache_dir) || File.readlink(gem_cache_dir) != cache
+                    FileUtils.mkdir_p gem_home
+                    FileUtils.rm_rf gem_cache_dir
+                    Autoproj.create_symlink(cache, gem_cache_dir)
                 end
             end
 
             # Return the directory in which RubyGems package should be installed
-            def self.gem_home
-                @gem_home
+            class << self
+                attr_reader :gem_home
             end
 
             @gem_home = nil
-            
+
             # Returns the set of default options that are added to gem
             #
             # By default, we add --no-user-install to un-break distributions
             # like Arch that set --user-install by default (thus disabling the
             # role of GEM_HOME)
             def self.default_install_options
-                @default_install_options ||= ['--no-user-install', '--no-format-executable']
+                @default_install_options ||= ["--no-user-install", "--no-format-executable"]
             end
 
             def initialize(ws)
@@ -115,7 +115,7 @@ module Autoproj
             attr_reader :installed_gems
 
             def gem_fetcher
-                if !@gem_fetcher
+                unless @gem_fetcher
                     Autoproj.message "  looking for RubyGems updates"
                     @gem_fetcher = Gem::SpecFetcher.fetcher
                 end
@@ -123,35 +123,29 @@ module Autoproj
             end
 
             def guess_gem_program
-                if Autobuild.programs['gem']
-                    return Autobuild.programs['gem']
-                end
+                return Autobuild.programs["gem"] if Autobuild.programs["gem"]
 
-                ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
-                ruby_bindir = RbConfig::CONFIG['bindir']
+                ruby_bin = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
+                ruby_bindir = RbConfig::CONFIG["bindir"]
 
-                candidates = ['gem']
-                if ruby_bin =~ /^ruby(.+)$/
-                    candidates << "gem#{$1}" 
-                end
+                candidates = ["gem"]
+                candidates << "gem#{$1}" if ruby_bin =~ /^ruby(.+)$/
 
                 candidates.each do |gem_name|
                     if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
-                        Autobuild.programs['gem'] = gem_full_path
+                        Autobuild.programs["gem"] = gem_full_path
                         return
                     end
                 end
 
-                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
+                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(', ')} in #{ruby_bindir})"
             end
 
             def build_gem_cmdlines(gems)
                 with_version, without_version = gems.partition { |name, v| v }
 
                 cmdlines = []
-                if !without_version.empty?
-                    cmdlines << without_version.flatten
-                end
+                cmdlines << without_version.flatten unless without_version.empty?
                 with_version.each do |name, v|
                     cmdlines << [name, "-v", v]
                 end
@@ -160,17 +154,17 @@ module Autoproj
 
             def pristine(gems)
                 guess_gem_program
-                base_cmdline = [Autobuild.tool_in_path('ruby', env: ws.env), '-S', Autobuild.tool('gem')]
+                base_cmdline = [Autobuild.tool_in_path("ruby", env: ws.env), "-S", Autobuild.tool("gem")]
                 cmdlines = [
-                    [*base_cmdline, 'clean'],
+                    [*base_cmdline, "clean"]
                 ]
                 cmdlines += build_gem_cmdlines(gems).map do |line|
                     base_cmdline + ["pristine", "--extensions"] + line
                 end
                 if gems_interaction(gems, cmdlines)
-                    Autoproj.message "  restoring RubyGems: #{gems.map { |g| g.join(" ") }.sort.join(", ")}"
+                    Autoproj.message "  restoring RubyGems: #{gems.map { |g| g.join(' ') }.sort.join(', ')}"
                     cmdlines.each do |c|
-                        Autobuild::Subprocess.run 'autoproj', 'osdeps', *c
+                        Autobuild::Subprocess.run "autoproj", "osdeps", *c
                     end
                 end
             end
@@ -178,25 +172,21 @@ module Autoproj
             def install(gems)
                 guess_gem_program
 
-                base_cmdline = [Autobuild.tool_in_path('ruby', env: ws.env), '-S', Autobuild.tool('gem'), 'install', *GemManager.default_install_options]
-                if !GemManager.with_doc
-                    base_cmdline << '--no-rdoc' << '--no-ri'
-                end
+                base_cmdline = [Autobuild.tool_in_path("ruby", env: ws.env), "-S", Autobuild.tool("gem"), "install", *GemManager.default_install_options]
+                base_cmdline << "--no-rdoc" << "--no-ri" unless GemManager.with_doc
 
-                if GemManager.with_prerelease
-                    base_cmdline << "--prerelease"
-                end
+                base_cmdline << "--prerelease" if GemManager.with_prerelease
 
                 cmdlines = build_gem_cmdlines(gems).map do |line|
                     base_cmdline + line
                 end
                 if gems_interaction(gems, cmdlines)
-                    Autoproj.message "  installing/updating RubyGems dependencies: #{gems.map { |g| g.join(" ") }.sort.join(", ")}"
+                    Autoproj.message "  installing/updating RubyGems dependencies: #{gems.map { |g| g.join(' ') }.sort.join(', ')}"
 
                     cmdlines.each do |c|
-                        Autobuild::Subprocess.run 'autoproj', 'osdeps', *c,
-                            env: Hash['GEM_HOME' => Gem.paths.home,
-                                      'GEM_PATH' => Gem.paths.path.join(":")]
+                        Autobuild::Subprocess.run "autoproj", "osdeps", *c,
+                                                  env: Hash["GEM_HOME" => Gem.paths.home,
+                                                            "GEM_PATH" => Gem.paths.path.join(":")]
                     end
                     gems.each do |name, v|
                         installed_gems << name
@@ -209,14 +199,14 @@ module Autoproj
             # installed, or that can be upgraded
             def filter_uptodate_packages(gems, options = Hash.new)
                 options = validate_options options,
-                    install_only: !Autobuild.do_update
+                                           install_only: !Autobuild.do_update
 
                 # Don't install gems that are already there ...
                 gems = gems.dup
                 gems.delete_if do |name, version|
                     next(true) if installed_gems.include?(name)
 
-                    version_requirements = Gem::Requirement.new(version || '>= 0')
+                    version_requirements = Gem::Requirement.new(version || ">= 0")
                     installed =
                         if Gem::Specification.respond_to?(:find_by_name)
                             begin
@@ -236,14 +226,16 @@ module Autoproj
                                 non_prerelease = gem_fetcher.find_matching(dep, true, true).map(&:first)
                                 if GemManager.with_prerelease
                                     prerelease = gem_fetcher.find_matching(dep, false, true, true).map(&:first)
-                                else prerelease = Array.new
+                                else
+                                    prerelease = Array.new
                                 end
-                                (non_prerelease + prerelease).
-                                    map { |n, v, _| [n, v] }
+                                (non_prerelease + prerelease)
+                                    .map { |n, v, _| [n, v] }
 
                             else # Post RubyGems-2.0
                                 type = if GemManager.with_prerelease then :complete
-                                       else :released
+                                       else
+                                           :released
                                        end
 
                                 gem_fetcher.detect(type) do |tuple|
@@ -252,7 +244,7 @@ module Autoproj
                             end
                         installed_version = installed.map(&:version).max
                         available_version = available.map { |_, v| v }.max
-                        if !available_version
+                        unless available_version
                             if version
                                 raise ConfigError.new, "cannot find any gem with the name '#{name}' and version #{version}"
                             else
@@ -288,22 +280,22 @@ module Autoproj
                 # We're not supposed to install rubygem packages but silent is not
                 # set, so display information about them anyway
                 puts <<-EOMSG
-      #{Autoproj.color("The build process and/or the packages require some Ruby Gems to be installed", :bold)}
-      #{Autoproj.color("and you required autoproj to not do it itself", :bold)}
+      #{Autoproj.color('The build process and/or the packages require some Ruby Gems to be installed', :bold)}
+      #{Autoproj.color('and you required autoproj to not do it itself', :bold)}
         You can use the --all or --ruby options to autoproj osdeps to install these
         packages anyway, and/or change to the osdeps handling mode by running an
         autoproj operation with the --reconfigure option as for instance
         autoproj build --reconfigure
-        
+      #{'  '}
         The following command line can be used to install them manually
-        
-          #{cmdlines.map { |c| c.join(" ") }.join("\n      ")}
-        
+      #{'  '}
+          #{cmdlines.map { |c| c.join(' ') }.join("\n      ")}
+      #{'  '}
         Autoproj expects these Gems to be installed in #{GemManager.gem_home} This can
         be overridden by setting the AUTOPROJ_GEM_HOME environment variable manually
 
                 EOMSG
-                print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+                print "    #{Autoproj.color('Press ENTER to continue ', :bold)}"
 
                 STDOUT.flush
                 STDIN.readline
@@ -313,4 +305,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/package_managers/homebrew_manager.rb

@@ -5,8 +5,8 @@ module Autoproj
         class HomebrewManager < ShellScriptManager
             def initialize(ws)
                 super(ws, true,
-                        %w{brew install},
-                        %w{brew install},
+                        %w[brew install],
+                        %w[brew install],
                         false)
             end
 
@@ -16,7 +16,7 @@ module Autoproj
                 packages = packages.uniq
                 command_line = "brew info --json=v1 #{packages.join(' ')}"
                 result = Autoproj.bundler_with_unbundled_env do
-                    (Autobuild::Subprocess.run 'autoproj', 'osdeps', command_line).first
+                    (Autobuild::Subprocess.run "autoproj", "osdeps", command_line).first
                 end
 
                 begin
@@ -53,4 +53,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/package_managers/manager.rb

@@ -11,10 +11,16 @@ module Autoproj
             attr_reader :ws
 
             attr_writer :enabled
-            def enabled?; !!@enabled end
+
+            def enabled?
+                !!@enabled
+            end
 
             attr_writer :silent
-            def silent?; !!@silent end
+
+            def silent?
+                !!@silent
+            end
 
             # Whether this package manager should be called even if no packages
             # should be installed
@@ -68,4 +74,3 @@ module Autoproj
         end
     end
 end
-

data/lib/autoproj/package_managers/pacman_manager.rb

@@ -5,10 +5,9 @@ module Autoproj
         class PacmanManager < ShellScriptManager
             def initialize(ws)
                 super(ws, true,
-                        %w{pacman -Sy --needed},
-                        %w{pacman -Sy --needed --noconfirm})
+                        %w[pacman -Sy --needed],
+                        %w[pacman -Sy --needed --noconfirm])
             end
         end
     end
 end
-

data/lib/autoproj/package_managers/pip_manager.rb

@@ -1,4 +1,4 @@
-require 'autoproj/python'
+require "autoproj/python"
 
 module Autoproj
     module PackageManagers
@@ -7,14 +7,14 @@ module Autoproj
             attr_reader :installed_pips
 
             def initialize_environment
-                ws.env.set 'PYTHONUSERBASE', pip_home
-                ws.env.add_path 'PATH', File.join(pip_home, 'bin')
+                ws.env.set "PYTHONUSERBASE", pip_home
+                ws.env.add_path "PATH", File.join(pip_home, "bin")
             end
 
             # Return the directory where python packages are installed to.
             # The actual path is pip_home/lib/pythonx.y/site-packages.
             def pip_home
-                ws.env['AUTOPROJ_PYTHONUSERBASE'] || File.join(ws.prefix_dir, "pip")
+                ws.env["AUTOPROJ_PYTHONUSERBASE"] || File.join(ws.prefix_dir, "pip")
             end
 
             def initialize(ws)
@@ -23,43 +23,42 @@ module Autoproj
             end
 
             def os_dependencies
-                super + ['pip']
+                super + ["pip"]
             end
 
             def guess_pip_program
-                unless ws.config.has_value_for?('USE_PYTHON')
-                  Autoproj::Python.setup_python_configuration_options(ws: ws)
+                unless ws.config.has_value_for?("USE_PYTHON")
+                    Autoproj::Python.setup_python_configuration_options(ws: ws)
                 end
-                unless ws.config.get('USE_PYTHON')
-                  raise ConfigError, "Your current package selection" \
-                    " requires the use of pip, but" \
-                    " the use of python is either unspecified or has been denied, see" \
-                    " setting of USE_PYTHON in your workspace configuration." \
-                    " Either remove all packages depending on pip packages " \
-                    " from the workspace layout (manifest) or " \
-                    " call 'autoproj reconfigure' to change the setting."
+                unless ws.config.get("USE_PYTHON")
+                    raise ConfigError,
+                          "Your current package selection requires the use of pip, but" \
+                          " the use of python is either unspecified or has been denied,"\
+                          " see setting of USE_PYTHON in your workspace configuration." \
+                          " Either remove all packages depending on pip packages " \
+                          " from the workspace layout (manifest) or " \
+                          " call 'autoproj reconfigure' to change the setting."
 
                 end
 
-                Autobuild.programs['pip'] = "pip" unless Autobuild.programs['pip']
-                Autobuild.programs['pip']
+                Autobuild.programs["pip"] = "pip" unless Autobuild.programs["pip"]
+                Autobuild.programs["pip"]
             end
 
-            # rubocop:disable Lint/UnusedMethodArgument
             def install(pips, filter_uptodate_packages: false, install_only: false)
                 guess_pip_program
                 pips = [pips] if pips.is_a?(String)
 
-                base_cmdline = [Autobuild.tool('pip'), 'install', '--user']
+                base_cmdline = [Autobuild.tool("pip"), "install", "--user"]
 
                 cmdlines = [base_cmdline + pips]
 
                 if pips_interaction(cmdlines)
                     Autoproj.message "  installing/updating Python dependencies:" \
-                        " #{pips.sort.join(', ')}"
+                                     " #{pips.sort.join(', ')}"
 
                     cmdlines.each do |c|
-                        Autobuild::Subprocess.run 'autoproj', 'osdeps', *c,
+                        Autobuild::Subprocess.run "autoproj", "osdeps", *c,
                                                   env: ws.env.resolved_env
                     end
 
@@ -68,7 +67,6 @@ module Autoproj
                     end
                 end
             end
-            # rubocop:enable Lint/UnusedMethodArgument
 
             def pips_interaction(cmdlines)
                 if OSPackageInstaller.force_osdeps

data/lib/autoproj/package_managers/pkg_manager.rb

@@ -1,14 +1,13 @@
 module Autoproj
     module PackageManagers
-	# Package manager interface for systems that use pkg (i.e. FreeBSD) as
+        # Package manager interface for systems that use pkg (i.e. FreeBSD) as
         # their package manager
         class PkgManager < ShellScriptManager
             def initialize(ws)
                 super(ws, true,
-                        %w{pkg install -y},
-                        %w{pkg install -y})
+                        %w[pkg install -y],
+                        %w[pkg install -y])
             end
         end
     end
 end
-

data/lib/autoproj/package_managers/port_manager.rb

@@ -5,10 +5,9 @@ module Autoproj
         class PortManager < ShellScriptManager
             def initialize(ws)
                 super(ws, true,
-                        %w{port install},
-                        %w{port install})
+                        %w[port install],
+                        %w[port install])
             end
         end
     end
 end
-

data/lib/autoproj/package_managers/shell_script_manager.rb

@@ -5,31 +5,30 @@ module Autoproj
         class ShellScriptManager < Manager
             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
-                            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)
-                        ensure
-                            lock_io.flock(File::LOCK_UN)
+                    File.open("/tmp/autoproj_osdeps_lock", "w") do |lock_io|
+                        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)
+                    ensure
+                        lock_io.flock(File::LOCK_UN)
                     end
                 end
 
                 if with_root
-                    sudo = Autobuild.tool_in_path('sudo', env: env)
+                    sudo = Autobuild.tool_in_path("sudo", env: env)
                     command_line = [sudo, *command_line]
                 end
 
-                Autobuild::Subprocess.run 'autoproj', 'osdeps', *command_line
+                Autobuild::Subprocess.run "autoproj", "osdeps", *command_line
             end
 
             # Overrides the {#needs_locking?} flag
             attr_writer :needs_locking
+
             # Whether two autoproj instances can run this package manager at the
             # same time
             #
@@ -45,6 +44,7 @@ module Autoproj
 
             # Overrides the {#needs_root?} flag
             attr_writer :needs_root
+
             # Whether this package manager needs root access.
             #
             # This declares if the command line(s) for this package manager
@@ -90,7 +90,7 @@ module Autoproj
             # @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)
+                auto_install_cmd, needs_root = true)
                 super(ws)
                 @needs_locking = needs_locking
                 @user_install_cmd = user_install_cmd
@@ -108,10 +108,11 @@ module Autoproj
             #   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)
+                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)
+                    generate_script(user_install_cmd, os_packages)
+                else
+                    generate_auto_os_script(os_packages)
                 end
             end
 
@@ -125,8 +126,15 @@ module Autoproj
             #   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)
-                auto_install_cmd.join(" ") + " " + os_packages.join("' '")
+                auto_install_cmd: self.auto_install_cmd)
+                generate_script(auto_install_cmd, os_packages)
+            end
+
+            # Helper for {#generate_user_os_script} and {#generate_auto_os_script}
+            def generate_script(cmd, args)
+                cmd = cmd.join(" ")
+                args = args.join("' '")
+                "#{cmd} #{args}"
             end
 
             # Handles interaction with the user
@@ -152,7 +160,9 @@ module Autoproj
 
                 #{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)}
+                #{unless respond_to?(:filter_uptodate_packages)
+                      Autoproj.color('\nIf these packages are already installed, simply ignore this message\n', :red)
+                  end}
     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
@@ -183,8 +193,8 @@ module Autoproj
             #   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?

data/lib/autoproj/package_managers/unknown_os_manager.rb

@@ -10,8 +10,8 @@ module Autoproj
 
             def osdeps_interaction_unknown_os(osdeps)
                 puts <<-EOMSG
-  #{Autoproj.color("The build process requires some other software packages to be installed on our operating system", :bold)}
-  #{Autoproj.color("If they are already installed, simply ignore this message", :red)}
+  #{Autoproj.color('The build process requires some other software packages to be installed on our operating system', :bold)}
+  #{Autoproj.color('If they are already installed, simply ignore this message', :red)}
 
     #{osdeps.to_a.sort.join("\n    ")}
 
@@ -25,18 +25,15 @@ module Autoproj
 
             def install(osdeps)
                 if silent?
-                    return false
+                    false
                 else
                     osdeps = osdeps.to_set
                     osdeps -= @installed_osdeps
-                    if !osdeps.empty?
-                        result = osdeps_interaction_unknown_os(osdeps)
-                    end
+                    result = osdeps_interaction_unknown_os(osdeps) unless osdeps.empty?
                     @installed_osdeps |= osdeps
-                    return result
+                    result
                 end
             end
         end
     end
 end
-