simple_scripting 0.11.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd6f01ad9ea507d97ac4024fa8e78feb1093e67f75b16d4ac5c5db79354caf18
-  data.tar.gz: a0a1ad4b67822086544890b54590af03a2877a7210f3198109d605a6fa772d57
+  metadata.gz: 0a31e06185c711924565be44455735e02e55b31a98fc6782a101214cf9d37266
+  data.tar.gz: 2fa2139a689a85e1703604a3da2be186ac8596b9b17c0bc2af4c8c8244c8ad4d
 SHA512:
-  metadata.gz: 2ee276b4af46f3746523f9ed11d7b11b4097f65c7139709506363708f1e6303ec1ead4d48c182f480918597272f2c1af92af6620920dad296967540c5b14105c
-  data.tar.gz: 9059bae5453cc7e64eeea88c8279167020bd7cae0c1b67337c4bf83acb055a0ab04b75c746e7c0ea6d2a9184a8b1df5af0754dcfff55a8ad8e9e2b2409c8fe59
+  metadata.gz: bbf4a7477108d85b62922592eedbc550f0896ca75265385c219c052636d0c45628cd93ca59603649f9ee9227cf00fdf2526732918efb0ab7d55fe62d4b158196
+  data.tar.gz: b754caa9b812a0d7a5882d5bc2c67b0e72a276da9385a2be70d423838f00da711a182fb1f9b67c4072176c73a9d4020acb3b2070fba54f83615edd830cc5aa5c

data/lib/simple_scripting/argv.rb

@@ -7,9 +7,19 @@ module SimpleScripting
     # The fact that the following errors don't descend from OptionParser::InvalidOption is somewhat
     # annoying, however, there should be no practical problem.
     #
-    class InvalidCommand < StandardError; end
     class ArgumentError < StandardError; end
 
+    class InvalidCommand < StandardError
+
+      attr_reader :valid_commands
+
+      def initialize(message, valid_commands)
+        super(message)
+        @valid_commands = valid_commands
+      end
+
+    end
+
     class ExitWithCommandsHelpPrinting < Struct.new(:commands_definition)
       # Note that :long_help is not used.
       def print_help(output, long_help)
@@ -61,12 +71,18 @@ module SimpleScripting
       exit_data.print_help(output, @long_help)
 
       nil # to be used with the 'decode(...) || exit' pattern
-    rescue SimpleScripting::Argv::ArgumentError, SimpleScripting::Argv::InvalidCommand, OptionParser::InvalidOption => error
-      if raise_errors
-        raise
-      else
-        output.puts "Command error!: #{error.message}"
-      end
+    rescue SimpleScripting::Argv::ArgumentError, OptionParser::InvalidOption => error
+      raise if raise_errors
+        
+      output.puts "Command error!: #{error.message}"
+    rescue SimpleScripting::Argv::InvalidCommand => error
+      raise if raise_errors
+
+      output.puts <<~MESSAGE
+        Command error!: #{error.message}"
+
+        Valid commands: #{error.valid_commands.join(", ")}
+      MESSAGE
     ensure
       @long_help = nil
     end
@@ -129,13 +145,13 @@ module SimpleScripting
 
       command = command_for_check
 
-      raise InvalidCommand.new("Missing command") if command.nil?
+      raise InvalidCommand.new("Missing command!", commands_definition.keys) if command.nil?
 
       command_params_definition = commands_definition[command]
 
       case command_params_definition
       when nil
-        raise InvalidCommand.new("Invalid command: #{command}")
+        raise InvalidCommand.new("Invalid command: #{command}", commands_definition.keys)
       when Hash
         commands_stack << command
 
@@ -210,14 +226,25 @@ module SimpleScripting
     # DEFINITIONS PROCESSING ###############################
 
     def process_option_definition!(param_definition, parser_opts, result)
+      # Work on a copy; in at least one case (data type definition), we perform destructive
+      # operations.
+      #
+      param_definition = param_definition.dup
+
       if param_definition[1] && param_definition[1].start_with?('--')
-        key = param_definition[1].split(' ')[0][2 .. -1].tr('-', '_').to_sym
+        raw_key, key_argument = param_definition[1].split(' ')
+        key = raw_key[2 .. -1].tr('-', '_').to_sym
+
+        if key_argument&.include?(',')
+          param_definition.insert(2, Array)
+        end
       else
         key = param_definition[0][1 .. -1].to_sym
       end
 
       parser_opts.on(*param_definition) do |value|
