simple_scripting 0.14.1 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccda16c3d0d547b879118105a4a8e6612dcdeab5a2b4304f5a173ae853640d19
-  data.tar.gz: f0a608185cf3896b7e7a70028396d35573532ac9b72af592b0f459482fcb7f0b
+  metadata.gz: 19d1802651a6d6c7ba48675475a2031da57ccde2ca508977f35c4865897734b1
+  data.tar.gz: 81108ceef64d225fd28c2752992aba5f46053ece551e3179364426cd708c9788
 SHA512:
-  metadata.gz: f8e954db6fcf8db093451e1b92873e4a5d16ed5c84fc802e2dc006b2d35d10c88a3b74744905210fe389036898bc8b171f2e323ea249db14c80da2612e51e97a
-  data.tar.gz: 7db2ee472ef700028e861774b8c85dffc050752adab3d63b71a0596cff43fbef00c53f25ab0b148e4be7c2a29fe6fa0cf867c8a4a90257a9d99942e2ee171a2d
+  metadata.gz: 64373b69f2c72da9d253d8ad0bfa4660ca8e39de83ba3d3c7140454c71e76a82a80b33f1e5a1e885216c6ac8d573b3e0c373de1316db459e44b0a43f532f9c83
+  data.tar.gz: 6dd6a9ef7ceec62cf139f006f66a364ae881325bdfa5e2af61baad56377ce02ad8536eb440a9fc445cc110c977c7d1856655067f75707d946f61a15d901dcff5

data/.github/workflows/ci.yml

@@ -4,21 +4,28 @@ on: [pull_request]
 
 jobs:
   test:
+    name: Test Suite
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [head, 3.2, 3.1, 3.0, 2.7]
+        ruby-version: [head, 4.0, 3.4, 3.3, 3.2]
       fail-fast: false
-    continue-on-error: ${{ endsWith(matrix.ruby, 'head') || matrix.ruby == 'debug' }}
+    continue-on-error: ${{ endsWith(matrix['ruby-version'], 'head') }}
     steps:
-    - uses: actions/checkout@v3
-    - run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
+    - uses: actions/checkout@v7
     - name: Set up Ruby ${{ matrix.ruby-version }}
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true
-    - name: Install dependencies
-      run: bundle install
-    - name: Run tests
-      run: bundle exec rspec
+    - run: bundle exec rspec
+  # Summary job for branch-protection rules; head failures are ignored via continue-on-error above.
+  all-tests:
+    name: All (non-head) tests passed
+    runs-on: ubuntu-latest
+    needs: [test]
+    if: always()
+    steps:
+      - name: Check test suite result
+        run: |
+          [[ "${{ needs.test.result }}" == "success" ]] || exit 1

data/.simplecov

@@ -1,6 +1,5 @@
-require 'simplecov'
-require 'coveralls'
+SimpleCov.start do
+  add_filter '/spec/'
 
-SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-
-SimpleCov.add_filter '/spec/'
+  enable_coverage :branch
+end

data/Gemfile

@@ -3,10 +3,10 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'coveralls', '~> 0.8.23', require: false
+  gem 'simplecov', '~> 0.22', require: false
 end
 
 group :tools do
-  gem 'byebug', '~> 10.0.2'
+  gem 'byebug'
   gem 'rubocop', '= 0.58.1'
 end

data/README.md

