autobuild 1.17.0 → 1.18.0

data/lib/autobuild/pkgconfig.rb

@@ -2,10 +2,16 @@
 class PkgConfig
     class NotFound < RuntimeError
         attr_reader :name
-        def initialize(name); @name = name end
-        def to_s; "#{name} is not available to pkg-config" end
+
+        def initialize(name)
+            @name = name
+        end
+
+        def to_s
+            "#{name} is not available to pkg-config"
+        end
     end
-    
+
     # The module name
     attr_reader :name
     # The module version
@@ -14,30 +20,36 @@ def to_s; "#{name} is not available to pkg-config" end
     # Create a PkgConfig object for the package +name+
     # Raises PkgConfig::NotFound if the module does not exist
     def initialize(name)
-        if !system("pkg-config --exists #{name}")
-            raise NotFound.new(name)
+        unless system("pkg-config --exists #{name}")
+            raise NotFound.new(name), "pkg-config package '#{name}' not found"
         end
-        
+
         @name    = name
         @version = `pkg-config --modversion #{name}`.chomp.strip
         @actions = Hash.new
         @variables = Hash.new
     end
 
-    ACTIONS = %w{cflags cflags-only-I cflags-only-other 
-                libs libs-only-L libs-only-l libs-only-other static}
+    ACTIONS = %w[cflags cflags-only-I cflags-only-other
+                 libs libs-only-L libs-only-l libs-only-other static].freeze
     ACTIONS.each do |action|
-        define_method(action.gsub(/-/, '_')) do 
+        define_method(action.tr('-', '_')) do
             @actions[action] ||= `pkg-config --#{action} #{name}`.chomp.strip
         end
     end
 
+    def respond_to_missing?(varname, _include_all)
+        varname =~ /^\w+$/
+    end
+
     def method_missing(varname, *args, &proc)
         if args.empty?
-            @variables[varname] ||= `pkg-config --variable=#{varname} #{name}`.chomp.strip
-        else
-            super(varname, *args, &proc)
+            unless (value = @variables[varname])
+                value = `pkg-config --variable=#{varname} #{name}`.chomp.strip
+                @variables[varname] = value
+            end
+            return value
         end
+        super
     end
 end
-

data/lib/autobuild/progress_display.rb

@@ -3,7 +3,6 @@ module Autobuild
     class ProgressDisplay
         def initialize(io, color: ::Autobuild.method(:color))
             @io = io
-            #@cursor = Blank.new
             @cursor = TTY::Cursor
             @last_formatted_progress = []
             @progress_messages = []
@@ -21,7 +20,8 @@ def silent?
         end
 
         def silent
-            @silent, silent = true, @silent
+            @silent = true
+            silent = @silent
             yield
         ensure
             @silent = silent
@@ -36,12 +36,11 @@ def progress_enabled?
         def message(message, *args, io: @io, force: false)
             return if silent? && !force
 
-            if args.last.respond_to?(:to_io)
-                io = args.pop
-            end
+            io = args.pop if args.last.respond_to?(:to_io)
 
             @display_lock.synchronize do
-                io.print "#{@cursor.column(1)}#{@cursor.clear_screen_down}#{@color.call(message, *args)}\n"
+                io.print "#{@cursor.column(1)}#{@cursor.clear_screen_down}"\
+                    "#{@color.call(message, *args)}\n"
                 io.flush if @io != io
                 display_progress
                 @io.flush
@@ -94,9 +93,7 @@ def progress_done(key, display_last = true, message: nil)
                 current_size = @progress_messages.size
                 @progress_messages.delete_if do |msg_key, msg|
                     if msg_key == key
-                        if display_last && !message
-                            message = msg
-                        end
+                        message = msg if display_last && !message
                         true
                     end
                 end
@@ -116,11 +113,11 @@ def progress_done(key, display_last = true, message: nil)
             end
         end
 
-
         def display_progress
             return unless progress_enabled?
 
-            formatted = format_grouped_messages(@progress_messages.map(&:last), indent: "  ")
+            formatted = format_grouped_messages(@progress_messages.map(&:last),
+                indent: "  ")
             @io.print @cursor.clear_screen_down
             @io.print formatted.join("\n")
             if formatted.size > 1
@@ -137,13 +134,11 @@ def find_common_prefix(msg, other_msg)
             msg.each_with_index do |token, idx|
                 if other_msg[idx] != token
                     prefix = msg[0..(idx - 1)].join(" ")