-        result[key] = value || true
+        raise "Unexpected (nil; likely programmatic error) value for param definition #{param_definition}" if value.nil?
+        result[key] = value
       end
     end
 

data/lib/simple_scripting/version.rb

@@ -1,5 +1,5 @@
 module SimpleScripting
 
-  VERSION = "0.11.1"
+  VERSION = "0.13.0"
 
 end

data/simple_scripting.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.required_ruby_version = '>= 2.3.0'
   s.authors     = ["Saverio Miroddi"]
-  s.date        = "2019-03-31"
+  s.date        = "2022-07-21"
   s.email       = ["saverio.pub2@gmail.com"]
   s.homepage    = "https://github.com/saveriomiroddi/simple_scripting"
   s.summary     = "Library for simplifying some typical scripting functionalities."

data/spec/simple_scripting/argv_spec.rb

@@ -2,497 +2,512 @@ require_relative '../../lib/simple_scripting/argv.rb'
 
 require 'stringio'
 
-describe SimpleScripting::Argv do
-
-  let(:output_buffer) do
-    StringIO.new
-  end
-
-  describe 'Basic functionality' do
-
-    let(:decoder_params) {[
-      ['-a'                                        ],
-      ['-b',                     '"-b" description'],
-      ['-c', '--c-switch'                          ],
-      ['-d', '--d-switch',       '"-d" description'],
-      ['-e', '--e-switch VALUE'                    ],
-      ['-f', '--f-switch VALUE', '"-f" description'],
-      'mandatory',
-      '[optional]',
-      long_help: 'This is the long help!',
-      output:     output_buffer,
-    ]}
-
-    context 'help' do
-
-      it 'should print help automatically by default' do
-        decoder_params.last[:arguments] = ['-h']
-
-        return_value = described_class.decode(*decoder_params)
-
-        expected_output = <<~OUTPUT
-          Usage: rspec [options] <mandatory> [<optional>]
-              -a
-              -b                               "-b" description
-              -c, --c-switch
-              -d, --d-switch                   "-d" description
-              -e, --e-switch VALUE
-              -f, --f-switch VALUE             "-f" description
-              -h, --help                       Help
-
-          This is the long help!
-        OUTPUT
-
-        expect(output_buffer.string).to eql(expected_output)
-        expect(return_value).to be(nil)
-      end
-
-      it 'should not interpret the --help argument, and not print the help, on auto_help: false' do
-        decoder_params.last.merge!(
-          arguments: ['--help', 'm_arg'],
-          auto_help: false
-        )
-
-        actual_result = described_class.decode(*decoder_params)
-
-        expected_result = {
-          help: true,
-          mandatory: 'm_arg',
-        }
-
-        expect(output_buffer.string).to eql('')
-        expect(actual_result).to eql(expected_result)
-      end
-
-      it "should check all the options/arguments when --help is passed, raising an error when they're not correct" do
-        decoder_params.last.merge!(
-          arguments: ['--help'],
-          auto_help: false,
-          raise_errors: true,
-        )
-
-        decoding = -> { described_class.decode(*decoder_params) }
+module SimpleScripting
+  describe Argv do
+    let(:output_buffer) do
+      StringIO.new
+    end
 
-        expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Missing mandatory argument(s)")
-      end
+    describe 'Basic functionality' do
+      let(:decoder_params) {[
+        ['-a'                                        ],
+        ['-b',                     '"-b" description'],
+        ['-c', '--c-switch VAL1,VAL2'                ],
+        ['-d', '--d-switch',       '"-d" description'],
+        ['-e', '--e-switch VALUE'                    ],
+        ['-f', '--f-switch VALUE', '"-f" description'],
+        'mandatory',
+        '[optional]',
+        long_help: 'This is the long help!',
+        output:     output_buffer,
+      ]}
 
-    end # context 'help'
+      context 'help' do
+        it 'should print help automatically by default' do
+          decoder_params.last[:arguments] = ['-h']
 
-    it "should implement basic switches and arguments (all set)" do
-      decoder_params.last[:arguments] = ['-a', '-b', '-c', '-d', '-ev_swt', '-fv_swt', 'm_arg', 'o_arg']
+          return_value = described_class.decode(*decoder_params)
 
