sproc 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2ccda7be2976e3c6daaa74c8a37c858fdc76f5d929e1cf87b77cc7411d9f72d
-  data.tar.gz: ae73fcb466456779be5e91afc1bbe8e67b368bed7f3c834a0d523acaacfdd9a9
+  metadata.gz: 13cf3463eedf90a3e4d64a1bd60d7b9e49a6c08b49f2b957a0b8667ea2f8ef17
+  data.tar.gz: d29364e2b3738102c2eeadb6c5084eeea72ff35fc89c7ee2a7be0ebe1b2d420a
 SHA512:
-  metadata.gz: abc0511633bf642dfaffd0a35f00f9d257bc38f316010418932b910bfeebbcb7d7c7f479aa70fed8aa31fe6be24eacc19f69a0108a17d766910c7145da3e194a
-  data.tar.gz: 6d00c01bf0791f2919b37449cf76ee95a71dba9aa95713e0c0955dd37bcb4c9a41b7881e7a4e7058d8800c64963ea78bb804550e6bd66cf0e4e1fada40daf82f
+  metadata.gz: '08dd7e0860ae172a028855727e81855100454a059f6614e49a34565ade89f0edba2c72a1fc38f6accbd765d222dde2da71ea297a844ffbcb0d359126945ea198'
+  data.tar.gz: 9a1d55462170d19154cccbd938f92278e0bd521c0432b3bcdf04c8c6f09a645f601a1c5ee275bdc9b36d6122bcfd89f8ceb11699902ea41379f39b5baefa2704

data/lib/sproc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SProc
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sproc
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Anders Rillbert
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-28 00:00:00.000000000 Z
+date: 2021-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -44,7 +44,6 @@ files:
 - lib/sproc.rb
 - lib/sproc/core.rb
 - lib/sproc/osinfo.rb
-- lib/sproc/reporting.rb
 - lib/sproc/version.rb
 - sproc.gemspec
 homepage: https://github.com/rillbert/sproc

data/lib/sproc/reporting.rb

@@ -1,196 +0,0 @@
-require_relative 'core'
-
-# This module is written to provide sub-process
-# execution with some human readable logging of process start/stop/errors
-#
-# It wraps SProc instances and execution with calls to logging methods
-# that tries to make the resulting log user friendly
-module SProc
-  module Reporting
-    class << self
-      attr_accessor :logger
-    end
-
-    def logger
-      Reporting.logger
-    end
-
-    # Run a process synchronuously via the native shell and log
-    # output suitable for a build log
-    #
-    # @param cmd_name   a String containing a descriptive
-    #                        name for what the process will do.
-    # @param cmd, args, opts see SProc.exec_sync
-    #
-    # @return                the SProc instance containing the completed process
-    def report_sync(cmd_name, cmd, *args, **opts)
-      p = create_proc_and_log(cmd_name,
-                              ShellType::NONE, :exec_sync,
-                              cmd, args, opts)
-      report_completed(p)
-      p
-    end
-
-    # Run a process asynchronuously via the native shell and log
-    # output suitable for a build log
-    #
-    # @param cmd_name   a String containing a descriptive
-    #                        name for what the process will do.
-    # @param cmd, args, opts see SProc.exec_sync
-    #
-    # @return                the created SProc instance
-    def report_async(cmd_name, cmd, *args, **opts)
-      create_proc_and_log(cmd_name,
-                          ShellType::NONE, :exec_async,
-                          cmd, args, opts)
-    end
-
-    # Run a process asynchronuously via the Bash shell and log
-    # output suitable for a build log
-    #
-    # @param cmd_name   a String containing a descriptive
-    #                        name for what the process will do.
-    # @param cmd, args, opts see SProc.exec_sync
-    #
-    # @return                the created SProc instance
-    def report_async_within_bash(cmd_name, cmd, *args, **opts)
-      create_proc_and_log(cmd_name,
-                          ShellType::BASH, :exec_async,
-                          cmd, args, opts)
-    end
-
-    # Log output from a completed/aborted process
-    #
-    # @param process   the SProc instance that has run
-    # @return          true/false corresponding to process success
-    def report_completed(process)
-      friendly_name = if @log_friendly_name_map&.key?(process)
-                  "#{@log_friendly_name_map[process]}"
-                else
-                  process.task_info[:cmd_str][0,10] + "..."
-                end
-      started_ok = true
-      case process.execution_state
-      when ExecutionState::COMPLETED
-        process.exit_zero? && log_completed_ok(friendly_name, process.task_info)
-        !process.exit_zero? && log_completed_err(friendly_name, process.task_info)
-      when ExecutionState::ABORTED
-        log_aborted(friendly_name, process.task_info)
-        started_ok = false
-      when ExecutionState::FAILED_TO_START
-        log_failed_start(friendly_name, process.task_info)
-        started_ok = false
-      else
-        log_unexpected(friendly_name, process.task_info)
-      end
-      started_ok && process.exit_zero?
-    end
-
-    private
-
-    def create_proc_and_log(cmd_name, type, method, cmd, args, opts)
-      log_start(cmd_name, type, method, cmd, args, **opts)
-      p = SProc.new(type: type).send(method, cmd, args, **opts)
-      @log_friendly_name_map ||= {}
-      @log_friendly_name_map[p] = cmd_name
-      p
-    end
-
-    def log_method_result_ok(friendly_name, delta)
-      logger.info do
-        "#{friendly_name} completed successfully after #{delta.round(3)}s"
-      end
-    end
-
-    def log_method_result_error(friendly_name_method, delta, exc)
-      logger.error do
-        "#{friendly_name_method} aborted by #{exc.class} after #{delta.round(3)}s\n"\
-        "Exception info: #{exc.message}"
-      end
-
-      logger.debug do
-        exc.backtrace.to_s
-      end
-    end
-
-    def log_start(cmd_name, type, method, cmd, *args, **opts)
-      logger.info do
-        async_str = method == :exec_async ? 'asynchronuously' : 'synchronuously'
-        type_str = type == ShellType::NONE ? 'without shell' : 'within the bash shell'
-        "'#{cmd_name}' executing #{async_str} #{type_str}..."
-      end
-      logger.debug do
-        msg = String.new("Starting #{cmd}")
-        msg << " with args: #{args.flatten.inspect}" unless args.nil? || args.empty?
-        msg << " and opts: #{opts.inspect}" unless opts.nil? || opts.empty?
-        msg
-      end
-    end
-
-    def log_one_dll(regex, cmd_str, time)
-      m = regex.match(cmd_str)
-      s = m.nil? ? cmd_str : m[1]
-      max = 45
-      s = s.length > max ? s.slice(0..max - 1) : s.ljust(max)
-      logger.info { "#{s} took #{time.round(3)}s." }
-    end
-
-    def log_aborted(friendly_name, p_info)
-      logger.error do
-        "'#{friendly_name}' aborted!\n"\
-        "When running: #{p_info[:cmd_str]}\n"\
-        "#{merge_proc_output(p_info)}"\
-        "#{p_info[:process_status] unless p_info[:process_status].nil?}"
-      end
-    end
-
-    def log_failed_start(friendly_name, p_info)
-      logger.error do
-        "'#{friendly_name}' not run!\n"\
-        "Could not start process using: #{p_info[:cmd_str]}\n"\
-        "#{merge_proc_output(p_info)}"
-      end
-    end
-
-    def log_completed_ok(friendly_name, p_info)
-      logger.info do
-        "'#{friendly_name}' completed successfully after #{p_info[:wall_time].round(3)}s"
-      end
-      logger.debug do
-        "Cmd: #{p_info[:cmd_str]}"
-      end
-    end
-
-    def log_completed_err(friendly_name, p_info)
-      logger.error do
-        "'#{friendly_name}' completed with exit code "\
-        "#{p_info[:process_status].exitstatus}\n"\
-        "When running: #{p_info[:cmd_str]}\n"\
-        "after #{p_info[:wall_time].round(3)}s\n"\
-        "#{merge_proc_output(p_info)}"
-      end
-    end
-
-    def log_unexpected(friendly_name, p_info)
-      logger.error do
-        "'#{friendly_name}' caused unexpected error!"\
-        ' Trying to display info on a running process'\
-        "(#{p_info[:cmd_str]})"
-      end
-    end
-
-    # @return String with sections for each non-empty output stream
-    #                and exception messages
-    def merge_proc_output(p_info)
-      inf_str = %i[stdout stderr].collect do |sym|
-        next('') if p_info[sym].empty?
-
-        "--- #{sym} ---\n#{p_info[sym]}"
-      end.join("\n")
-
-      exc = p_info[:exception]
-      inf_str << "--- exception ---\n#{exc}\n" unless exc.nil?
-      inf_str
-    end
-  end
-end