-                    if !prefix.empty?
-                        prefix << " "
-                    end
+                    prefix << " " unless prefix.empty?
                     return prefix
                 end
             end
-            return msg.join(" ")
+            msg.join(" ")
         end
 
         def group_messages(messages)
@@ -152,19 +147,22 @@ def group_messages(messages)
             groups = Array.new
             groups << ["", (0...messages.size)]
             messages.each_with_index do |msg, idx|
-                prefix, grouping = nil, false
+                prefix = nil
+                grouping = false
                 messages[(idx + 1)..-1].each_with_index do |other_msg, other_idx|
                     other_idx += idx + 1
                     prefix ||= find_common_prefix(msg, other_msg)
-                    break if !other_msg.start_with?(prefix)
+                    break unless other_msg.start_with?(prefix)
 
                     if grouping
                         break if prefix != groups.last[0]
+
                         groups.last[1] << other_idx
                     else
                         current_prefix, current_group = groups.last
-                        if prefix.size > current_prefix.size # create a new group from there
-                            groups.last[1] = (current_group.first..[idx-1,current_group.last].min)
+                        if prefix.size > current_prefix.size # create a new group
+                            group_end_index = [idx - 1, current_group.last].min
+                            groups.last[1] = (current_group.first..group_end_index)
                             groups << [prefix, [idx, other_idx]]
                             grouping = true
                         else break
@@ -179,13 +177,14 @@ def group_messages(messages)
             groups.map do |prefix, indexes|
                 indexes = indexes.to_a
                 next if indexes.empty?
+
                 range = (prefix.size)..-1
                 [prefix, indexes.map { |i| messages[i][range] }]
             end.compact
         end
 
-        def format_grouped_messages(messages, indent: "  ", width: TTY::Screen.width)
-            groups = group_messages(messages)
+        def format_grouped_messages(raw_messages, indent: "  ", width: TTY::Screen.width)
+            groups = group_messages(raw_messages)
             groups.each_with_object([]) do |(prefix, messages), lines|
                 if prefix.empty?
                     lines.concat(messages.map { |m| "#{indent}#{m.strip}" })
@@ -197,10 +196,11 @@ def format_grouped_messages(messages, indent: "  ", width: TTY::Screen.width)
                     msg = messages.shift.strip
                     margin = messages.empty? ? 1 : 2
                     if lines.last.size + margin + msg.size > width
-                        lines << "".dup
+                        lines.last << ","
+                        lines << +""
                         lines.last << indent << indent << msg
                     else
-                        lines.last << " " << msg
+                        lines.last << ", " << msg
                     end
                 end
                 lines.last << "," unless messages.empty?

data/lib/autobuild/rake_task_extension.rb

@@ -1,19 +1,19 @@
 module Autobuild
     module RakeTaskExtension
         def already_invoked?
-            !!@already_invoked
+            @already_invoked
         end
 
-        def already_invoked=(value)
-            @already_invoked = value
-        end
+        attr_writer :already_invoked
 
         def disable!
             @already_invoked = true
-            def self.needed?; false end
+            singleton_class.class_eval do
+                define_method(:needed?) { false }
+            end
         end
     end
 end
-class Rake::Task
+class Rake::Task # rubocop:disable Style/ClassAndModuleChildren
     include Autobuild::RakeTaskExtension
 end

data/lib/autobuild/reporting.rb

@@ -16,6 +16,7 @@ def color=(flag)
         def color?
             @colorizer.enabled?
         end
+
         def color(message, *style)
             @colorizer.decorate(message, *style)
         end
@@ -31,6 +32,7 @@ class << self
         def silent?
             @display.silent?
         end
+
         def silent=(flag)
             @display.silent = flag
         end
@@ -80,7 +82,7 @@ def self.progress_done(key, display_last = true, message: nil)
     #
     # It does not use a logging framework like Log4r, but it should ;-)
     module Reporting
-        @@reporters = Array.new
+        @reporters = Array.new
 
         ## Run a block and report known exception
         # If an exception is fatal, the program is terminated using exit()
@@ -89,18 +91,22 @@ def self.report(on_package_failures: default_report_on_package_failures)
             rescue Interrupt => e
                 interrupted = e
             rescue Autobuild::Exception => e