-      actual_result = described_class.decode(*decoder_params)
+          expected_output = <<~OUTPUT
+            Usage: rspec [options] <mandatory> [<optional>]
+                -a
+                -b                               "-b" description
+                -c, --c-switch VAL1,VAL2
+                -d, --d-switch                   "-d" description
+                -e, --e-switch VALUE
+                -f, --f-switch VALUE             "-f" description
+                -h, --help                       Help
 
-      expected_result = {
-        a:          true,
-        b:          true,
-        c_switch:   true,
-        d_switch:   true,
-        e_switch:   'v_swt',
-        f_switch:   'v_swt',
-        mandatory:  'm_arg',
-        optional:   'o_arg',
-      }
+            This is the long help!
+          OUTPUT
 
-      expect(actual_result).to eql(expected_result)
-    end
+          expect(output_buffer.string).to eql(expected_output)
+          expect(return_value).to be(nil)
+        end
 
-    it "should implement basic switches and arguments (no optional argument)" do
-      decoder_params.last[:arguments] = ['m_arg']
+        it 'should not interpret the --help argument, and not print the help, on auto_help: false' do
+          decoder_params.last.merge!(
+            arguments: ['--help', 'm_arg'],
+            auto_help: false
+          )
 
-      actual_result = described_class.decode(*decoder_params)
+          actual_result = described_class.decode(*decoder_params)
 
-      expected_result = {
-        mandatory: 'm_arg',
-      }
+          expected_result = {
+            help: true,
+            mandatory: 'm_arg',
+          }
 
-      expect(actual_result).to eql(expected_result)
-    end
+          expect(output_buffer.string).to eql('')
+          expect(actual_result).to eql(expected_result)
+        end
 
-    context "multiple optional arguments" do
+        it "should check all the options/arguments when --help is passed, raising an error when they're not correct" do
+          decoder_params.last.merge!(
+            arguments: ['--help'],
+            auto_help: false,
+            raise_errors: true,
+          )
 
-      let(:decoder_params) {[
-        '[optional1]',
-        '[optional2]',
-        output:     output_buffer,
-      ]}
+          expect {
+            described_class.decode(*decoder_params)
+          }.to raise_error(Argv::ArgumentError, "Missing mandatory argument(s)")
+        end
+      end # context 'help'
 
-      it "should correctly decode a single argument passed" do
-        decoder_params.last[:arguments] = ['o_arg1']
+      it "should implement basic switches, with conversion, and arguments (all set)" do
+        decoder_params.last[:arguments] = ['-a', '-b', '-c', 'a,b,c', '-d', '-ev_swt', '-fv_swt', 'm_arg', 'o_arg']
 
         actual_result = described_class.decode(*decoder_params)
 
         expected_result = {
-          optional1: 'o_arg1',
+          a:          true,
+          b:          true,
+          c_switch:   %w(a b c),
+          d_switch:   true,
+          e_switch:   'v_swt',
+          f_switch:   'v_swt',
+          mandatory:  'm_arg',
+          optional:   'o_arg',
         }
 
         expect(actual_result).to eql(expected_result)
       end
 
-      it "should correctly decode all arguments passed" do
-        decoder_params.last[:arguments] = ['o_arg1', 'o_arg2']
+      it "should implement basic switches and arguments (no optional argument)" do
+        decoder_params.last[:arguments] = ['m_arg']
 
         actual_result = described_class.decode(*decoder_params)
 
         expected_result = {
-          optional1: 'o_arg1',
-          optional2: 'o_arg2',
+          mandatory: 'm_arg',
         }
 
         expect(actual_result).to eql(expected_result)
       end
 
-    end
-
-    context "error handling" do
-
-      # All the other UTs use error raising, for convenience.
-      it "should print the error, with a previx, by default, instead of raising an error" do
-        decoder_params.last[:arguments] = []
-
-        actual_result = described_class.decode(*decoder_params)
-
-        # Returning nil is an important specification, as it's part of the Argv protocol of doing
-        # so in case of problem/exit.
-        expect(actual_result).to be(nil)
-
-        expect(output_buffer.string).to eql("Command error!: Missing mandatory argument(s)\n")
-      end
-
-      it "should raise an error when mandatory arguments are missing" do
-        decoder_params.last.merge!(
-          arguments: [],
-          raise_errors: true,
-        )
+      context "booleans" do
+        VALID_BOOLS = {
+          'false' => false,
+          'true'  => true,
+        }
 
-        decoding = -> { described_class.decode(*decoder_params) }
+        INVALID_BOOLS = %w[falx FALSE TRUE]
 
-        expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Missing mandatory argument(s)")
-      end
+        VALID_BOOLS.each do |user_value, decoded_value|
+          it "should decode a #{decoded_value} value" do
+            decoder_params = [
+              ["-b", "--mybool VAL", TrueClass],
+              output:     output_buffer,
+              arguments: ['--mybool', 'false']
+            ]
 
-      it "should raise an error when there are too many arguments" do
-        decoder_params.last.merge!(
-          arguments: ['arg1', 'arg2', 'excessive_arg'],
-          raise_errors: true,
-        )
+            actual_result = described_class.decode(*decoder_params)
 
-        decoding = -> { described_class.decode(*decoder_params) }
+            expected_result = {
+              mybool: false
+            }
 
-        expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Too many arguments")
+            expect(actual_result).to eql(expected_result)
+          end
+        end # context "booleans"
+
+        INVALID_BOOLS.each do |value|
+          it "should raise an error on invalid bool #{value.inspect}" do
+            decoder_params = [
+              ["-b", "--mybool VAL", TrueClass],
+              output:       output_buffer,
+              arguments:    ['--mybool', value],
+              raise_errors: true,
+            ]
+
+            expect {
+              described_class.decode(*decoder_params)
+            }.to raise_error(OptionParser::InvalidArgument)
+          end
+        end
       end
 
-    end # context "error handling"
-
-  end # describe 'Basic functionality'
-
-  describe 'Varargs' do
-
-    describe '(mandatory)' do
-
-      context 'as only parameter' do
-
+      context "multiple optional arguments" do
         let(:decoder_params) {[
-          '*varargs',
+          '[optional1]',
+          '[optional2]',
           output:     output_buffer,
-          arguments:  ['varval1', 'varval2'],
         ]}
 
-        it "should be decoded" do
+        it "should correctly decode a single argument passed" do
+          decoder_params.last[:arguments] = ['o_arg1']
+
           actual_result = described_class.decode(*decoder_params)
 
           expected_result = {
-            varargs:   ['varval1', 'varval2'],
+            optional1: 'o_arg1',
           }
 
           expect(actual_result).to eql(expected_result)
         end
 
-      end
-
-      context 'followed by varargs' do
+        it "should correctly decode all arguments passed" do
+          decoder_params.last[:arguments] = ['o_arg1', 'o_arg2']
 
-        let(:decoder_params) {[
-          'mandatory',
-          '*varargs',
-          output:     output_buffer,
-          arguments:  ['mandval', 'varval1', 'varval2']
-        ]}
-
-        it "should be decoded" do
           actual_result = described_class.decode(*decoder_params)
 
           expected_result = {
-            mandatory: 'mandval',
-            varargs:   ['varval1', 'varval2'],
+            optional1: 'o_arg1',
+            optional2: 'o_arg2',
           }
 
           expect(actual_result).to eql(expected_result)
         end
-
       end
 
       context "error handling" do
+        # All the other UTs use error raising, for convenience.
+        it "should print the error, with a previx, by default, instead of raising an error" do
+          decoder_params.last[:arguments] = []
 
-        let(:decoder_params) {[
-          '*varargs',
-          output:     output_buffer,
-          arguments:  [],
-        ]}
-
-        it "should raise an error when they are not specified" do
-          decoder_params.last[:raise_errors] = true
+          actual_result = described_class.decode(*decoder_params)
 
-          decoding = -> { described_class.decode(*decoder_params) }
+          # Returning nil is an important specification, as it's part of the Argv protocol of doing
+          # so in case of problem/exit.
+          expect(actual_result).to be(nil)
 
-          expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Missing mandatory argument(s)")
+          expect(output_buffer.string).to eql("Command error!: Missing mandatory argument(s)\n")
         end
 
-      end # context "error handling"
-
-    end # describe '(mandatory)'
-
-    describe '(optional)' do
-
-      let(:decoder_params) {[
-        '[*varargs]',
-        output:     output_buffer,
-      ]}
-
-      it "should be decoded" do
-        decoder_params.last[:arguments] = ['varval1', 'varval2']
-
-        actual_result = described_class.decode(*decoder_params)
-
-        expected_result = {
-          varargs:   ['varval1', 'varval2'],
-        }
-
-        expect(actual_result).to eql(expected_result)
-      end
-
-      it "should be allowed not to be specified" do
-        decoder_params.last[:arguments] = []
+        it "should raise an error when mandatory arguments are missing" do
+          decoder_params.last.merge!(
+            arguments: [],
+            raise_errors: true,
+          )
 
-        actual_result = described_class.decode(*decoder_params)
+          expect {
+            described_class.decode(*decoder_params)
+          }.to raise_error(Argv::ArgumentError, "Missing mandatory argument(s)")
+        end
 
-        expected_result = {
-          varargs:   [],
-        }
+        it "should raise an error when there are too many arguments" do
+          decoder_params.last.merge!(
+            arguments: ['arg1', 'arg2', 'excessive_arg'],
+            raise_errors: true,
+          )
 
-        expect(actual_result).to eql(expected_result)
-      end
+          expect {
+            described_class.decode(*decoder_params)
+          }.to raise_error(Argv::ArgumentError, "Too many arguments")
+        end
+      end # context "error handling"
+    end # describe 'Basic functionality'
 
-    end # describe '(optional)'
+    describe 'Varargs' do
+      describe '(mandatory)' do
+        context 'as only parameter' do
+          let(:decoder_params) {[
+            '*varargs',
+            output:     output_buffer,
+            arguments:  ['varval1', 'varval2'],
+          ]}
 
-  end # describe 'Varargs'
+          it "should be decoded" do
+            actual_result = described_class.decode(*decoder_params)
 
-  describe 'Commands' do
+            expected_result = {
+              varargs:   ['varval1', 'varval2'],
+            }
 
-    describe 'regular case' do
+            expect(actual_result).to eql(expected_result)
+          end
+        end
 
-      let(:decoder_params) {{
-        'command1' => [
-          'arg1',
-          long_help: 'This is the long help.'
-        ],
-        'command2' => [
-          'arg2'
-        ],
-        output:     output_buffer,
-      }}
+        context 'followed by varargs' do
+          let(:decoder_params) {[
+            'mandatory',
+            '*varargs',
+            output:     output_buffer,
+            arguments:  ['mandval', 'varval1', 'varval2']
+          ]}
 
-      it 'should be decoded' do
-        decoder_params[:arguments] = ['command1', 'value1']
+          it "should be decoded" do
+            actual_result = described_class.decode(*decoder_params)
 
-        actual_result = described_class.decode(decoder_params)
+            expected_result = {
+              mandatory: 'mandval',
+              varargs:   ['varval1', 'varval2'],
+            }
 
-        expected_result = ['command1', arg1: 'value1']
+            expect(actual_result).to eql(expected_result)
+          end
+        end
 
-        expect(actual_result).to eql(expected_result)
-      end
+        context "error handling" do
+          let(:decoder_params) {[
+            '*varargs',
+            output:     output_buffer,
+            arguments:  [],
+          ]}
 
-      context "error handling" do
+          it "should raise an error when they are not specified" do
+            decoder_params.last[:raise_errors] = true
 
-        it "should raise an error on invalid command" do
-          decoder_params.merge!(
-            arguments: ['pizza'],
-            raise_errors: true,
-          )
+            expect {
+              described_class.decode(*decoder_params)
+            }.to raise_error(Argv::ArgumentError, "Missing mandatory argument(s)")
+          end
+        end # context "error handling"
+      end # describe '(mandatory)'
 
-          decoding = -> { described_class.decode(decoder_params) }
+      describe '(optional)' do
+        let(:decoder_params) {[
+          '[*varargs]',
+          output:     output_buffer,
+        ]}
 
-          expect(decoding).to raise_error(SimpleScripting::Argv::InvalidCommand, "Invalid command: pizza")
-        end
+        it "should be decoded" do
+          decoder_params.last[:arguments] = ['varval1', 'varval2']
 
-        it "should raise a specific error message on missing command" do
-          decoder_params.merge!(
-            arguments: [],
-            raise_errors: true,
-          )
+          actual_result = described_class.decode(*decoder_params)
 
-          decoding = -> { described_class.decode(decoder_params) }
+          expected_result = {
+            varargs:   ['varval1', 'varval2'],
+          }
 
-          expect(decoding).to raise_error(SimpleScripting::Argv::InvalidCommand, "Missing command")
+          expect(actual_result).to eql(expected_result)
         end
 
-      end # context "error handling"
-
-      context "help" do
-
-        it 'should implement the commands help' do
-          decoder_params[:arguments] = ['-h']
+        it "should be allowed not to be specified" do
+          decoder_params.last[:arguments] = []
 
-          described_class.decode(decoder_params)
-
-          expected_output = <<~OUTPUT
-            Valid commands:
+          actual_result = described_class.decode(*decoder_params)
 
-              command1, command2
-          OUTPUT
+          expected_result = {
+            varargs:   [],
+          }
 
-          expect(output_buffer.string).to eql(expected_output)
+          expect(actual_result).to eql(expected_result)
         end
+      end # describe '(optional)'
+    end # describe 'Varargs'
 
-        it "should display the command given command's help" do
-          decoder_params[:arguments] = ['command1', '-h']
+    describe 'Commands' do
+      describe 'regular case' do
+        let(:decoder_params) {{
+          'command1' => [
+            'arg1',
+            long_help: 'This is the long help.'
+          ],
+          'command2' => [
+            'arg2'
+          ],
+          output:     output_buffer,
+        }}
 
-          described_class.decode(decoder_params)
+        it 'should be decoded' do
+          decoder_params[:arguments] = ['command1', 'value1']
 
-          expected_output = <<~OUTPUT
-            Usage: rspec command1 [options] <arg1>
-                -h, --help                       Help
+          actual_result = described_class.decode(decoder_params)
 
-            This is the long help.
-          OUTPUT
+          expected_result = ['command1', arg1: 'value1']
 
-          expect(output_buffer.string).to eql(expected_output)
+          expect(actual_result).to eql(expected_result)
         end
 
-        context 'auto_help: false' do
-
-          it 'should not interpret the --help argument, and not print the help' do
+        context "error handling" do
+          it "should raise an error on invalid command" do
             decoder_params.merge!(
-              arguments: ['-h'],
-              auto_help: false,
+              arguments: ['pizza'],
+              raise_errors: true,
             )
 
-            actual_result = described_class.decode(decoder_params)
-
-            expected_result = {
-              help: true,
-            }
-
-            expect(actual_result).to eql(expected_result)
+            expect {
+              described_class.decode(decoder_params)
+            }.to raise_error(an_instance_of(Argv::InvalidCommand).and having_attributes(
+              message: "Invalid command: pizza",
+              valid_commands: ["command1", "command2"],
+            ))
           end
 
-          it 'should ignore and not return all the other arguments' do
+          it "should raise a specific error message on missing command" do
             decoder_params.merge!(
-              arguments: ['-h', 'pizza'],
-              auto_help: false,
+              arguments: [],
+              raise_errors: true,
             )
 
-            actual_result = described_class.decode(decoder_params)
-
-            expected_result = {
-              help: true,
-            }
-
-            expect(actual_result).to eql(expected_result)
+            expect {
+              described_class.decode(decoder_params)
+            }.to raise_error(an_instance_of(Argv::InvalidCommand).and having_attributes(
+              message: "Missing command!",
+              valid_commands: ["command1", "command2"],
+            ))
           end
+        end # context "error handling"
 
-        end # context 'auto_help: false'
+        context "help" do
+          it 'should implement the commands help' do
+            decoder_params[:arguments] = ['-h']
 
-      end # context 'help'
+            described_class.decode(decoder_params)
 
-    end # describe 'regular case'
+            expected_output = <<~OUTPUT
+              Valid commands:
 
-    describe 'Nested commands' do
+                command1, command2
+            OUTPUT
 
-      let(:decoder_params) {{
-        'command1' => {
-          'nested1a' => [
-            'arg1',
-            long_help: 'nested1a long help.'
-          ],
-          'nested1b' => [
-            'arg1b'
-          ],
-        },
-        'command2' => [
-          'arg2'
-        ],
-        output:     output_buffer
-      }}
+            expect(output_buffer.string).to eql(expected_output)
+          end
 
-      it 'should be decoded (two levels)' do
-        decoder_params[:arguments] = ['command1', 'nested1a', 'value1']
+          it "should display the command given command's help" do
+            decoder_params[:arguments] = ['command1', '-h']
 
-        actual_result = described_class.decode(decoder_params)
+            described_class.decode(decoder_params)
 
-        expected_result = ['command1.nested1a', arg1: 'value1']
+            expected_output = <<~OUTPUT
+              Usage: rspec command1 [options] <arg1>
+                  -h, --help                       Help
 
-        expect(actual_result).to eql(expected_result)
-      end
+              This is the long help.
+            OUTPUT
 
-      it 'should be decoded (one level)' do
-        decoder_params[:arguments] = ['command2', 'value2']
+            expect(output_buffer.string).to eql(expected_output)
+          end
 
