bwrap 1.0.0.pre.alpha3 → 1.0.0.pre.beta2

data/lib/bwrap/execution.rb

@@ -1,177 +1,11 @@
 # frozen_string_literal: true
 
-require "bwrap/version"
-require "bwrap/output"
-require_relative "execution/execute"
+require_relative "bwrap_module"
 
-# @abstract Module to be included in a class that needs to execute commands.
-#
-# Methods to execute processes.
+# Declare Execution module here so Bwrap::Execution module is
+# already declared for Execution module classes, to avoid
+# a circular dependency.
 module Bwrap::Execution
-  include Bwrap::Output
-
-  # Unspecified execution related error.
-  class CommandError < StandardError
-  end
-
-  # Signifies that command execution has failed.
-  class ExecutionFailed < CommandError
-  end
-
-  # Actual implementation of execution command. Can be used when static method is needed.
-  #
-  # @note When an array is given as a command, empty strings are passed as empty arguments.
-  #
-  #   This means that `[ "foo", "bar" ]` passes one argument to "foo" command, when
-  #   `[ "foo", "", "bar" ]` passes two arguments.
-  #
-  #   This may or may not be what is assumed, so it can’t be fixed here. It is up to the
-  #   command to decide how to handle empty arguments.
-  #
-  # Returns pid of executed command if wait is false.
-  # Returns command output if wait is true.
-  #
-  # fail == If true, an error is raised in case the command returns failure code.
-  #
-  # @param error if :show, warn()s output of the command is shown if execution failed.
-  #
-  # @see #execute
-  def self.do_execute command,
-                      fail: true,
-                      wait: true,
-                      log: true,
-                      direct_output: false,
-                      env: {},
-                      clear_env: false,
-                      error: nil,
-                      log_callback: 2,
-                      rootcmd: nil
-    command = Execute.format_command command, rootcmd: rootcmd
-    Execute.handle_logging command, log_callback: log_callback, log: log, dry_run: @dry_run
-    return if @dry_run || Bwrap::Execution::Execute.dry_run
-
-    Execute.open_pipes direct_output
-
-    # If command is an array, there can’t be arrays inside the array.
-    # For convenience, the array is flattened here, so callers can construct commands more easily.
-    if command.respond_to? :flatten!
-      command.flatten!
-    end
-
-    # If command is string, splat operator (the *) does not do anything. If array, it expand the arguments.
-    # This causes spawning work correctly, as that’s how spawn() expects to have the argu
-    pid = spawn(env, *command, err: [ :child, :out ], out: Execute.w, unsetenv_others: clear_env)
-    output = Execute.finish_execution(log: log, wait: wait, direct_output: direct_output)
-    return pid unless wait
-
-    # This is instant return, but allows us to have $?/$CHILD_STATUS set.
-    Process.wait pid
-    @last_status = $CHILD_STATUS
-
-    output = Execute.process_output output: output
-    Execute.handle_execution_fail fail: fail, error: error, output: output
-    output
-  ensure
-    Execute.clean_variables
-  end
-
-  # Returns Process::Status instance of last execution.
-  #
-  # @note This only is able to return the status if wait is true, as otherwise caller is assumed to
-  # handle execution flow.
-  def self.last_status
-    @last_status
-  end
-
-  # Check if requested program can be found.
-  #
-  # Should work cross-platform and in restricted environents pretty well.
-  private def command_available? command
-    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [ "" ]
-    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
-      exts.each do |ext|
-        exe = File.join(path, "#{command}#{ext}")
-        return true if File.executable?(exe) && !File.directory?(exe)
-      end
-    end
-    false
-  end
-
-  # Returns path to given executable.
-  private def which command, fail: true
-    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [ "" ]
-    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
-      exts.each do |ext|
-        exe = File.join(path, "#{command}#{ext}")
-        return exe if File.executable?(exe) && !File.directory?(exe)
-      end
-    end
-    error "Failed to find #{command} from PATH." if fail
-    nil
-  end
-
-  # Execute a command.
-  #
-  # This method can be used by including Execution module in a class that should be able to
-  # execute commands.
-  #
-  # @see .do_execute .do_execute for documentation of argument syntax
-  private def execute *args
-    # Mangle proper location to error message.
-    if args.last.is_a? Hash
-      args.last[:log_callback] = 3
-    else
-      args << { log_callback: 3 }
-    end
-    Bwrap::Execution.do_execute(*args)
-  end
-
-  # Same as ::execute, but uses log: false to avoid unnecessary output when we’re just getting a
-  # value for internal needs.
-  #
-  # Defaults to fail: false, since when one just wants to get the value, there is not that much
-  # need to unconditionally die if getting bad exit code.
-  private def execvalue *args, fail: false, rootcmd: nil, env: {}
-    # This logging handling is a bit of duplication from execute(), but to be extra safe, it is duplicated.
-    # The debug message contents will always be evaluated, so can just do it like this.
-    log_command = args[0].respond_to?(:join) && args[0].join(" ") || args[0]
-    log_command =
-        if log_command.frozen?
-          log_command.dup.force_encoding("UTF-8")
-        else
-          log_command.force_encoding("UTF-8")
-        end
-    if @dry_run
-      puts "Would execvalue “#{log_command}” at #{caller_locations(1, 1)[0]}"
-      return
-    end
-    trace "Execvaluing “#{log_command}” at #{caller_locations(1, 1)[0]}"
-    execute(*args, fail: fail, log: false, rootcmd: rootcmd, env: env)
-  end
-
-  private def exec_success?
-    $CHILD_STATUS.success?
-  end
-
-  private def exec_failure?
-    !exec_success?
-  end
-
-  # When running through bundler, don’t use whatever it defines as we’re running inside chroot.
-  private def clean_execute
-    if (Bundler&.bundler_major_version) >= 2
-      Bundler.with_unbundled_env do
-        yield 2
-      end
-    elsif Bundler&.bundler_major_version == 1
-      Bundler.with_clean_env do
-        yield 1
-      end
-    else
-      yield nil
-    end
-  rescue NameError
-    # If NameError is thrown, no Bundler is available.
-    yield nil
-  end
 end