-                return report_finish_on_error([e], on_package_failures: on_package_failures, interrupted_by: interrupted)
+                return report_finish_on_error([e],
+                    on_package_failures: on_package_failures,
+                    interrupted_by: interrupted)
             end
 
             # If ignore_erorrs is true, check if some packages have failed
             # on the way. If so, raise an exception to inform the user about
             # it
             errors = []
-            Autobuild::Package.each do |name, pkg|
+            Autobuild::Package.each do |_name, pkg|
                 errors.concat(pkg.failures)
             end
 
-            report_finish_on_error(errors, on_package_failures: on_package_failures, interrupted_by: interrupted)
+            report_finish_on_error(errors,
+                on_package_failures: on_package_failures,
+                interrupted_by: interrupted)
         end
 
         # @api private
@@ -121,15 +127,18 @@ def self.default_report_on_package_failures
         #
         # @param [Symbol] on_package_failures how does the reporting should behave.
         #
-        def self.report_finish_on_error(errors, on_package_failures: default_report_on_package_failures, interrupted_by: nil)
-            if not_package_error = errors.find { |e| !e.respond_to?(:fatal?) }
+        def self.report_finish_on_error(errors,
+            on_package_failures: default_report_on_package_failures, interrupted_by: nil)
+            if (not_package_error = errors.find { |e| !e.respond_to?(:fatal?) })
                 raise not_package_error
             end
-            if ![:raise, :report_silent, :exit_silent].include?(on_package_failures)
+
+            unless %i[raise report_silent exit_silent].include?(on_package_failures)
                 errors.each { |e| error(e) }
             end
+
             fatal = errors.any?(&:fatal?)
-            if !fatal
+            unless fatal
                 if interrupted_by
                     raise interrupted_by
                 else
@@ -138,30 +147,29 @@ def self.report_finish_on_error(errors, on_package_failures: default_report_on_p
             end
 
             if on_package_failures == :raise
-                if interrupted_by
-                    raise interrupted_by
-                end
+                raise interrupted_by if interrupted_by
 
                 e = if errors.size == 1 then errors.first
-                else CompositeException.new(errors)
-                end
+                    else CompositeException.new(errors)
+                    end
                 raise e
-            elsif [:report_silent, :report].include?(on_package_failures)
+            elsif %i[report_silent report].include?(on_package_failures)
                 if interrupted_by
                     raise interrupted_by
                 else
                     return errors
                 end
-            elsif [:exit, :exit_silent].include?(on_package_failures)
+            elsif %i[exit exit_silent].include?(on_package_failures)
                 exit 1
             else
-                raise ArgumentError, "unexpected value for on_package_failures: #{on_package_failures}"
+                raise ArgumentError, "unexpected value for on_package_failures: "\
+                    "#{on_package_failures}"
             end
         end
 
         ## Reports a successful build to the user
         def self.success
-            each_reporter { |rep| rep.success }
+            each_reporter(&:success)
         end
 
         ## Reports that the build failed to the user
@@ -171,19 +179,19 @@ def self.error(error)
 
         ## Add a new reporter
         def self.<<(reporter)
-            @@reporters << reporter
+            @reporters << reporter
         end
 
         def self.remove(reporter)
-            @@reporters.delete(reporter)
+            @reporters.delete(reporter)
         end
 
         def self.clear_reporters
-            @@reporters.clear
+            @reporters.clear
         end
 
         def self.each_reporter(&iter)
-            @@reporters.each(&iter)
+            @reporters.each(&iter)
         end
 
         ## Iterate on all log files
@@ -195,6 +203,7 @@ def self.each_log(&block)
     ## Base class for reporters
     class Reporter
         def error(error); end
+
         def success; end
     end
 
@@ -203,11 +212,10 @@ class StdoutReporter < Reporter
         def error(error)
             STDERR.puts "Build failed: #{error}"
         end
+
         def success
             puts "Build finished successfully at #{Time.now}"
-            if Autobuild.post_success_message
-                puts Autobuild.post_success_message
-            end
+            puts Autobuild.post_success_message if Autobuild.post_success_message
         end
     end
 
@@ -216,12 +224,16 @@ def success
         [1_000_000.0, "M"],
         [1_000.0, "k"],
         [1.0, ""]
-    ]
+    ].freeze
 
     def self.human_readable_size(size)
         HUMAN_READABLE_SIZES.each do |scale, name|
             scaled_size = (size / scale)