-        actual_result = described_class.decode(decoder_params)
+          context 'auto_help: false' do
+            it 'should not interpret the --help argument, and not print the help' do
+              decoder_params.merge!(
+                arguments: ['-h'],
+                auto_help: false,
+              )
+
+              actual_result = described_class.decode(decoder_params)
+
+              expected_result = {
+                help: true,
+              }
+
+              expect(actual_result).to eql(expected_result)
+            end
+
+            it 'should ignore and not return all the other arguments' do
+              decoder_params.merge!(
+                arguments: ['-h', 'pizza'],
+                auto_help: false,
+              )
+
+              actual_result = described_class.decode(decoder_params)
+
+              expected_result = {
+                help: true,
+              }
+
+              expect(actual_result).to eql(expected_result)
+            end
+          end # context 'auto_help: false'
+        end # context 'help'
+      end # describe 'regular case'
+
+      describe 'Nested commands' do
+        let(:decoder_params) {{
+          'command1' => {
+            'nested1a' => [
+              'arg1',
+              long_help: 'nested1a long help.'
+            ],
+            'nested1b' => [
+              'arg1b'
+            ],
+          },
+          'command2' => [
+            'arg2'
+          ],
+          output:     output_buffer
+        }}
 
-        expected_result = ['command2', arg2: 'value2']
+        it 'should be decoded (two levels)' do
+          decoder_params[:arguments] = ['command1', 'nested1a', 'value1']
 
-        expect(actual_result).to eql(expected_result)
-      end
+          actual_result = described_class.decode(decoder_params)
 
-      it 'should print the command1 help' do
-        decoder_params[:arguments] = ['command1', '-h']
+          expected_result = ['command1.nested1a', arg1: 'value1']
 
-        actual_result = described_class.decode(decoder_params)
+          expect(actual_result).to eql(expected_result)
+        end
 
-        expected_output = <<~OUTPUT
-          Valid commands:
+        it 'should be decoded (one level)' do
+          decoder_params[:arguments] = ['command2', 'value2']
 
-            nested1a, nested1b
-        OUTPUT
+          actual_result = described_class.decode(decoder_params)
 
-        expect(output_buffer.string).to eql(expected_output)
-      end
+          expected_result = ['command2', arg2: 'value2']
 
-      it 'should print the nested1a help, and long help' do
-        decoder_params[:arguments] = ['command1', 'nested1a', '-h']
+          expect(actual_result).to eql(expected_result)
+        end
 
-        actual_result = described_class.decode(decoder_params)
+        it 'should print the command1 help' do
+          decoder_params[:arguments] = ['command1', '-h']
+
+          actual_result = described_class.decode(decoder_params)
 
-        expected_output = <<~OUTPUT
-          Usage: rspec command1 nested1a [options] <arg1>
-              -h, --help                       Help
+          expected_output = <<~OUTPUT
+            Valid commands:
 
-          nested1a long help.
-        OUTPUT
+              nested1a, nested1b
+          OUTPUT
 
-        expect(output_buffer.string).to eql(expected_output)
-      end
-    end # describe 'Nested commands'
+          expect(output_buffer.string).to eql(expected_output)
+        end
 
-  end # describe 'Commands'
+        it 'should print the nested1a help, and long help' do
+          decoder_params[:arguments] = ['command1', 'nested1a', '-h']
 
-  # Special case.
-  #
-  describe 'No definitions given' do
+          actual_result = described_class.decode(decoder_params)
 
-    let(:decoder_params) {{
-      output:     output_buffer,
-    }}
+          expected_output = <<~OUTPUT
+            Usage: rspec command1 nested1a [options] <arg1>
+                -h, --help                       Help
 
-    it 'should avoid options being interpreted as definitions' do
-      decoder_params[:arguments] = ['pizza']
-      decoder_params[:raise_errors] = true
+            nested1a long help.
+          OUTPUT
 
-      decoding = -> { described_class.decode(decoder_params) }
+          expect(output_buffer.string).to eql(expected_output)
+        end
+      end # describe 'Nested commands'
+    end # describe 'Commands'
 
-      expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Too many arguments")
-    end
+    # Special case.
+    #
+    describe 'No definitions given' do
+      let(:decoder_params) {{
+        output:     output_buffer,
+      }}
 
-  end # describe 'No definitions given'
+      it 'should avoid options being interpreted as definitions' do
+        decoder_params[:arguments] = ['pizza']
+        decoder_params[:raise_errors] = true
 