+
+require_relative "execution/execution"

data/lib/bwrap/output/colors.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "output"
-
 # Methods to color CLI output.
 module Bwrap::Output::Colors
   # Outputs ANSI true color sequence.

data/lib/bwrap/output/log.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-# force_encoding modifies string, so can’t freeze strings.
-
-require_relative "output"
-
 # Logging methods.
+#
+# @note One should require "bwrap/output" instead of this file directly, even
+#   if using only methods from this class.
+#
+#   This is because Bwrap::Output module would be missing, or there could be
+#   a circular dependency, which is always bad, even if Ruby would break it for you.
 class Bwrap::Output::Log
   @@log_file = nil
 
@@ -31,6 +33,10 @@ class Bwrap::Output::Log
 
   # Starts logging to given file.
   def self.log_to_file log_path
+    unless File.writable? log_path
+      warn "Given log file #{log_path} is not writable by current user."
+      return
+    end
     log_file = File.open log_path, "w"
 
     # In default mode, log messages disappears as Ruby’s own buffer gets full.
@@ -40,7 +46,7 @@ class Bwrap::Output::Log
     @@log_file = log_file
 
     at_exit do
-      ::Bwrap::Output::Log.close_log_file
+      Bwrap::Output::Log.close_log_file
     end
   end
 end

data/lib/bwrap/output/output_impl.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+# Have variables like $CHILD_STATUS which is alias of $?.
+require "English"
+
+require "bwrap/bwrap_module"
+require "bwrap/execution/labels"
+
+require_relative "levels"
+require_relative "log"
+
+# Methods useful for output handling.
+#
+# There is four different log levels:
+#
+# @!description_list
+#   @term error
+#   @description
+#     Causes execution to halt either to exit with requested code or,
+#     if requested, raises an exception.
+#   @term warning
+#   @description Outputs given text to STDERR.
+#   @term verbose
+#   @description Outputs given text if verbose, debug or trace flag is set.
+#   @term debug
+#   @description Outputs given text if debug or trace flag is set.
+#   @term trace
+#   @description Outputs given text if trace flag is set.
+#
+# Output levels can be enabled with {.handle_output_options}.
+#
+# When using {Bwrap::Bwrap}, {Bwrap::Bwrap#parse_command_line_arguments}
+# causes output levels to be set if relevant CLI arguments have been
+# given. TODO: Add documentation about CLI args somewhere. Maybe README?
+module Bwrap::Output
+  # @see #verbose?
+  def self.verbose?
+    Bwrap::Output::Levels.verbose?
+  end
+
+  # @see #debug?
+  def self.debug?
+    Bwrap::Output::Levels.debug?
+  end
+
+  # @see #trace?
+  def self.trace?
+    Bwrap::Output::Levels.trace?
+  end
+
+  # Takes hash of options received from Optimist and checks output related flags.
+  def self.handle_output_options options
+    Bwrap::Output::Levels.handle_output_options options
+  end
+
+  # Handler used by #trace to output given string.
+  def self.trace_output str, raw: false, log_callback: 1
+    return unless trace?
+
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.trace_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Handler used by #debug to output given string.
+  def self.debug_output str, raw: false, log_callback: 1
+    return unless debug?
+
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.debug_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Handler used by #verb to output given string.
+  def self.verb_output str, raw: false, log_callback: 1
+    return unless verbose?
+
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.verbose_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Handler used by #warn to output given string.
+  def self.warn_output str, raw: false, log_callback: 1
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.warning_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Aborts current process.
+  #
+  # Use this instead of Ruby’s #exit in order to filter out dummy #exit calls from the code.
+  def self.error_output str = nil, label: :unspecified, log_callback: 1, raise_exception: false
+    unless str.nil?
+      out = Bwrap::Output::Levels.error_print_formatted str, log_callback: (log_callback + 1)
+      Bwrap::Output::Log.puts_to_log out
+    end
+
+    exit_code = Bwrap::Execution::Labels.resolve_exit_code(label)
+    raise str if raise_exception
+
+    exit exit_code
+  end
+
+  # @return true if --verbose, --debug or --trace has been passed, false if not.
+  private def verbose?
+    Bwrap::Output::Levels.verbose?
+  end
+
+  # @return true if --debug or --trace has been passed, false if not.
+  private def debug?
+    Bwrap::Output::Levels.debug?
+  end
+
+  # @return true if --trace has been passed, false if not.
+  private def trace?
+    Bwrap::Output::Levels.trace?
+  end
+
+  # @!group Outputters
+
+  # Outputs given string if trace flag has been set.
+  #
+  # Output flags can be set with {.handle_output_options}.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def trace str, raw: false
+    Bwrap::Output.trace_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string if debug flag has been set.
+  #
+  # Output flags can be set with {.handle_output_options}.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def debug str, raw: false
+    Bwrap::Output.debug_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string if verbose flag has been set.
+  #
+  # Output flags can be set with {.handle_output_options}.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def verb str, raw: false
+    Bwrap::Output.verb_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string to `$stderr`.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def warn str, raw: false
+    Bwrap::Output.warn_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string to `$stderr` and halts execution.
+  #
+  # @param str String to be outputted
+  # @param label [Symbol] Exit label accepted by {Bwrap::Execution.resolve_exit_code}
+  # @param raise_exception [Boolean] if true, an exception is raised instead of just existing with exit code.
+  private def error str = nil, label: :unspecified, raise_exception: false
+    Bwrap::Output.error_output(str, label: label, log_callback: 2, raise_exception: raise_exception)
+  end
+
+  # @!endgroup
+end

