simple_scripting 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dec0612c673d96b8e5f8299faff45642f8da72a615b2bb424f1b509361da3b3
-  data.tar.gz: a8111721013e564624ee4fdd72e063c7eb9ee33d0a6154781509131afa3c77c5
+  metadata.gz: 58e50fed7e20d97c590ebbab5466313a9a98393c7fbec6124131bcbf166af043
+  data.tar.gz: 7b16435d1eb0544743043b58f437a3d63407bac2ceb1595defa4ee557b6a7523
 SHA512:
-  metadata.gz: 78c6995cdce8e0f495c0ae1028972a507ba4b88c5102d9da421f0afbcb1e113e03757474227e775a4b8676b00eccd8b3e3b56ab91fefa3a858dd65e7127b504a
-  data.tar.gz: a05c83cdce85612d6b488604eec6bbb182f3d06dd9a2bb2bd90a8fcce0dade13482cf442cf2eca548d708e7e8c28ecd48dfd26cc4eaaaa1947e67ce914a934c9
+  metadata.gz: '088ce9b31b82294a6b0ac5a238edfabaff919c71358e82deae14ef31f620c33f2f44af4de4f6a8e1996c7b1f3d9574d2ac5b88a85ff65745e3b5752b02146b07'
+  data.tar.gz: a94f016103580b122129bd85070030d21b74b2b6b348e129259f674cffec2cbb847a86fcde5d0a4cac267ce4c7d7bc2fdae1e5ff6b0259d1f3a351dbe4df96cd

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
 

data/lib/simple_scripting/version.rb

@@ -1,5 +1,5 @@
 module SimpleScripting
 
-  VERSION = "0.12.0"
+  VERSION = "0.12.1"
 
 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-08-18"
+  s.date        = "2020-02-13"
   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,228 +2,143 @@ 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 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,
-    ]}
-
-    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 VAL1,VAL2
-              -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
+module SimpleScripting
 
-      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
-        )
+  describe Argv do
 
-        actual_result = described_class.decode(*decoder_params)
+    let(:output_buffer) do
+      StringIO.new
+    end
 
-        expected_result = {
-          help: true,
-          mandatory: 'm_arg',
-        }
+    describe 'Basic functionality' do
 
-        expect(output_buffer.string).to eql('')
-        expect(actual_result).to eql(expected_result)
-      end
+      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,
+      ]}
 
-      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,
-        )
+      context 'help' do
 
-        decoding = -> { described_class.decode(*decoder_params) }
+        it 'should print help automatically by default' do
+          decoder_params.last[:arguments] = ['-h']
 
-        expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Missing mandatory argument(s)")
-      end
+          return_value = described_class.decode(*decoder_params)
 
-    end # context 'help'
+          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
 
-    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']
+            This is the long help!
+          OUTPUT
 
-      actual_result = described_class.decode(*decoder_params)
+          expect(output_buffer.string).to eql(expected_output)
+          expect(return_value).to be(nil)
+        end
 
-      expected_result = {
-        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',
-      }
+        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
+          )
 
-      expect(actual_result).to eql(expected_result)
-    end
+          actual_result = described_class.decode(*decoder_params)
 
-    it "should implement basic switches and arguments (no optional argument)" do
-      decoder_params.last[:arguments] = ['m_arg']
+          expected_result = {
+            help: true,
+            mandatory: 'm_arg',
+          }
 
-      actual_result = described_class.decode(*decoder_params)
+          expect(output_buffer.string).to eql('')
+          expect(actual_result).to eql(expected_result)
+        end
 
-      expected_result = {
-        mandatory: 'm_arg',
-      }
+        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,
+          )
 
-      expect(actual_result).to eql(expected_result)
-    end
+          decoding = -> { described_class.decode(*decoder_params) }
 
-    context "multiple optional arguments" do
+          expect(decoding).to raise_error(Argv::ArgumentError, "Missing mandatory argument(s)")
+        end
 
-      let(:decoder_params) {[
-        '[optional1]',
-        '[optional2]',
-        output:     output_buffer,
-      ]}
+      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,
-        )
-
-        decoding = -> { described_class.decode(*decoder_params) }
-
-        expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Missing mandatory argument(s)")
-      end
-
-      it "should raise an error when there are too many arguments" do
-        decoder_params.last.merge!(
-          arguments: ['arg1', 'arg2', 'excessive_arg'],
-          raise_errors: true,
-        )
-
-        decoding = -> { described_class.decode(*decoder_params) }
-
-        expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Too many arguments")
-      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
-
-        let(:decoder_params) {[
-          'mandatory',
-          '*varargs',
-          output:     output_buffer,
-          arguments:  ['mandval', 'varval1', 'varval2']
-        ]}
+        it "should correctly decode all arguments passed" do
+          decoder_params.last[:arguments] = ['o_arg1', 'o_arg2']
 