-end
+        expect {
+          described_class.decode(decoder_params)
+        }.to raise_error(Argv::ArgumentError, "Too many arguments")
+      end
+    end # describe 'No definitions given'
+  end # describe Argv
+end # module SimpleScripting

data/spec/simple_scripting/configuration_spec.rb

@@ -4,7 +4,6 @@ require 'tempfile'
 require 'tmpdir'
 
 module SimpleScripting::ConfigurationSpecHelper
-
   def with_tempfile(config_content)
     tempfile = Tempfile.new('ss_config_test')
     tempfile.write(config_content)
@@ -14,11 +13,9 @@ module SimpleScripting::ConfigurationSpecHelper
   ensure
     tempfile.unlink
   end
-
 end
 
 describe SimpleScripting::Configuration do
-
   include SimpleScripting::ConfigurationSpecHelper
 
   let(:configuration_text) {"
@@ -56,9 +53,9 @@ g2_key=bang
 
   it "should raise an error when required keys are missing" do
     with_tempfile(configuration_text) do |config_file|
-      error_call = -> { described_class.load(config_file: config_file, required: %w(abspath_key missing_key group1)) }
-
-      expect(error_call).to raise_error(RuntimeError, "Missing required configuration key(s): missing_key, group1")
+      expect {
+        described_class.load(config_file: config_file, required: %w(abspath_key missing_key group1))
+      }.to raise_error(RuntimeError, "Missing required configuration key(s): missing_key, group1")
     end
   end
 
@@ -73,5 +70,4 @@ g2_key=bang
       File.delete(temp_config_file)
     end
   end
-
-end
+end # describe SimpleScripting::Configuration

data/spec/simple_scripting/tab_completion_spec.rb

@@ -3,7 +3,6 @@
 require_relative '../../lib/simple_scripting/tab_completion.rb'
 
 describe SimpleScripting::TabCompletion do
-
   include TabCompletionCustomRSpecMatchers
 
   let(:output_buffer) {
@@ -45,9 +44,7 @@ describe SimpleScripting::TabCompletion do
   subject { described_class.new(switches_definition, output: output_buffer) }
 
   context "with a correct configuration" do
-
     context "standard cases" do
-
       # Note that the conversion of mandatory to optional argument is defined by most of the cases.
       #
       STANDARD_CASES = {
@@ -79,11 +76,9 @@ describe SimpleScripting::TabCompletion do
           expect(symbolic_commandline_options).to complete_with(expected_entries)
         end
       end
-
     end # context "standard cases"
 
     context "suffix management" do
-
       SUFFIX_CASES = {
         "arg1<tab>v"        => %w(arg1v1 arg1v2), # the execution target of the test suite doesn't
         "arg1<tab>x"        => %w(),              # ignore the suffix; programmer-defined
@@ -97,11 +92,9 @@ describe SimpleScripting::TabCompletion do
           expect(symbolic_commandline_options).to complete_with(expected_entries)
         end
       end
-
     end # context "suffix management"
 
     context "escaped cases" do
-
       ESCAPED_CASES = {
         "\ <tab>"           => [" _argv1spc"],
         '\-<tab>'           => %w(),                       # this is the result of typing `command "\-<tab>`
@@ -111,7 +104,6 @@ describe SimpleScripting::TabCompletion do
       ESCAPED_CASES.each do |symbolic_commandline_options, _|
         it "should output the entries for #{symbolic_commandline_options.inspect}"
       end
-
     end # context "escaped cases"
 
     it "should support multiple values for an option"
@@ -119,11 +111,9 @@ describe SimpleScripting::TabCompletion do
     it "should keep parsing also when --help is passed" do
       expect("--help a<tab>").to complete_with(%w(arg1v1 arg1v2))
     end
-
   end # context "with a correct configuration"
 
   context "with an incorrect configuration" do
-
     INCORRECT_CASES = [
       "a b <tab>",        # too many args
       "-O<tab>",          # no values for this option
@@ -134,7 +124,5 @@ describe SimpleScripting::TabCompletion do
         expect(symbolic_commandline_options).to not_complete
       end
     end
-
   end # context "with an incorrect configuration"
-
 end # describe SimpleScripting::TabCompletion

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_scripting
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Saverio Miroddi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-31 00:00:00.000000000 Z
+date: 2022-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parseconfig
@@ -99,8 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Library for simplifying some typical scripting functionalities.