data/lib/bwrap/output.rb

@@ -1,153 +1,13 @@
 # frozen_string_literal: true
 
-# Have variables like $CHILD_STATUS which is alias of $?.
-require "English"
+require_relative "bwrap_module"
 
-require "bwrap/execution/labels"
-require_relative "output/colors"
-require_relative "output/levels"
-require_relative "output/log"
-
-# Extends the module with outputting methods.
+# Declare Output module here so Bwrap::Output module is
+# already declared for Output module classes, to avoid
+# a circular dependency.
+#
+# See output/output.rb for documentation.
 module Bwrap::Output
-  include Bwrap::Output::Colors
-
-  # @see #verbose?
-  def self.verbose?
-    Bwrap::Output::Levels.verbose?
-  end
-
-  # @see #debug?
-  def self.debug?
-    Bwrap::Output::Levels.debug?
-  end
-
-  # @see #trace?
-  def self.trace?
-    Bwrap::Output::Levels.trace?
-  end
-
-  # Takes hash of options received from Optimist and checks output related flags.
-  def self.handle_output_options options
-    Bwrap::Output::Levels.handle_output_options options
-  end
-
-  # Handler used by #trace to output given string.
-  def self.trace_output str, raw: false, log_callback: 1
-    return unless trace?
-
-    if raw
-      print str
-    else
-      out = Bwrap::Output::Levels.trace_print_formatted str, log_callback: (log_callback + 1)
-    end
-    Bwrap::Output::Log.puts_to_log out || str
-  end
-
-  # Handler used by #debug to output given string.
-  def self.debug_output str, raw: false, log_callback: 1
-    return unless debug?
-
-    if raw
-      print str
-    else
-      out = Bwrap::Output::Levels.debug_print_formatted str, log_callback: (log_callback + 1)
-    end
-    Bwrap::Output::Log.puts_to_log out || str
-  end
-
-  # Handler used by #verb to output given string.
-  def self.verb_output str, raw: false, log_callback: 1
-    return unless verbose?
-
-    if raw
-      print str
-    else
-      out = Bwrap::Output::Levels.verbose_print_formatted str, log_callback: (log_callback + 1)
-    end
-    Bwrap::Output::Log.puts_to_log out || str
-  end
-
-  # Handler used by #warn to output given string.
-  def self.warn_output str, raw: false, log_callback: 1
-    if raw
-      print str
-    else
-      out = Bwrap::Output::Levels.warning_print_formatted str, log_callback: (log_callback + 1)
-    end
-    Bwrap::Output::Log.puts_to_log out || str
-  end
-
-  # Aborts current process.
-  #
-  # Use this instead of Ruby’s #exit in order to filter out dummy #exit calls from the code.
-  def self.error_output str = nil, label: :unspecified, log_callback: 1
-    unless str.nil?
-      out = Bwrap::Output::Levels.error_print_formatted str, log_callback: (log_callback + 1)
-      Bwrap::Output::Log.puts_to_log out
-    end
-
-    exit Bwrap::Execution::Labels.resolve_exit_code(label)
-  end
-
-  # @return true if --verbose, --debug or --trace has been passed, false if not.
-  private def verbose?
-    Bwrap::Output::Levels.verbose?
-  end
-
-  # @return true if --debug or --trace has been passed, false if not.
-  private def debug?
-    Bwrap::Output::Levels.debug?
-  end
-
-  # @return true if --trace has been passed, false if not.
-  private def trace?
-    Bwrap::Output::Levels.trace?
-  end
-
-  # Outputs given string if trace flag has been set.
-  #
-  # Output flags can be set with {.handle_output_options}.
-  #
-  # @param str String to be outputted
-  # @param raw [Boolean] If true, disables output formatting
-  private def trace str, raw: false
-    Bwrap::Output.trace_output(str, raw: raw, log_callback: 2)
-  end
-
-  # Outputs given string if debug flag has been set.
-  #
-  # Output flags can be set with {.handle_output_options}.
-  #
-  # @param str String to be outputted
-  # @param raw [Boolean] If true, disables output formatting
-  private def debug str, raw: false
-    Bwrap::Output.debug_output(str, raw: raw, log_callback: 2)
-  end
-
-  # Outputs given string if verbose flag has been set.
-  #
-  # Output flags can be set with {.handle_output_options}.
-  #
-  # @param str String to be outputted
-  # @param raw [Boolean] If true, disables output formatting
-  private def verb str, raw: false
-    Bwrap::Output.verb_output(str, raw: raw, log_callback: 2)
-  end
-
-  # Outputs given string to `$stderr`.
-  #
-  # @param str String to be outputted
-  # @param raw [Boolean] If true, disables output formatting
-  private def warn str, raw: false
-    Bwrap::Output.warn_output(str, raw: raw, log_callback: 2)
-  end
-
-  # Outputs given string to `$stderr` and halts execution.
-  #
-  # @param str String to be outputted
-  # @param label [Symbol] Exit label accepted by {Bwrap::Execution.resolve_exit_code}
-  private def error str = nil, label: :unspecified
-    Bwrap::Output.error_output(str, label: label, log_callback: 2)
-  end
 end