-            return format("%3.1f%s", scaled_size, name) if scaled_size > 1
+            if scaled_size > 1
+                return format("%3.1<scaled>f%<scale_name>s",
+                    scaled: scaled_size,
+                    scale_name: name)
+            end
         end
     end
 end

data/lib/autobuild/subcommand.rb

@@ -2,6 +2,7 @@
 require 'autobuild/exceptions'
 require 'autobuild/reporting'
 require 'fcntl'
+require 'English'
 
 module Autobuild
     @logfiles = Set.new
@@ -24,9 +25,11 @@ def self.registered_logfile?(logfile)
     def self.statistics
         @statistics
     end
+
     def self.reset_statistics
         @statistics = Hash.new
     end
+
     def self.add_stat(package, phase, duration)
         if !@statistics[package]
             @statistics[package] = { phase => duration }
@@ -36,6 +39,7 @@ def self.add_stat(package, phase, duration)
             @statistics[package][phase] += duration
         end
     end
+
     reset_statistics
 
     @parallel_build_level = nil
@@ -52,9 +56,8 @@ class << self
         def displayed_error_line_count=(value)
             @displayed_error_line_count = validate_displayed_error_line_count(value)
         end
-        def displayed_error_line_count
-            @displayed_error_line_count
-        end
+
+        attr_reader :displayed_error_line_count
 
         # Returns the number of processes that can run in parallel during the
         # build. This is a system-wide value that can be overriden in a
@@ -78,13 +81,13 @@ def parallel_build_level
 
     # Returns the number of CPUs present on this system
     def self.autodetect_processor_count
-        if @processor_count
-            return @processor_count
-        end
+        return @processor_count if @processor_count
 
         if File.file?('/proc/cpuinfo')
             cpuinfo = File.readlines('/proc/cpuinfo')
-            physical_ids, core_count, processor_ids = [], [], []
+            physical_ids  = []
+            core_count    = []
+            processor_ids = []
             cpuinfo.each do |line|
                 case line
                 when /^processor\s+:\s+(\d+)$/
@@ -99,7 +102,10 @@ def self.autodetect_processor_count
             # Try to count the number of physical cores, not the number of
             # logical ones. If the info is not available, fallback to the
             # logical count
-            if (physical_ids.size == core_count.size) && (physical_ids.size == processor_ids.size)
+            has_consistent_info =
+                (physical_ids.size == core_count.size) &&
+                (physical_ids.size == processor_ids.size)
+            if has_consistent_info
                 info = Array.new
                 while (id = physical_ids.shift)
                     info[id] = core_count.shift
@@ -112,18 +118,17 @@ def self.autodetect_processor_count
             result = Open3.popen3("sysctl", "-n", "hw.ncpu") do |_, io, _|
                 io.read
             end
-            if !result.empty?
-                @processor_count = Integer(result.chomp.strip)
-            end
+            @processor_count = Integer(result.chomp.strip) unless result.empty?
         end
 
         # The format of the cpuinfo file is ... let's say not very standardized.
         # If the cpuinfo detection fails, inform the user and set it to 1
-        if !@processor_count
+        unless @processor_count
             # Hug... What kind of system is it ?
             Autobuild.message "INFO: cannot autodetect the number of CPUs on this sytem"
             Autobuild.message "INFO: turning parallel builds off"
-            Autobuild.message "INFO: you can manually set the number of parallel build processes to N"
+            Autobuild.message "INFO: you can manually set the number of parallel build "\
+                "processes to N"
             Autobuild.message "INFO: (and therefore turn this message off)"
             Autobuild.message "INFO: with"
             Autobuild.message "    Autobuild.parallel_build_level = N"
@@ -135,20 +140,24 @@ def self.autodetect_processor_count
 
     def self.validate_displayed_error_line_count(lines)
         if lines == 'ALL'
-            return Float::INFINITY
+            Float::INFINITY
         elsif lines.to_i > 0
-            return lines.to_i
+            lines.to_i
+        else
+            raise ConfigException.new, 'Autobuild.displayed_error_line_count can only "\
+                "be a positive integer or \'ALL\''
         end
-        raise ConfigException.new, 'Autobuild.displayed_error_line_count can only be a positive integer or \'ALL\''
     end
 end
 
-
-module Autobuild::Subprocess
-    class Failed < Exception
-        def retry?; @retry end
+module Autobuild::Subprocess # rubocop:disable Style/ClassAndModuleChildren
+    class Failed < RuntimeError
         attr_reader :status
 
+        def retry?
+            @retry
+        end
+
         def initialize(status, do_retry)
             @status = status
             @retry = do_retry
@@ -206,7 +215,11 @@ def self.run(target, phase, *command)
         STDOUT.sync = true
 
         input_streams = []
-        options = Hash[retry: false, env: ENV.to_hash, env_inherit: true, encoding: 'BINARY']
+        options = {
+            retry: false, encoding: 'BINARY',
+            env: ENV.to_hash, env_inherit: true
+        }
+
         if command.last.kind_of?(Hash)
             options = command.pop
             options = Kernel.validate_options options,
@@ -216,19 +229,15 @@ def self.run(target, phase, *command)
                 env_inherit: true,
                 encoding: 'BINARY'
 
-            if options[:input]
-                input_streams << File.open(options[:input])
-            end
-            if options[:input_streams]
-                input_streams += options[:input_streams]
-            end
+            input_streams << File.open(options[:input]) if options[:input]
+            input_streams.concat(options[:input_streams]) if options[:input_streams]
         end
 
         start_time = Time.now
 
         # Filter nil and empty? in command
-        command.reject!  { |o| o.nil? || (o.respond_to?(:empty?) && o.empty?) }
-        command.collect! { |o| o.to_s }
+        command.reject! { |o| o.nil? || (o.respond_to?(:empty?) && o.empty?) }
+        command.collect!(&:to_s)
 
         if target.respond_to?(:name)
             target_name = target.name
@@ -246,13 +255,15 @@ def self.run(target, phase, *command)
             options[:working_directory] ||= target.working_directory
         end
 
-        logname = File.join(logdir, "#{target_name.gsub(/[:]/,'_')}-#{phase.to_s.gsub(/[:]/,'_')}.log")
-        if !File.directory?(File.dirname(logname))
+        logname = File.join(logdir, "#{target_name.gsub(/[:]/, '_')}-"\
+            "#{phase.to_s.gsub(/[:]/, '_')}.log")
+        unless File.directory?(File.dirname(logname))
             FileUtils.mkdir_p File.dirname(logname)
         end
 
         if Autobuild.verbose
-            Autobuild.message "#{target_name}: running #{command.join(" ")}\n    (output goes to #{logname})"
+            Autobuild.message "#{target_name}: running #{command.join(' ')}\n"\
+                "    (output goes to #{logname})"
         end
 
         open_flag = if Autobuild.keep_oldlogs then 'a'
@@ -267,32 +278,28 @@ def self.run(target, phase, *command)
         env = options[:env].dup
         if options[:env_inherit]
             ENV.each do |k, v|
-                if !env.has_key?(k)
-                    env[k] = v
-                end
+                env[k] = v unless env.key?(k)
             end
         end
 
         status = File.open(logname, open_flag) do |logfile|
-            if Autobuild.keep_oldlogs
-                logfile.puts
-            end
+            logfile.puts if Autobuild.keep_oldlogs
             logfile.puts
             logfile.puts "#{Time.now}: running"
-            logfile.puts "    #{command.join(" ")}"
+            logfile.puts "    #{command.join(' ')}"
             logfile.puts "with environment:"
             env.keys.sort.each do |key|
-                if value = env[key]
+                if (value = env[key])
                     logfile.puts "  '#{key}'='#{value}'"
                 end
             end
             logfile.puts
             logfile.puts "#{Time.now}: running"
-            logfile.puts "    #{command.join(" ")}"
+            logfile.puts "    #{command.join(' ')}"
             logfile.flush
             logfile.sync = true
 
-            if !input_streams.empty?
+            unless input_streams.empty?
                 pread, pwrite = IO.pipe # to feed subprocess stdin
             end
 
@@ -304,22 +311,19 @@ def self.run(target, phase, *command)
 
             if Autobuild.windows?
                 Dir.chdir(options[:working_directory]) do
-                    if !system(*command)
-                        raise Failed.new($?.exitstatus, nil),
+                    unless system(*command)
+                        raise Failed.new($CHILD_STATUS.exitstatus, nil),
                             "'#{command.join(' ')}' returned status #{status.exitstatus}"
                     end
                 end
