ruby_git 0.2.0 → 0.3.1

data/bin/command-line-test

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'command_line_boss'
+
+# A script used to test calling a command line program from Ruby
+#
+# This script is used to test the `Git::CommandLine` class. It is called
+# from the `test_command_line` unit test.
+#
+# --stdout: string to output to stdout
+# --stderr: string to output to stderr
+# --exitstatus: exit status to return (default is zero)
+# --signal: uncaught signal to raise (default is not to signal)
+# --duration: number of seconds to sleep before exiting (default is zero)
+#
+# Both --stdout and --stderr can be given.
+#
+# If --signal is given, --exitstatus is ignored.
+#
+# Examples:
+# Output "Hello, world!" to stdout and exit with status 0
+#    $ bin/command-line-test --stdout="Hello, world!" --exitstatus=0
+#
+# Output "ERROR: timeout" to stderr and exit with status 1
+#   $ bin/command-line-test --stderr="ERROR: timeout" --exitstatus=1
+#
+# Output "Fatal: killed by parent" to stderr and signal 9
+#   $ bin/command-line-test --stderr="Fatal: killed by parent" --signal=9
+#
+# Output to both stdout and stderr return default exitstatus 0
+#   $ bin/command-line-test --stdout="Hello, world!" --stderr="ERROR: timeout"
+#
+
+# The command line parser for this script
+#
+# @example
+#   parser = CommandLineParser.new
+#   options = parser.parse(['--exitstatus', '1', '--stderr', 'ERROR: timeout', '--duration', '5'])
+#
+# @api private
+class CommandLineParser < CommandLineBoss
+  attr_reader :duration, :stdout, :stderr, :exitstatus, :signal, :env_vars, :remaining_args
+
+  private
+
+  def set_defaults
+    @duration = 0.0
+    @stdout = nil
+    @stderr = nil
+    @exitstatus = 0
+    @signal = nil
+    @env_vars = []
+    @remaining_args = []
+  end
+
+  include CommandLineBoss::HelpOption
+
+  def parse_arguments
+    @remaining_args = args.shift(args.length)
+  end
+
+  def banner = <<~HEADER
+    A script used to test calling a command line program from Ruby
+
+    Command line options allow control of the output, exit status, signal
+    raised, and the duration of the command.
+
+    Usage: #{$PROGRAM_NAME} [options]
+
+  HEADER
+
+  def footer = <<~HEADER
+    The default exitstatus is 0.
+    The default duration is 0.
+    Both --stdout and --stderr can be given.
+    If --signal is given, --exitstatus is ignored.
+
+    If no options are given, the script will exit with exitstatus 0.
+  HEADER
+
+  # Define the stdout option
+  # @return [void]
+  # @api private
+  def define_stdout_option
+    parser.on('--stdout="string to stdout"', 'A string to send to stdout') do |string|
+      @stdout = string
+    end
+  end
+
+  # Define the stdout-file option
+  # @return [void]
+  # @api private
+  def define_stdout_file_option
+    parser.on('--stdout-file="file"', 'Send contents of file to stdout') do |filename|
+      @stdout = File.binread(filename)
+    end
+  end
+
+  # Define the stderr option
+  # @return [void]
+  # @api private
+  def define_stderr_option
+    parser.on('--stderr="string to stderr"', 'A string to send to stderr') do |string|
+      @stderr = string
+    end
+  end
+
+  # Define the stderr-file option
+  # @return [void]
+  # @api private
+  def define_stderr_file_option
+    parser.on('--stderr-file="file"', 'Send contents of file to stderr') do |filename|
+      @stderr = File.binread(filename)
+    end
+  end
+
+  # Define the exitstatus option
+  # @return [void]
+  # @api private
+  def define_exitstatus_option
+    parser.on('--exitstatus=1', 'The exitstatus to return') do |exitstatus|
+      @exitstatus = Integer(exitstatus)
+    end
+  end
+
+  # Define the signal option
+  # @return [void]
+  # @api private
+  def define_signal_option
+    parser.on('--signal=9', 'The signal to raise') do |signal|
+      @signal = Integer(signal)
+    end
+  end
+
+  # Define the duration option
+  # @return [void]
+  # @api private
+  def define_duration_option
+    parser.on('--duration=0', 'The number of seconds the command should take') do |duration|
+      @duration = Float(duration)
+    end
+  end
+
+  # Define the envvar option
+  # @return [void]
+  # @api private
+  def define_env_var_option
+    parser.on('--env-var=name', 'Display an environment variable') do |name|
+      @env_vars << name
+    end
+  end
+end
+
+options = CommandLineParser.new.parse(ARGV)
+
+if options.error_messages.any?
+  warn options.error_messages.join("\n")
+  exit 1
+end
+
+options.remaining_args.each do |arg|
+  warn "Found argument: #{arg}"
+end
+
+options.env_vars.each do |name|
+  print "Environment variable #{name}="
+  if ENV.key?(name)
+    puts ENV[name].inspect
+  else
+    puts '<not set>'
+  end
+end
+
+if options.stdout
+  $stdout.binmode
+  $stdout.puts options.stdout
+end
+
+if options.stderr
+  $stderr.binmode
+  $stderr.puts options.stderr # rubocop:disable Style/StderrPuts
+end
+
+sleep options.duration unless options.duration.zero?
+
+Process.kill(options.signal, Process.pid) if options.signal
+
+exit(options.exitstatus) if options.exitstatus