+
+require_relative "output/output_impl"

data/lib/bwrap/version.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-# bwrap command runner tools.
 module Bwrap
   # Current version of bwrap.
-  VERSION = "1.0.0-alpha3"
+  VERSION = "1.0.0-beta2"
 end
 
 require "deep-cover" if ENV["DEEP_COVER"]

data/lib/bwrap.rb

@@ -1,74 +1,3 @@
 # frozen_string_literal: true
 
-require "optimist"
-
-#require "deep-cover" if ENV["DEEP_COVER"]
-
-require "bwrap/version"
-require "bwrap/args/construct"
-require "bwrap/config"
-require "bwrap/execution"
-
-# Executes bwrap command using given configuration.
-class Bwrap::Bwrap
-  include Bwrap::Execution
-
-  def initialize config
-    @config = config
-
-    parse_command_line_arguments
-  end
-
-  # Runs given command inside bwrap.
-  #
-  # @param command [String, Array] Command, with necessary arguments, to be executed inside bwrap
-  def run command
-    construct = Bwrap::Args::Construct.new
-    construct.config = @config
-    bwrap_args = construct.construct_bwrap_args
-
-    exec_command = [ "bwrap" ]
-    exec_command += bwrap_args
-    exec_command += %W{ #{command} --new-instance }
-    exec_command += ARGV unless ARGV.empty?
-
-    execute exec_command
-
-    construct.cleanup
-  end
-
-  # Parses command line arguments given to caller script.
-  private def parse_command_line_arguments
-    options = optimist_cli_args
-
-    Bwrap::Output.handle_output_options options
-  end
-
-  # Parses global bwrap flags using Optimist.
-  private def optimist_cli_args
-    Optimist.options do
-      version ::Bwrap::VERSION
-
-      banner "Usage:"
-      banner "  #{$PROGRAM_NAME} [global options]\n \n"
-      banner "Global options:"
-      opt :verbose,
-          "Show verbose output",
-          short: "v"
-      opt :debug,
-          "Show debug output (useful when debugging a problem)",
-          short: "d"
-      opt :trace,
-          "Show trace output (noisiest, probably not useful for most of time)",
-          short: :none
-      opt :version,
-          "Print version and exit",
-          short: "V"
-      opt :help,
-          "Show help message",
-          short: "h"
-
-      educate_on_error
-    end
-  end
-end
+require "bwrap/bwrap"