-        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)
@@ -233,266 +148,361 @@ describe SimpleScripting::Argv do
 
       context "error handling" do
 
-        let(:decoder_params) {[
-          '*varargs',
-          output:     output_buffer,
-          arguments:  [],
-        ]}
+        # 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)
 
-        it "should raise an error when they are not specified" do
-          decoder_params.last[:raise_errors] = true
+          # 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,
+          )
 
           decoding = -> { described_class.decode(*decoder_params) }
 
-          expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Missing mandatory argument(s)")
+          expect(decoding).to raise_error(Argv::ArgumentError, "Missing mandatory argument(s)")
+        end
+
+        it "should raise an error when there are too many arguments" do
+          decoder_params.last.merge!(
+            arguments: ['arg1', 'arg2', 'excessive_arg'],
+            raise_errors: true,
+          )
+
+          decoding = -> { described_class.decode(*decoder_params) }
+
+          expect(decoding).to raise_error(Argv::ArgumentError, "Too many arguments")
         end
 
       end # context "error handling"
 
-    end # describe '(mandatory)'
+    end # describe 'Basic functionality'
 
-    describe '(optional)' do
+    describe 'Varargs' do
 
-      let(:decoder_params) {[
-        '[*varargs]',
-        output:     output_buffer,
-      ]}
+      describe '(mandatory)' do
 
-      it "should be decoded" do
-        decoder_params.last[:arguments] = ['varval1', 'varval2']
+        context 'as only parameter' do
 
-        actual_result = described_class.decode(*decoder_params)
+          let(:decoder_params) {[
+            '*varargs',
+            output:     output_buffer,
+            arguments:  ['varval1', 'varval2'],
+          ]}
 
-        expected_result = {
-          varargs:   ['varval1', 'varval2'],
-        }
+          it "should be decoded" do
+            actual_result = described_class.decode(*decoder_params)
 
-        expect(actual_result).to eql(expected_result)
-      end
+            expected_result = {
+              varargs:   ['varval1', 'varval2'],
+            }
 
-      it "should be allowed not to be specified" do
-        decoder_params.last[:arguments] = []
+            expect(actual_result).to eql(expected_result)
+          end
 
-        actual_result = described_class.decode(*decoder_params)
+        end
 
-        expected_result = {
-          varargs:   [],
-        }
+        context 'followed by varargs' do
 
-        expect(actual_result).to eql(expected_result)
-      end
+          let(:decoder_params) {[
+            'mandatory',
+            '*varargs',
+            output:     output_buffer,
+            arguments:  ['mandval', 'varval1', 'varval2']
+          ]}
 
-    end # describe '(optional)'
+          it "should be decoded" do
+            actual_result = described_class.decode(*decoder_params)
 
-  end # describe 'Varargs'
+            expected_result = {
+              mandatory: 'mandval',
+              varargs:   ['varval1', 'varval2'],
+            }
 
-  describe 'Commands' do
+            expect(actual_result).to eql(expected_result)
+          end
 
-    describe 'regular case' do
+        end
 
-      let(:decoder_params) {{
-        'command1' => [
-          'arg1',
-          long_help: 'This is the long help.'
-        ],
-        'command2' => [
-          'arg2'
-        ],
-        output:     output_buffer,
-      }}
+        context "error handling" do
 
-      it 'should be decoded' do
-        decoder_params[:arguments] = ['command1', 'value1']
+          let(:decoder_params) {[
+            '*varargs',
+            output:     output_buffer,
+            arguments:  [],
+          ]}
 
-        actual_result = described_class.decode(decoder_params)
+          it "should raise an error when they are not specified" do
+            decoder_params.last[:raise_errors] = true
 
-        expected_result = ['command1', arg1: 'value1']
+            decoding = -> { described_class.decode(*decoder_params) }
 
-        expect(actual_result).to eql(expected_result)
-      end
+            expect(decoding).to raise_error(Argv::ArgumentError, "Missing mandatory argument(s)")
+          end
 
-      context "error handling" do
+        end # context "error handling"
 
-        it "should raise an error on invalid command" do
-          decoder_params.merge!(
-            arguments: ['pizza'],
-            raise_errors: true,
-          )
+      end # describe '(mandatory)'
 
-          decoding = -> { described_class.decode(decoder_params) }
+      describe '(optional)' do
 
-          expect(decoding).to raise_error(SimpleScripting::Argv::InvalidCommand, "Invalid command: pizza")
-        end
+        let(:decoder_params) {[
+          '[*varargs]',
+          output:     output_buffer,
+        ]}
 
-        it "should raise a specific error message on missing command" do
-          decoder_params.merge!(
-            arguments: [],
-            raise_errors: true,
-          )
+        it "should be decoded" do
+          decoder_params.last[:arguments] = ['varval1', 'varval2']
 
-          decoding = -> { described_class.decode(decoder_params) }
+          actual_result = described_class.decode(*decoder_params)
 
-          expect(decoding).to raise_error(SimpleScripting::Argv::InvalidCommand, "Missing command")
+          expected_result = {
+            varargs:   ['varval1', 'varval2'],
+          }
+
+          expect(actual_result).to eql(expected_result)
         end
 
-      end # context "error handling"
+        it "should be allowed not to be specified" do
+          decoder_params.last[:arguments] = []
 
-      context "help" do
+          actual_result = described_class.decode(*decoder_params)
 
-        it 'should implement the commands help' do
-          decoder_params[:arguments] = ['-h']
+          expected_result = {
+            varargs:   [],
+          }
 
-          described_class.decode(decoder_params)
+          expect(actual_result).to eql(expected_result)
+        end
 
-          expected_output = <<~OUTPUT
-            Valid commands:
+      end # describe '(optional)'
 
-              command1, command2
-          OUTPUT
+    end # describe 'Varargs'
 
-          expect(output_buffer.string).to eql(expected_output)
-        end
+    describe 'Commands' do
 
-        it "should display the command given command's help" do
-          decoder_params[:arguments] = ['command1', '-h']
+      describe 'regular case' do
 
-          described_class.decode(decoder_params)
+        let(:decoder_params) {{
+          'command1' => [
+            'arg1',
+            long_help: 'This is the long help.'
+          ],
+          'command2' => [
+            'arg2'
+          ],
+          output:     output_buffer,
+        }}
 
-          expected_output = <<~OUTPUT
-            Usage: rspec command1 [options] <arg1>
-                -h, --help                       Help
+        it 'should be decoded' do
+          decoder_params[:arguments] = ['command1', 'value1']
 
-            This is the long help.
-          OUTPUT
+          actual_result = described_class.decode(decoder_params)
 
-          expect(output_buffer.string).to eql(expected_output)
+          expected_result = ['command1', arg1: 'value1']
+
+          expect(actual_result).to eql(expected_result)
         end
 
-        context 'auto_help: false' do
+        context "error handling" do
 
-          it 'should not interpret the --help argument, and not print the help' 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)
+            decoding = -> { described_class.decode(decoder_params) }
 
-            expected_result = {
-              help: true,
-            }
-
-            expect(actual_result).to eql(expected_result)
+            expect(decoding).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)
+            decoding = -> { described_class.decode(decoder_params) }
 
-            expected_result = {
-              help: true,
-            }
+            expect(decoding).to raise_error(an_instance_of(Argv::InvalidCommand).and having_attributes(
+              message: "Missing command!",
+              valid_commands: ["command1", "command2"],
+            ))
+          end
 
-            expect(actual_result).to eql(expected_result)
+        end # context "error handling"
+
+        context "help" do
+
+          it 'should implement the commands help' do
+            decoder_params[:arguments] = ['-h']
+
+            described_class.decode(decoder_params)
+
+            expected_output = <<~OUTPUT
+              Valid commands:
+
+                command1, command2
+            OUTPUT
+
+            expect(output_buffer.string).to eql(expected_output)
           end
 
-        end # context 'auto_help: false'
+          it "should display the command given command's help" do
+            decoder_params[:arguments] = ['command1', '-h']
 
-      end # context 'help'
+            described_class.decode(decoder_params)
 
-    end # describe 'regular case'
+            expected_output = <<~OUTPUT
+              Usage: rspec command1 [options] <arg1>
+                  -h, --help                       Help
 
-    describe 'Nested commands' do
+              This is the long help.
+            OUTPUT
 
-      let(:decoder_params) {{
-        'command1' => {
-          'nested1a' => [
-            'arg1',
-            long_help: 'nested1a long help.'
-          ],
-          'nested1b' => [
-            'arg1b'
+            expect(output_buffer.string).to eql(expected_output)
+          end
+
+          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'
           ],
-        },
-        'command2' => [
-          'arg2'
-        ],
-        output:     output_buffer
-      }}
+          output:     output_buffer
+        }}
 
-      it 'should be decoded (two levels)' do
-        decoder_params[:arguments] = ['command1', 'nested1a', 'value1']
+        it 'should be decoded (two levels)' do
+          decoder_params[:arguments] = ['command1', 'nested1a', 'value1']
 
-        actual_result = described_class.decode(decoder_params)
+          actual_result = described_class.decode(decoder_params)
 
-        expected_result = ['command1.nested1a', arg1: 'value1']
+          expected_result = ['command1.nested1a', arg1: 'value1']
 
-        expect(actual_result).to eql(expected_result)
-      end
+          expect(actual_result).to eql(expected_result)
+        end
 
-      it 'should be decoded (one level)' do
-        decoder_params[:arguments] = ['command2', 'value2']
+        it 'should be decoded (one level)' do
+          decoder_params[:arguments] = ['command2', 'value2']
 
-        actual_result = described_class.decode(decoder_params)
+          actual_result = described_class.decode(decoder_params)
 
-        expected_result = ['command2', arg2: 'value2']
+          expected_result = ['command2', arg2: 'value2']
 
-        expect(actual_result).to eql(expected_result)
-      end
+          expect(actual_result).to eql(expected_result)
+        end
 
-      it 'should print the command1 help' do
-        decoder_params[:arguments] = ['command1', '-h']
+        it 'should print the command1 help' do
+          decoder_params[:arguments] = ['command1', '-h']
 
-        actual_result = described_class.decode(decoder_params)
+          actual_result = described_class.decode(decoder_params)
 
-        expected_output = <<~OUTPUT
-          Valid commands:
+          expected_output = <<~OUTPUT
+            Valid commands:
 
-            nested1a, nested1b
-        OUTPUT
+              nested1a, nested1b
+          OUTPUT
 
-        expect(output_buffer.string).to eql(expected_output)
-      end
+          expect(output_buffer.string).to eql(expected_output)
+        end
 
-      it 'should print the nested1a help, and long help' do
-        decoder_params[:arguments] = ['command1', 'nested1a', '-h']
+        it 'should print the nested1a help, and long help' do
+          decoder_params[:arguments] = ['command1', 'nested1a', '-h']
 
-        actual_result = described_class.decode(decoder_params)
+          actual_result = described_class.decode(decoder_params)
 
-        expected_output = <<~OUTPUT
-          Usage: rspec command1 nested1a [options] <arg1>
-              -h, --help                       Help
+          expected_output = <<~OUTPUT
+            Usage: rspec command1 nested1a [options] <arg1>
+                -h, --help                       Help
 
-          nested1a long help.
-        OUTPUT
+            nested1a long help.
+          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 'Nested commands'
 
-  end # describe 'Commands'
+    end # describe 'Commands'
 
-  # Special case.
-  #
-  describe 'No definitions given' do
+    # Special case.
+    #
+    describe 'No definitions given' do
 
-    let(:decoder_params) {{
-      output:     output_buffer,
-    }}
+      let(:decoder_params) {{
+        output:     output_buffer,
+      }}
 
-    it 'should avoid options being interpreted as definitions' do
-      decoder_params[:arguments] = ['pizza']
-      decoder_params[:raise_errors] = true
+      it 'should avoid options being interpreted as definitions' do
+        decoder_params[:arguments] = ['pizza']
+        decoder_params[:raise_errors] = true
 
-      decoding = -> { described_class.decode(decoder_params) }
+        decoding = -> { described_class.decode(decoder_params) }
 
-      expect(decoding).to raise_error(SimpleScripting::Argv::ArgumentError, "Too many arguments")
-    end
+        expect(decoding).to raise_error(Argv::ArgumentError, "Too many arguments")
+      end
+
+    end # describe 'No definitions given'
 
-  end # describe 'No definitions given'
+  end # describe Argv
 
-end
+end # module SimpleScripting

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_scripting
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Saverio Miroddi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-18 00:00:00.000000000 Z
+date: 2020-02-13 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.0.6
 signing_key: 
 specification_version: 4
 summary: Library for simplifying some typical scripting functionalities.