data/bin/console

@@ -12,4 +12,6 @@ require 'ruby_git'
 # Pry.start
 
 require 'irb'
+require_relative '../spec/spec_helper'
+
 IRB.start(__FILE__)

data/bin/setup

@@ -1,6 +1,17 @@
 #!/usr/bin/env bash
+
+# Same setup script for Ruby projects that also installs the conventional commit git hook
+
 set -euo pipefail
 IFS=$'\n\t'
-set -vx
 
-cp pre-commit .git/hooks/pre-commit
+# set -vx
+
+bundle install
+
+if [ -x "$(command -v npm)" ]; then
+  npm install
+else
+  echo "npm is not installed"
+  echo "Install npm then re-run this script to enable the conventional commit git hook."
+fi

data/lib/ruby_git/command_line/options.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'process_executer'
+
+module RubyGit
+  module CommandLine
+    # Defines the options for RubyGit::CommandLine::Runner
+    #
+    # @api public
+    #
+    class Options < ProcessExecuter::Options::RunOptions
+      # Alias for brevity
+      OptionDefinition = ProcessExecuter::Options::OptionDefinition
+
+      private
+
+      # :nocov: SimpleCov on JRuby reports the last with the last argument line is not covered
+
+      # The options allowed for objects of this class
+      # @return [Array<OptionDefinition>]
+      # @api private
+      def define_options
+        [
+          *super,
+          OptionDefinition.new(:normalize_encoding, default: false, validator: method(:validate_normalize_encoding)),
+          OptionDefinition.new(:chomp, default: false, validator: method(:validate_chomp)),
+          OptionDefinition.new(:raise_git_errors, default: true, validator: method(:validate_raise_git_errors))
+        ].freeze
+      end
+      # :nocov:
+
+      # Validate the raise_git_errors option value
+      # @return [String, nil] the error message if the value is not valid
+      # @api private
+      def validate_raise_git_errors
+        return if [true, false].include?(raise_git_errors)
+
+        errors << "raise_git_errors must be true or false but was #{raise_git_errors.inspect}"
+      end
+
+      # Validate the normalize_encoding option value
+      # @return [String, nil] the error message if the value is not valid
+      # @api private
+      def validate_normalize_encoding
+        return if [true, false].include?(normalize_encoding)
+
+        errors << "normalize_encoding must be true or false but was #{normalize_encoding.inspect}"
+      end
+
+      # Validate the chomp option value
+      # @return [String, nil] the error message if the value is not valid
+      # @api private
+      def validate_chomp
+        return if [true, false].include?(chomp)
+
+        errors << "chomp must be true or false but was #{chomp.inspect}"
+      end
+    end
+  end
+end

data/lib/ruby_git/command_line/result.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'process_executer'
+
+module RubyGit
+  module CommandLine
+    # The result of running a git command
+    #
+    # Adds stdout and stderr processing to the `ProcessExecuter::Result` class.
+    #
+    # @api public
+    #
+    class Result < SimpleDelegator
+      # @!method initialize(result)
+      #   Initialize a new result object
+      #   @example
+      #     result = ProcessExecuter.run('echo hello')
+      #     RubyGit::CommandLine::Result.new(result)
+      #   @param [ProcessExecuter::Result] result The result of running the command
+      #   @return [RubyGit::CommandLine::Result]
+      #   @api public
+
+      # Return the processed stdout output (or original if it was not processed)
+      #
+      # This output is only returned if a stdout redirection is a
+      # `ProcessExecuter::MonitoredPipe`.
+      #
+      # @example
+      #   result = ProcessExecuter.run('echo hello': out: StringIO.new)
+      #   result.stdout #=> "hello\n"
+      #
+      # @return [String, nil]
+      #
+      def stdout
+        defined?(@processed_stdout) ? @processed_stdout : unprocessed_stdout
+      end
+
+      # Process the captured stdout output
+      #
+      # @example
+      #   result = ProcessExecuter.run('echo hello', out: StringIO.new)
+      #   result.stdout #=> "hello\n"
+      #   result.process_stdout { |stdout, _result| stdout.upcase }
+      #   result.stdout #=> "HELLO\n"
+      #   result.unprocessed_stdout #=> "hello\n"
+      #
+      # @example Chain processing
+      #   result = ProcessExecuter.run('echo hello', out: StringIO.new)
+      #   result.stdout #=> "hello\n"
+      #   result.process_stdout { |s| s.upcase }.process_stdout { |s| s.reverse }
+      #   result.stdout #=> "OLLEH\n"
+      #   result.unprocessed_stdout #=> "hello\n"
+      #
+      # @return [String, nil]
+      #
+      # @yield [stdout, result] Yields the stdout output and the result object
+      # @yieldparam stdout [String] The output to process
+      # @yieldparam result [RubyGit::CommandLine::Result] This object (aka self)
+      # @yieldreturn [String] The processed stdout output
+      #
+      # @api public
+      #
+      def process_stdout(&block)
+        return if block.nil?
+
+        @processed_stdout = block.call(stdout, self)
+        self
+      end
+
+      # Returns the original stdout output before it was processed
+      #
+      # @example
+      #   result = ProcessExecuter.run('echo hello', out: StringIO.new)
+      #   result.stdout #=> "hello\n"
+      #   result.unprocessed_stdout #=> "hello\n"
+      #   result.process_stdout { |s| s.upcase }
+      #   result.stdout #=> "HELLO\n"
+      #   result.unprocessed_stdout #=> "hello\n"
+      #
+      # @return [String, nil]
+      #
+      # @api public
+      #
+      def unprocessed_stdout
+        __getobj__.stdout
+      end
+
+      # Return the processed stderr output (or original if it was not processed)
+      #
+      # This output is only returned if a stderr redirection is a
+      # `ProcessExecuter::MonitoredPipe`.
+      #
+      # @example
+      #   result = ProcessExecuter.run('echo hello 1>&2': err: StringIO.new)
+      #   result.stderr #=> "hello\n"
+      #
+      # @return [String, nil]
+      #
+      def stderr
+        defined?(@processed_stderr) ? @processed_stderr : unprocessed_stderr
+      end
+
+      # Process the captured stderr output
+      #
+      # @example
+      #   result = ProcessExecuter.run('echo hello 1>&2', err: StringIO.new)
+      #   result.stderr #=> "hello\n"
+      #   result.process_stderr { |stderr, _result| stderr.upcase }
+      #   result.stderr #=> "HELLO\n"
+      #   result.unprocessed_stderr #=> "hello\n"
+      #
+      # @example Chain processing
+      #   result = ProcessExecuter.run('echo hello 1>&2', err: StringIO.new)
+      #   result.stderr #=> "hello\n"
+      #   result.process_stderr { |s| s.upcase }.process_stderr { |s| s.reverse }
+      #   result.stderr #=> "OLLEH\n"
+      #   result.unprocessed_stderr #=> "hello\n"
+      #
+      # @return [String, nil]
+      #
+      # @yield [stderr, result] Yields the stderr output and the result object
+      # @yieldparam stderr [String] The output to process
+      # @yieldparam result [RubyGit::CommandLine::Result] This object (aka self)
+      # @yieldreturn [String] The processed stderr output
+      #
+      # @api public
+      #
+      def process_stderr(&block)
+        return if block.nil?
+
+        @processed_stderr = block.call(stderr, self)
+        self
+      end
+
+      # Returns the original stderr output before it was processed
+      #
+      # @example
+      #   result = ProcessExecuter.run('echo hello 1>&2', err: StringIO.new)
+      #   result.stderr #=> "hello\n"
+      #   result.unprocessed_stderr #=> "hello\n"
+      #   result.process_stderr { |stderr| stderr.upcase }
+      #   result.stderr #=> "HELLO\n"
+      #   result.unprocessed_stderr #=> "hello\n"
+      #
+      # @return [String, nil]
+      #
+      # @api public
+      #
+      def unprocessed_stderr
+        __getobj__.stderr
+      end
+    end
+  end
+end