autobuild 1.17.0 → 1.21.0

data/lib/autobuild/rake_task_extension.rb

@@ -1,19 +1,24 @@
 module Autobuild
     module RakeTaskExtension
         def already_invoked?
-            !!@already_invoked
+            @already_invoked
         end
 
-        def already_invoked=(value)
-            @already_invoked = value
+        attr_writer :already_invoked
+
+        def disabled?
+            @disabled
+        end
+
+        def disabled!
+            disable
         end
 
-        def disable!
-            @already_invoked = true
-            def self.needed?; false end
+        def disable
+            @disabled = true
         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
@@ -45,10 +47,23 @@ def self.progress_display_enabled?
         @display.progress_enabled?
     end
 
+    def self.progress_display_synchronize(&block)
+        @display.synchronize(&block)
+    end
+
+    # @deprecated use {progress_display_mode=} instead
     def self.progress_display_enabled=(value)
         @display.progress_enabled = value
     end
 
+    def self.progress_display_mode=(value)
+        @display.progress_mode = value
+    end
+
+    def self.progress_display_period=(value)
+        @display.progress_period = value
+    end
+
     def self.message(*args, **options)
         @display.message(*args, **options)
     end
@@ -80,7 +95,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 +104,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 +140,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 +160,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 +192,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 +216,7 @@ def self.each_log(&block)
     ## Base class for reporters
     class Reporter
         def error(error); end
+
         def success; end
     end
 
@@ -203,11 +225,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 +237,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