-                return
+                return # rubocop:disable Lint/NonLocalExitFromIterator
             end
 
             cwrite.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
             pid = fork do
                 begin
-                    if options[:working_directory] && (options[:working_directory] != Dir.pwd)
-                        Dir.chdir(options[:working_directory])
-                    end
-                    logfile.puts "in directory #{Dir.pwd}"
+                    logfile.puts "in directory #{options[:working_directory] || Dir.pwd}"
 
                     cwrite.sync = true
                     if Autobuild.nice
@@ -330,19 +334,23 @@ def self.run(target, phase, *command)
                     $stderr.reopen(outwrite.dup)
                     $stdout.reopen(outwrite.dup)
 
-                    if !input_streams.empty?
+                    unless input_streams.empty?
                         pwrite.close
                         $stdin.reopen(pread)
                     end
 
-                    exec(env, *command, close_others: false)
+                    exec(env, *command,
+                        chdir: options[:working_directory] || Dir.pwd,
+                        close_others: false)
                 rescue Errno::ENOENT
                     cwrite.write([CONTROL_COMMAND_NOT_FOUND].pack('I'))
                     exit(100)
                 rescue Interrupt
                     cwrite.write([CONTROL_INTERRUPT].pack('I'))
                     exit(100)
-                rescue ::Exception
+                rescue ::Exception => e
+                    STDERR.puts e
+                    STDERR.puts e.backtrace.join("\n  ")
                     cwrite.write([CONTROL_UNEXPECTED].pack('I'))
                     exit(100)
                 end
@@ -351,12 +359,14 @@ def self.run(target, phase, *command)
             readbuffer = StringIO.new
 
             # Feed the input
-            if !input_streams.empty?
+            unless input_streams.empty?
                 pread.close
                 begin
                     input_streams.each do |instream|
                         instream.each_line do |line|
-                            readbuffer.write(outread.readpartial(128)) while IO.select([outread], nil, nil, 0)
+                            while IO.select([outread], nil, nil, 0)
+                                readbuffer.write(outread.readpartial(128))
+                            end
                             pwrite.write(line)
                         end
                     end
@@ -385,15 +395,13 @@ def self.run(target, phase, *command)
             end
 
             transparent_prefix = "#{target_name}:#{phase}: "
-            if target_type
-                transparent_prefix = "#{target_type}:#{transparent_prefix}"
-            end
+            transparent_prefix = "#{target_type}:#{transparent_prefix}" if target_type
 
             # If the caller asked for process output, provide it to him
             # line-by-line.
             outwrite.close
 
-            if !input_streams.empty?
+            unless input_streams.empty?
                 readbuffer.write(outread.read)
                 readbuffer.seek(0)
                 outread.close
@@ -428,6 +436,7 @@ def self.run(target, phase, *command)
             if status.termsig == 2 # SIGINT == 2
                 raise Interrupt, "subcommand #{command.join(' ')} interrupted"
             end
+
             if status.termsig
                 raise Failed.new(status.exitstatus, nil),
                     "'#{command.join(' ')}' terminated by signal #{status.termsig}"
@@ -441,21 +450,19 @@ def self.run(target, phase, *command)
         Autobuild.add_stat(target, phase, duration)
         FileUtils.mkdir_p(Autobuild.logdir)
         File.open(File.join(Autobuild.logdir, "stats.log"), 'a') do |io|
-            formatted_time = "#{start_time.strftime('%F %H:%M:%S')}.#{'%.03i' % [start_time.tv_usec / 1000]}"
+            formatted_msec = format('%.03i', start_time.tv_usec / 1000)
+            formatted_time = "#{start_time.strftime('%F %H:%M:%S')}.#{formatted_msec}"
             io.puts "#{formatted_time} #{target_name} #{phase} #{duration}"
         end
-        if target.respond_to?(:add_stat)
-            target.add_stat(phase, duration)
-        end
+        target.add_stat(phase, duration) if target.respond_to?(:add_stat)
         subcommand_output
-
     rescue Failed => e
-        error = Autobuild::SubcommandFailed.new(target, command.join(" "), logname, e.status, subcommand_output)
+        error = Autobuild::SubcommandFailed.new(target, command.join(" "),
+            logname, e.status, subcommand_output)
         error.retry = if e.retry?.nil? then options[:retry]
                       else e.retry?
                       end
         error.phase = phase
         raise error, e.message
     end
-
 end