@@ -1,7 +1,5 @@
 [![Gem Version][GV img]](https://rubygems.org/gems/simple_scripting)
-[![Build Status][BS img]](https://travis-ci.org/saveriomiroddi/simple_scripting)
-[![Code Climate][CC img]](https://codeclimate.com/github/saveriomiroddi/simple_scripting)
-[![Coverage Status][CS img]](https://coveralls.io/r/saveriomiroddi/simple_scripting)
+[![CI][CI img]](https://github.com/64kramsystem/simple_scripting/actions/workflows/ci.yml)
 
 # SimpleScripting
 
@@ -90,7 +88,7 @@ Note that a **recent version of Zsh is required**; the stock Ubuntu 16.04 versio
 
 ### More complex use cases
 
-For a description of the more complex use cases, including edge cases and error handling, see the [wiki](https://github.com/saveriomiroddi/simple_scripting/wiki/SimpleScripting::TabCompletion-Guide).
+For a description of the more complex use cases, including edge cases and error handling, see the [wiki](https://github.com/64kramsystem/simple_scripting/wiki/SimpleScripting::TabCompletion-Guide).
 
 ## SimpleScripting::Argv
 
@@ -151,7 +149,7 @@ Commands are also supported (with unlimited depth), by using a hash:
       }
     ) || exit
 
-For the guide, see the [wiki page](https://github.com/saveriomiroddi/simple_scripting/wiki/SimpleScripting::Argv-Guide).
+For the guide, see the [wiki page](https://github.com/64kramsystem/simple_scripting/wiki/SimpleScripting::Argv-Guide).
 
 ## SimpleScripting::Configuration
 
@@ -184,15 +182,17 @@ This is the workflow and functionality offered by `Configuration`:
 
     configuration.a_group.group_key                 # 'baz'; also supports #full_path and #decrypted
 
+### Local configuration
+
+If a file with the same name plus the `.local` suffix exists (e.g. `$HOME/.foo_my_bar.local`), its keys are merged over the main configuration's (per-group). This is useful for keeping the main file shared across machines, with machine-specific overrides in the local one.
+
 ### Encryption note
 
 The purpose of encryption in this library is just to avoid displaying passwords in plaintext; it's not considered safe against attacks.
 
 ## Help
 
-See the [wiki](https://github.com/saveriomiroddi/simple_scripting/wiki) for additional help.
+See the [wiki](https://github.com/64kramsystem/simple_scripting/wiki) for additional help.
 
 [GV img]: https://badge.fury.io/rb/simple_scripting.png
-[BS img]: https://travis-ci.org/saveriomiroddi/simple_scripting.svg?branch=master
-[CC img]: https://codeclimate.com/github/saveriomiroddi/simple_scripting.png
-[CS img]: https://coveralls.io/repos/saveriomiroddi/simple_scripting/badge.png?branch=master
+[CI img]: https://github.com/64kramsystem/simple_scripting/actions/workflows/ci.yml/badge.svg

data/lib/simple_scripting/argv.rb

@@ -21,14 +21,13 @@ module SimpleScripting
     end
 
     class ExitWithCommandsHelpPrinting < Struct.new(:commands_definition)
-      # Note that :long_help is not used.
-      def print_help(output, long_help)
+      def print_help(output)
         output.puts "Valid commands:", "", "  " + commands_definition.keys.join(', ')
       end
     end
 
-    class ExitWithArgumentsHelpPrinting < Struct.new(:commands_stack, :args, :parser_opts_copy)
-      def print_help(output, long_help)
+    class ExitWithArgumentsHelpPrinting < Struct.new(:commands_stack, :args, :parser_opts_copy, :long_help)
+      def print_help(output)
         parser_opts_help = parser_opts_copy.to_s
 
         if commands_stack.size > 0
@@ -56,19 +55,15 @@ module SimpleScripting
       output    = options.fetch(:output, $stdout)
       raise_errors = options.fetch(:raise_errors, false)
 
-      # WATCH OUT! @long_help can also be set in :decode_command!. See issue #17.
-      #
-      @long_help = long_help
-
       exit_data = catch(:exit) do
         if params_definition.first.is_a?(Hash)
-          return decode_command!(params_definition, arguments, auto_help)
+          return decode_command!(params_definition, arguments, auto_help, long_help)
         else
-          return decode_arguments!(params_definition, arguments, auto_help)
+          return decode_arguments!(params_definition, arguments, auto_help, long_help)
         end
       end
 
-      exit_data.print_help(output, @long_help)
+      exit_data.print_help(output)
 
       nil # to be used with the 'decode(...) || exit' pattern
     rescue SimpleScripting::Argv::ArgumentError, OptionParser::InvalidOption => error
@@ -79,12 +74,10 @@ module SimpleScripting
       raise if raise_errors
 
       output.puts <<~MESSAGE
-        Command error!: #{error.message}"
+        Command error!: #{error.message}
 
         Valid commands: #{error.valid_commands.join(", ")}
       MESSAGE
-    ensure
-      @long_help = nil
     end
 
     private
@@ -120,7 +113,7 @@ module SimpleScripting
     #
     #   [{"command1"=>["arg1", {:long_help=>"This is the long help."}], "command2"=>["arg2"]}]
     #
-    def decode_command!(params_definition, arguments, auto_help, commands_stack=[])
+    def decode_command!(params_definition, arguments, auto_help, long_help, commands_stack=[])
       commands_definition = params_definition.first
 
       # Set the `command` variable only after; in the case where we print the help, this variable
@@ -157,23 +150,23 @@ module SimpleScripting
 
         # Nested case! Decode recursively
         #
-        decode_command!([command_params_definition], arguments, auto_help, commands_stack)
+        decode_command!([command_params_definition], arguments, auto_help, long_help, commands_stack)
       else
         commands_stack << command
 
         if command_params_definition.last.is_a?(Hash)
           internal_params = command_params_definition.pop # only long_help is here, if present
-          @long_help = internal_params.delete(:long_help)
+          long_help = internal_params.delete(:long_help)
         end
 
         [
           compose_returned_commands(commands_stack),
-          decode_arguments!(command_params_definition, arguments, auto_help, commands_stack),
+          decode_arguments!(command_params_definition, arguments, auto_help, long_help, commands_stack),
         ]
       end
     end
 
-    def decode_arguments!(params_definition, arg_values, auto_help, commands_stack=[])
+    def decode_arguments!(params_definition, arg_values, auto_help, long_help, commands_stack=[])
       result           = {}
       parser_opts_copy = nil  # not available outside the block
       arg_definitions  = {}   # { 'name' => mandatory? }
@@ -197,7 +190,7 @@ module SimpleScripting
         #
         parser_opts.on('-h', '--help', 'Help') do
           if auto_help
-            throw :exit, ExitWithArgumentsHelpPrinting.new(commands_stack, arg_definitions, parser_opts_copy)
+            throw :exit, ExitWithArgumentsHelpPrinting.new(commands_stack, arg_definitions, parser_opts_copy, long_help)
           else
             # Needs to be better handled. When help is required, generally, it trumps the
             # correctness of the rest of the options/arguments.
@@ -212,9 +205,9 @@ module SimpleScripting
       arg_definitions.each do |arg_name, arg_is_mandatory|
         if arg_name.to_s.start_with?('*')
           arg_name = arg_name.to_s[1..-1].to_sym
-          process_varargs!(arg_values, result, commands_stack, arg_name, arg_is_mandatory)
+          process_varargs!(arg_values, result, arg_name, arg_is_mandatory)
         else
-          process_regular_argument!(arg_values, result, commands_stack, arg_name, arg_is_mandatory)
+          process_regular_argument!(arg_values, result, arg_name, arg_is_mandatory)
         end
       end
 
@@ -260,14 +253,14 @@ module SimpleScripting
       end
     end
 
-    def process_varargs!(arg_values, result, commands_stack, arg_name, arg_is_mandatory)
+    def process_varargs!(arg_values, result, arg_name, arg_is_mandatory)
       raise ArgumentError.new("Missing mandatory argument(s)") if arg_is_mandatory && arg_values.empty?
 
       result[arg_name] = arg_values.dup
       arg_values.clear
     end
 
-    def process_regular_argument!(arg_values, result, commands_stack, arg_name, arg_is_mandatory)
+    def process_regular_argument!(arg_values, result, arg_name, arg_is_mandatory)
       if arg_values.empty?
         if arg_is_mandatory
           raise ArgumentError.new("Missing mandatory argument(s)")

data/lib/simple_scripting/configuration.rb

@@ -16,11 +16,21 @@ module SimpleScripting
     def load(config_file: default_config_file, passwords_key: nil, required: [])
       create_empty_file(config_file) if !File.exist?(config_file)
 
-      configuration = ParseConfig.new(config_file)
+      params = ParseConfig.new(config_file).params
 
-      enforce_required_keys(configuration.params, required)
+      local_config_file = "#{config_file}.local"
 
-      convert_to_cool_format(OpenStruct.new, configuration.params, passwords_key)
+      if File.exist?(local_config_file)
+        local_params = ParseConfig.new(local_config_file).params
+
+        params = params.merge(local_params) do |_, value, local_value|
+          value.is_a?(Hash) && local_value.is_a?(Hash) ? value.merge(local_value) : local_value
+        end
+      end
+
+      enforce_required_keys(params, required)
+
+      convert_to_cool_format(OpenStruct.new, params, passwords_key)
     end
 
     private

data/lib/simple_scripting/tab_completion/commandline_processor.rb

@@ -8,7 +8,7 @@ module SimpleScripting
 
   class TabCompletion
 
-    class CommandlineProcessor < Struct.new(:processed_argv, :cursor_marker, :switches_definition)
+    class CommandlineProcessor < Struct.new(:processed_argv, :cursor_marker, :switches_definition, :escaped_dash)
 
       # Arbitrary; can be anything (except an empty string).
       BASE_CURSOR_MARKER = "<tab>"
@@ -27,7 +27,12 @@ module SimpleScripting
             # Remove the executable.
             processed_argv = Shellwords.split(commandline_with_marker)[1..-1]
 
-            return new(processed_argv, cursor_marker, switches_definition)
+            # Shellwords strips the backslash, losing the information that the word is a value, not
+            # an option.
+            #
+            escaped_dash = commandline_with_marker.match?(/(?:\A|\s)\\-\S*#{Regexp.escape(cursor_marker)}/)
+
+            return new(processed_argv, cursor_marker, switches_definition, escaped_dash)
           end
         end
       end
@@ -56,15 +61,23 @@ module SimpleScripting
         parsed_pairs = parse_argv || raise("Parsing error")
 
         key, value = parsed_pairs.detect do |_, value|
-          !boolean?(value) && value.include?(cursor_marker)
+          if value.is_a?(Array)
+            value.any? { |entry| entry.include?(cursor_marker) }
+          else
+            !boolean?(value) && value.include?(cursor_marker)
+          end
         end
 
         # Impossible case, unless there is a programmatic error.
         #
         key || raise("Guru meditation! (#{self.class}##{__method__}:#{__LINE__})")
 
+        value = value.detect { |entry| entry.include?(cursor_marker) } if value.is_a?(Array)
+
         value_prefix, value_suffix = value.split(cursor_marker)
 
+        value_prefix = "-#{value_prefix}" if escaped_dash
+
         parsed_pairs.delete(key)
 
         [key, value_prefix || "", value_suffix || "", parsed_pairs]
@@ -98,7 +111,10 @@ module SimpleScripting
           adapted_switches_definition[i] = "[#{definition}]" if definition.is_a?(String) && !definition.start_with?('[')
         end
 
-        SimpleScripting::Argv.decode(*adapted_switches_definition, arguments: processed_argv.dup, auto_help: false)
+        adapted_argv = processed_argv.dup
+        adapted_argv[marked_word_position] = adapted_argv[marked_word_position].delete_prefix("-") if escaped_dash
+
+        SimpleScripting::Argv.decode(*adapted_switches_definition, arguments: adapted_argv, auto_help: false)
       rescue Argv::InvalidCommand, Argv::ArgumentError, OptionParser::InvalidOption
         # OptionParser::InvalidOption: see case "-O<tab>" in test suite.
 

data/lib/simple_scripting/tab_completion.rb

@@ -29,7 +29,7 @@ module SimpleScripting
       commandline_processor = CommandlineProcessor.process_commandline(source_commandline, cursor_position, @switches_definition)
 
       if commandline_processor.completing_an_option?
-        complete_option(commandline_processor, execution_target)
+        complete_option(commandline_processor)
       elsif commandline_processor.parsing_error?
         return
       else # completing_a_value?
@@ -43,7 +43,7 @@ module SimpleScripting
     # Completion!
     #############################################
 
-    def complete_option(commandline_processor, execution_target)
+    def complete_option(commandline_processor)
       all_switches = @switches_definition.select { |definition| definition.is_a?(Array) }.map { |definition| definition[1][/^--\S+/] }
 
       matching_switches = all_switches.select { |switch| switch.start_with?(commandline_processor.completing_word_prefix) }

data/lib/simple_scripting/version.rb

@@ -1,5 +1,5 @@
 module SimpleScripting
 
-  VERSION = "0.14.1"
+  VERSION = "0.16.0"
 
 end

data/simple_scripting.gemspec

@@ -8,17 +8,18 @@ Gem::Specification.new do |s|
   s.name        = "simple_scripting"
   s.version     = SimpleScripting::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.required_ruby_version = '>= 2.7.0'
+  s.required_ruby_version = '>= 3.2.0'
   s.authors     = ["Saverio Miroddi"]
-  s.date        = "2024-12-25"
+  s.date        = "2026-07-07"
   s.email       = ["saverio.pub2@gmail.com"]
-  s.homepage    = "https://github.com/saveriomiroddi/simple_scripting"
+  s.homepage    = "https://github.com/64kramsystem/simple_scripting"
   s.summary     = "Library for simplifying some typical scripting functionalities."
   s.description = "Simplifies options parsing and configuration loading."
   s.license     = "GPL-3.0"
 
   s.add_runtime_dependency     "parseconfig", "~> 1.0"
   s.add_runtime_dependency     "ostruct",     "~> 0.6.1"
+  s.add_runtime_dependency     "base64",      "~> 0.3"
 
   s.add_development_dependency "rake",        "~> 12.0"
   s.add_development_dependency "rspec",       "~> 3.7"

data/spec/simple_scripting/argv_spec.rb

@@ -45,6 +45,18 @@ module SimpleScripting
           expect(return_value).to be(nil)
         end
 
+        it 'should print help without arguments usage and long help, when they are not defined' do
+          described_class.decode(['-a'], output: output_buffer, arguments: ['-h'])
+
+          expected_output = <<~OUTPUT
+            Usage: rspec [options]
+                -a
+                -h, --help                       Help
+          OUTPUT
+
+          expect(output_buffer.string).to eql(expected_output)
+        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'],
@@ -359,6 +371,19 @@ module SimpleScripting
               valid_commands: ["command1", "command2"],
             ))
           end
+
+          it "should print the invalid-command error and valid commands by default, instead of raising" do
+            decoder_params[:arguments] = ['pizza']
+
+            actual_result = described_class.decode(decoder_params)
+
+            expect(actual_result).to be(nil)
+            expect(output_buffer.string).to eql(<<~OUTPUT)
+              Command error!: Invalid command: pizza
+
+              Valid commands: command1, command2
+            OUTPUT
+          end
         end # context "error handling"
 
         context "help" do
@@ -509,5 +534,26 @@ module SimpleScripting
         }.to raise_error(Argv::ArgumentError, "Too many arguments")
       end
     end # describe 'No definitions given'
+
+    describe 'Definition/options handling' do
+      it "should work when no options hash is passed, reading ARGV" do
+        original_argv = ARGV.dup
+        ARGV.replace(['m_arg'])
+
+        begin
+          actual_result = described_class.decode('mandatory')
+
+          expect(actual_result).to eql(mandatory: 'm_arg')
+        ensure
+          ARGV.replace(original_argv)
+        end
+      end
+
+      it "should raise on an unrecognized param definition" do
+        expect {
+          described_class.decode(123, arguments: [], output: output_buffer)
+        }.to raise_error(RuntimeError, "Unrecognized value: 123")
+      end
+    end # describe 'Definition/options handling'
   end # describe Argv
 end # module SimpleScripting

data/spec/simple_scripting/configuration_spec.rb

@@ -51,6 +51,42 @@ g2_key=bang
     end
   end
 
+  it "should merge the .local configuration file, when present, over the main one" do
+    with_tempfile(configuration_text) do |config_file|
+      local_configuration_text = "
+relpath_key=local_foo
+
+[group1]
+g_key=local_baz
+      "
+
+      File.write("#{config_file}.local", local_configuration_text)
+
+      begin
+        configuration = described_class.load(config_file: config_file)
+
+        expect(configuration.relpath_key).to eql('local_foo')
+        expect(configuration.group1.g_key).to eql('local_baz')
+
+        # Keys not overridden are preserved.
+        expect(configuration.abspath_key).to eql('/tmp/bar')
+        expect(configuration.group2.g2_key).to eql('bang')
+      ensure
+        File.delete("#{config_file}.local")
+      end
+    end
+  end
+
+  it "should raise an error when decrypting a value without the passwords key" do
+    with_tempfile(configuration_text) do |config_file|
+      configuration = described_class.load(config_file: config_file)
+
+      expect {
+        configuration.encr_key.decrypted
+      }.to raise_error("Encryption key not provided!")
+    end
+  end
+
   it "should raise an error when required keys are missing" do
     with_tempfile(configuration_text) do |config_file|
       expect {
@@ -70,4 +106,22 @@ g2_key=bang
       File.delete(temp_config_file)
     end
   end
+
+  it "should derive the default config file from the program name, when none is given" do
+    Dir.mktmpdir do |home|
+      original_home = ENV['HOME']
+      original_prog = $PROGRAM_NAME
+      ENV['HOME'] = home
+      $PROGRAM_NAME = 'my_test_prog.rb'
+
+      begin
+        described_class.load
+
+        expect(File).to exist(File.join(home, '.my_test_prog'))
+      ensure
+        ENV['HOME'] = original_home
+        $PROGRAM_NAME = original_prog
+      end
+    end
+  end
 end # describe SimpleScripting::Configuration

data/spec/simple_scripting/tab_completion_spec.rb

@@ -13,6 +13,7 @@ describe SimpleScripting::TabCompletion do
     [
       ["-o", "--opt1 ARG"],
       ["-O", "--opt2"],
+      ["-m", "--multi V1,V2"],
       "arg1",               # this and the following are internally converted to optional, as
       "arg2",               # according to the Argv spec, without brackets they are mandatory.
     ]
@@ -33,6 +34,10 @@ describe SimpleScripting::TabCompletion do
         ['arg1v1', 'arg1v2', '_arg1v3', ' _argv1spc'].select { |entry| entry =~ /^#{prefix}#{suffix}/ }
       end
 
+      def multi(prefix, suffix, context)
+        %w(multiv1 _multiv2).select { |entry| entry =~ /^#{prefix}#{suffix}/ }
+      end
+
       def arg2(prefix, suffix, context)
         # A value starting with minus is valid.
         #
@@ -57,11 +62,11 @@ describe SimpleScripting::TabCompletion do
         "a -- --<tab>"      => %w(--arg2v3),
         "-- --aaa <tab>"    => %w(arg2v1 arg2v2 --arg2v3),
 
-        "--<tab>"           => %w(--opt1 --opt2),
-        "--<tab> a"         => %w(--opt1 --opt2),
-        "--<tab> -- a"      => %w(--opt1 --opt2),
-        "--<tab> -- b"      => %w(--opt1 --opt2),
-        "--<tab> --xyz"     => %w(--opt1 --opt2),
+        "--<tab>"           => %w(--opt1 --opt2 --multi),
+        "--<tab> a"         => %w(--opt1 --opt2 --multi),
+        "--<tab> -- a"      => %w(--opt1 --opt2 --multi),
+        "--<tab> -- b"      => %w(--opt1 --opt2 --multi),
+        "--<tab> --xyz"     => %w(--opt1 --opt2 --multi),
         "--opt1 <tab> a"    => %w(opt1v1 _opt1v2),
         "--opt1 o<tab> a"   => %w(opt1v1),
 
@@ -96,17 +101,25 @@ describe SimpleScripting::TabCompletion do
 
     context "escaped cases" do
       ESCAPED_CASES = {
-        "\ <tab>"           => [" _argv1spc"],
+        '\ <tab>'           => [" _argv1spc"],
         '\-<tab>'           => %w(),                       # this is the result of typing `command "\-<tab>`
         'a \-<tab>'         => %w(--arg2v3),
       }
 
-      ESCAPED_CASES.each do |symbolic_commandline_options, _|
-        it "should output the entries for #{symbolic_commandline_options.inspect}"
+      ESCAPED_CASES.each do |symbolic_commandline_options, expected_entries|
+        it "should output the entries for #{symbolic_commandline_options.inspect}" do
+          expect(symbolic_commandline_options).to complete_with(expected_entries)
+        end
       end
     end # context "escaped cases"
 
-    it "should support multiple values for an option"
+    it "should support multiple values for an option" do
+      expect("--multi multiv1,m<tab>").to complete_with(%w(multiv1))
+    end
+
+    it "should use the next cursor marker when the commandline contains the base one" do
+      expect("a<tab0> <tab>").to complete_with(%w(arg2v1 arg2v2 --arg2v3))
+    end
 
     it "should keep parsing also when --help is passed" do
       expect("--help a<tab>").to complete_with(%w(arg1v1 arg1v2))
@@ -114,14 +127,16 @@ describe SimpleScripting::TabCompletion do
   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
-    ]
+    INCORRECT_CASES = {
+      "a b <tab>" => "Command error!: Too many arguments\n",        # too many args
+      "-O<tab>"   => "Command error!: invalid option: -<tab0>\n",   # no values for this option
+    }
 
-    INCORRECT_CASES.each do |symbolic_commandline_options|
+    INCORRECT_CASES.each do |symbolic_commandline_options, expected_error_message|
       it "should not output any entries for #{symbolic_commandline_options.inspect}" do
-        expect(symbolic_commandline_options).to not_complete
+        expect {
+          expect(symbolic_commandline_options).to not_complete
+        }.to output(expected_error_message).to_stdout
       end
     end
   end # context "with an incorrect configuration"

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 # Coverage setup
 
-require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: simple_scripting
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.16.0
 platform: ruby
 authors:
 - Saverio Miroddi
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-25 00:00:00.000000000 Z
+date: 2026-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parseconfig
@@ -38,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,11 +107,10 @@ files:
 - spec/simple_scripting/configuration_spec.rb
 - spec/simple_scripting/tab_completion_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/saveriomiroddi/simple_scripting
+homepage: https://github.com/64kramsystem/simple_scripting
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,15 +118,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Library for simplifying some typical scripting functionalities.
 test_files: