aspera-cli 4.17.0 → 4.18.1

data/lib/aspera/cli/manager.rb

@@ -55,9 +55,13 @@ module Aspera
       # option name separator in code (symbol)
       OPTION_SEP_SYMBOL = '_'
       SOURCE_USER = 'cmdline' # cspell:disable-line
-      TYPE_INTEGER = [Integer].freeze
+      OPTION_VALUE_SEPARATOR = '='
+      OPTION_PREFIX = '--'
+      OPTIONS_STOP = '--'
 
-      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :SOURCE_USER, :TYPE_INTEGER
+      DEFAULT_PARSER_TYPES = [Array, Hash].freeze
+
+      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :SOURCE_USER
 
       class << self
         def enum_to_bool(enum)
@@ -83,9 +87,9 @@ module Aspera
 
         # Generates error message with list of allowed values
         # @param error_msg [String] error message
-        # @param choices [Array] list of allowed values
-        def multi_choice_assert(assertion, error_msg, choices)
-          raise Cli::BadArgument, [error_msg, 'Use:'].concat(choices.map{|c|"- #{c}"}.sort).join("\n") unless assertion
+        # @param accept_list [Array] list of allowed values
+        def multi_choice_assert(assertion, error_msg, accept_list)
+          raise Cli::BadArgument, [error_msg, 'Use:'].concat(accept_list.map{|c|"- #{c}"}.sort).join("\n") unless assertion
         end
 
         # change option name with dash to name with underscore
@@ -94,19 +98,22 @@ module Aspera
         end
 
         def option_name_to_line(name)
-          return "--#{name.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)}"
+          return "#{OPTION_PREFIX}#{name.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)}"
         end
 
         # @param what [Symbol] :option or :argument
         # @param descr [String] description for help
-        # @param value [Object] value to check
+        # @param to_check [Object] value to check
         # @param type_list [NilClass, Class, Array[Class]] accepted value type(s)
-        def validate_type(what, descr, value, type_list)
+        def validate_type(what, descr, to_check, type_list, check_array: false)
           return nil if type_list.nil?
           Aspera.assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}
-          raise Cli::BadArgument,
-            "#{what.to_s.capitalize} #{descr} is a #{value.class} but must be #{type_list.length > 1 ? 'one of ' : ''}#{type_list.map(&:name).join(',')}" unless \
-            type_list.any?{|t|value.is_a?(t)}
+          value_list = check_array ? to_check : [to_check]
+          value_list.each do |value|
+            raise Cli::BadArgument,
+              "#{what.to_s.capitalize} #{descr} is a #{value.class} but must be #{type_list.length > 1 ? 'one of ' : ''}#{type_list.map(&:name).join(',')}" unless \
+              type_list.any?{|t|value.is_a?(t)}
+          end
         end
       end
 
@@ -114,23 +121,25 @@ module Aspera
       attr_accessor :ask_missing_mandatory, :ask_missing_optional
       attr_writer :fail_on_missing_mandatory
 
-      def initialize(program_name)
-        # command line values not starting with '-'
+      def initialize(program_name, argv = nil)
+        # command line values *not* starting with '-'
         @unprocessed_cmd_line_arguments = []
         # command line values starting with '-'
         @unprocessed_cmd_line_options = []
         # a copy of all initial options
         @initial_cli_options = []
-        # option description: key = option symbol, value=hash, :read_write, :accessor, :value, :accepted
+        # option description: key = option symbol, value=Hash, :read_write, :accessor, :value, :accepted
         @declared_options = {}
         # do we ask missing options and arguments to user ?
         @ask_missing_mandatory = false # STDIN.isatty
         # ask optional options if not provided and in interactive
         @ask_missing_optional = false
         @fail_on_missing_mandatory = true
-        # those must be set before parse, parse consumes those defined only
-        @unprocessed_defaults = []
-        @unprocessed_env = []
+        # Array of [key(sym), value]
+        # those must be set before parse
+        # parse consumes those defined only
+        @option_pairs_batch = {}
+        @option_pairs_env = {}
         # NOTE: was initially inherited but it is preferred to have specific methods
         @parser = OptionParser.new
         @parser.program_name = program_name
@@ -138,100 +147,94 @@ module Aspera
         env_prefix = program_name.upcase + OPTION_SEP_SYMBOL
         ENV.each do |k, v|
           if k.start_with?(env_prefix)
-            @unprocessed_env.push([k[env_prefix.length..-1].downcase.to_sym, v])
+            @option_pairs_env[k[env_prefix.length..-1].downcase.to_sym] = v
           end
         end
-        Log.log.debug{"env=#{@unprocessed_env}".red}
+        Log.log.debug{"env=#{@option_pairs_env}".red}
         @unprocessed_cmd_line_options = []
         @unprocessed_cmd_line_arguments = []
-      end
-
-      def parse_command_line(argv)
-        @parser.separator('')
-        @parser.separator('OPTIONS: global')
-        declare(:interactive, 'Use interactive input of missing params', values: :bool, handler: {o: self, m: :ask_missing_mandatory})
-        declare(:ask_options, 'Ask even optional options', values: :bool, handler: {o: self, m: :ask_missing_optional})
-        parse_options!
+        return if argv.nil?
         process_options = true
         until argv.empty?
           value = argv.shift
           if process_options && value.start_with?('-')
-            if value.eql?('--')
+            Log.log.trace1{"opt: #{value}"}
+            if value.eql?(OPTIONS_STOP)
               process_options = false
             else
               @unprocessed_cmd_line_options.push(value)
             end
           else
+            Log.log.trace1{"arg: #{value}"}
             @unprocessed_cmd_line_arguments.push(value)
           end
         end
-        @initial_cli_options = @unprocessed_cmd_line_options.dup
+        @initial_cli_options = @unprocessed_cmd_line_options.dup.freeze
         Log.log.debug{"add_cmd_line_options:commands/arguments=#{@unprocessed_cmd_line_arguments},options=#{@unprocessed_cmd_line_options}".red}
+        @parser.separator('')
+        @parser.separator('OPTIONS: global')
+        declare(:interactive, 'Use interactive input of missing params', values: :bool, handler: {o: self, m: :ask_missing_mandatory})
+        declare(:ask_options, 'Ask even optional options', values: :bool, handler: {o: self, m: :ask_missing_optional})
+        declare(:struct_parser, 'Default parser when expected value is a struct', values: %i[json ruby])
+        # do not parse options yet, let's wait for option `-h` to be overriden
       end
 
       # @param descr [String] description for help
-      # @param expected is
-      #   - Array of allowed value (single value)
-      #   - :multiple for remaining values
-      #   - :single for a single unconstrained value
-      #   - :integer for a single integer value
       # @param mandatory [Boolean] if true, raise error if option not set
-      # @param type [Class, Array] accepted value type(s)
+      # @param multiple [Boolean] if true, return remaining arguments
+      # @param accept_list [Array] list of allowed values (Symbol)
+      # @param validation [Class, Array] accepted value type(s) or list of Symbols
       # @param aliases [Hash] map of aliases: key = alias, value = real value
       # @param default [Object] default value
-      # @return value, list or nil
-      def get_next_argument(descr, expected: :single, mandatory: true, type: nil, aliases: nil, default: nil)
-        Aspera.assert(%i[single multiple].include?(expected) || (expected.is_a?(Array) && expected.all?(Symbol))) do
-          'expected must be single, multiple, or array of symbol'
-        end
-        Aspera.assert(type.nil? || type.is_a?(Class) || (type.is_a?(Array) && type.all?(Class))){'type must be Class or Array of Class'}
-        Aspera.assert(aliases.nil? || (aliases.is_a?(Hash) && aliases.keys.all?(Symbol) && aliases.values.all?(Symbol))){'aliases must be Hash'}
-        allowed_types = type
+      # @return one value, list or nil (if optional and no default)
+      def get_next_argument(descr, mandatory: true, multiple: false, accept_list: nil, validation: String, aliases: nil, default: nil)
+        Aspera.assert(accept_list.nil? || (accept_list.is_a?(Array) && accept_list.all?(Symbol)))
+        validation = Symbol if accept_list
+        Aspera.assert(validation.nil? || validation.is_a?(Class) || (validation.is_a?(Array) && validation.all?(Class))){'validation must be Class or Array of Class'}
+        Aspera.assert(aliases.nil? || (aliases.is_a?(Hash) && aliases.keys.all?(Symbol) && aliases.values.all?(Symbol))){'aliases must be Hash:Symbol: Symbol'}
+        allowed_types = validation
         unless allowed_types.nil?
           allowed_types = [allowed_types] unless allowed_types.is_a?(Array)
           descr = "#{descr} (#{allowed_types.join(', ')})"
         end
         result =
           if !@unprocessed_cmd_line_arguments.empty?
-            # there are values
-            case expected
-            when :single
-              ExtendedValue.instance.evaluate(@unprocessed_cmd_line_arguments.shift)
-            when :multiple
-              value = @unprocessed_cmd_line_arguments.shift(@unprocessed_cmd_line_arguments.length).map{|v|ExtendedValue.instance.evaluate(v)}
-              # if expecting list and only one arg of type array : it is the list
-              if value.length.eql?(1) && value.first.is_a?(Array)
-                value = value.first
-              end
-              value
-            when Array
-              allowed_values = [].concat(expected)
+            how_many = multiple ? @unprocessed_cmd_line_arguments.length : 1
+            values = @unprocessed_cmd_line_arguments.shift(how_many)
+            values = values.map{|v|evaluate_extended_value(v, allowed_types)}
+            # if expecting list and only one arg of type array : it is the list
+            values = values.first if values.length.eql?(1) && values.first.is_a?(Array)
+            if accept_list
+              allowed_values = [].concat(accept_list)
               allowed_values.concat(aliases.keys) unless aliases.nil?
-              self.class.get_from_list(@unprocessed_cmd_line_arguments.shift, descr, allowed_values)
-            else Aspera.error_unexpected_value(expected)
+              values = values.map{|v|self.class.get_from_list(v, descr, allowed_values)}
             end
+            multiple ? values : values.first
           elsif !default.nil? then default
             # no value provided, either get value interactively, or exception
-          elsif mandatory then get_interactive(:argument, descr, expected: expected)
+          elsif mandatory then get_interactive(descr, multiple: multiple, accept_list: accept_list)
           end
-        if result.is_a?(String) && allowed_types.eql?(TYPE_INTEGER)
+        if result.is_a?(String) && validation.eql?(Integer)
           int_result = Integer(result, exception: false)
           raise Cli::BadArgument, "Invalid integer: #{result}" if int_result.nil?
           result = int_result
         end
         Log.log.debug{"#{descr}=#{result}"}
         result = aliases[result] if aliases&.key?(result)
-        self.class.validate_type(:argument, descr, result, allowed_types) unless result.nil? && !mandatory
+        # if value comes from JSON/YAML, it may come as Integer
+        result = result.to_s if result.is_a?(Integer) && validation.eql?(String)
+        self.class.validate_type(:argument, descr, result, allowed_types, check_array: multiple) unless result.nil? && !mandatory
         return result
       end
 
-      def get_next_command(command_list, aliases: nil); return get_next_argument('command', expected: command_list, aliases: aliases); end
+      def get_next_command(command_list, aliases: nil); return get_next_argument('command', accept_list: command_list, aliases: aliases); end
 
       # Get an option value by name
       # either return value or calls handler, can return nil
       # ask interactively if requested/required
       # @param mandatory [Boolean] if true, raise error if option not set
       def get_option(option_symbol, mandatory: false, default: nil)
+        Aspera.assert_type(option_symbol, Symbol)
         attributes = @declared_options[option_symbol]
         Aspera.assert(attributes){"option not declared: #{option_symbol}"}
         result = nil
@@ -253,13 +256,13 @@ module Aspera
             raise Cli::BadArgument, "Missing mandatory option: #{option_symbol}" if mandatory
           elsif @ask_missing_optional || mandatory
             # ask_missing_mandatory
-            expected = :single
+            accept_list = nil
             # print "please enter: #{option_symbol.to_s}"
             if @declared_options.key?(option_symbol) && attributes.key?(:values)
-              expected = attributes[:values]
+              accept_list = attributes[:values]
             end
-            result = get_interactive(:option, option_symbol.to_s, expected: expected)
-            set_option(option_symbol, result, 'interactive')
+            result = get_interactive(option_symbol.to_s, option: true, accept_list: accept_list)
+            set_option(option_symbol, result, where: 'interactive')
           end
         end
         self.class.validate_type(:option, option_symbol, result, attributes[:types]) unless result.nil? && !mandatory
@@ -267,11 +270,16 @@ module Aspera
       end
 
       # set an option value by name, either store value or call handler
-      def set_option(option_symbol, value, where='code override')
+      # @param option_symbol [Symbol] option name
+      # @param value [String] value to set
+      # @param where [String] where the value comes from
+      # @param expect [Class, Array] expected value type(s)
+      def set_option(option_symbol, value, where: 'code override')
+        Aspera.assert_type(option_symbol, Symbol)
         raise Cli::BadArgument, "Unknown option: #{option_symbol}" unless @declared_options.key?(option_symbol)
         attributes = @declared_options[option_symbol]
         Log.log.warn("#{option_symbol}: Option is deprecated: #{attributes[:deprecation]}") if attributes[:deprecation]
-        value = ExtendedValue.instance.evaluate(value)
+        value = evaluate_extended_value(value, attributes[:types])
         value = Manager.enum_to_bool(value) if attributes[:values].eql?(BOOLEAN_VALUES)
         Log.log.debug{"(#{attributes[:read_write]}/#{where}) set #{option_symbol}=#{value}"}
         self.class.validate_type(:option, option_symbol, value, attributes[:types])
@@ -292,10 +300,11 @@ module Aspera
       # @param default [Object] default value
       # @param values [nil, Array, :bool, :date, :none] list of allowed values, :bool for true/false, :date for dates, :none for on/off switch
       # @param short [String] short option name
-      # @param coerce [Class] one of the coerce types accepted par option parser
+      # @param coerce [Class] one of the coerce types accepted by option parser
       # @param types [Class, Array] accepted value type(s)
       # @param block [Proc] block to execute when option is found
       def declare(option_symbol, description, handler: nil, default: nil, values: nil, short: nil, coerce: nil, types: nil, deprecation: nil, &block)
+        Aspera.assert_type(option_symbol, Symbol)
         Aspera.assert(!@declared_options.key?(option_symbol)){"#{option_symbol} already declared"}
         Aspera.assert(description[-1] != '.'){"#{option_symbol} ends with dot"}
         Aspera.assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with capital"}
@@ -307,7 +316,7 @@ module Aspera
         }
         if !types.nil?
           types = [types] unless types.is_a?(Array)
-          Aspera.assert(types.all?(Class)){"types must be Array of Class: #{types}"}
+          Aspera.assert(types.all?(Class)){"types must be (Array of) Class: #{types}"}
           opt[:types] = types
           description = "#{description} (#{types.map(&:name).join(', ')})"
         end
@@ -322,18 +331,18 @@ module Aspera
           Log.log.debug{"set attr obj #{option_symbol} (#{handler[:o]},#{handler[:m]})"}
           opt[:accessor] = AttrAccessor.new(handler[:o], handler[:m], option_symbol)
         end
-        set_option(option_symbol, default, 'default') unless default.nil?
+        set_option(option_symbol, default, where: 'default') unless default.nil?
         on_args = [description]
         case values
         when nil
           on_args.push(symbol_to_option(option_symbol, 'VALUE'))
           on_args.push("-#{short}VALUE") unless short.nil?
           on_args.push(coerce) unless coerce.nil?
-          @parser.on(*on_args) { |v| set_option(option_symbol, v, SOURCE_USER) }
+          @parser.on(*on_args) { |v| set_option(option_symbol, v, where: SOURCE_USER) }
         when Array, :bool
           if values.eql?(:bool)
             values = BOOLEAN_VALUES
-            set_option(option_symbol, Manager.enum_to_bool(default), 'default') unless default.nil?
+            set_option(option_symbol, Manager.enum_to_bool(default), where: 'default') unless default.nil?
           end
           # this option value must be a symbol
           opt[:values] = values
@@ -345,7 +354,7 @@ module Aspera
           on_args[0] = "#{description}: #{help_values}"
           on_args.push(symbol_to_option(option_symbol, 'ENUM'))
           on_args.push(values)
-          @parser.on(*on_args){|v|set_option(option_symbol, self.class.get_from_list(v.to_s, description, values), SOURCE_USER)}
+          @parser.on(*on_args){|v|set_option(option_symbol, self.class.get_from_list(v.to_s, description, values), where: SOURCE_USER)}
         when :date
           on_args.push(symbol_to_option(option_symbol, 'DATE'))
           @parser.on(*on_args) do |v|
@@ -354,11 +363,11 @@ module Aspera
             when /^-([0-9]+)h/ then Manager.time_to_string(Time.now - (Regexp.last_match(1).to_i * 3600))
             else v
             end
-            set_option(option_symbol, time_string, SOURCE_USER)
+            set_option(option_symbol, time_string, where: SOURCE_USER)
           end
         when :none
           Aspera.assert(!block.nil?){"missing block for #{option_symbol}"}
-          on_args.push(symbol_to_option(option_symbol, nil))
+          on_args.push(symbol_to_option(option_symbol))
           on_args.push("-#{short}") if short.is_a?(String)
           @parser.on(*on_args, &block)
         else Aspera.error_unexpected_value(values)
@@ -368,11 +377,13 @@ module Aspera
 
       # Adds each of the keys of specified hash as an option
       # @param preset_hash [Hash] hash of options to add
-      def add_option_preset(preset_hash, op: :push)
+      def add_option_preset(preset_hash, where, override: true)
         Aspera.assert_type(preset_hash, Hash)
-        Log.log.debug{"add_option_preset=#{preset_hash}"}
-        # incremental override
-        preset_hash.each{|k, v|@unprocessed_defaults.send(op, [k.to_sym, v])}
+        Log.log.debug{"add_option_preset: #{preset_hash}, #{where}, #{override}"}
+        preset_hash.each do |k, v|
+          option_symbol = k.to_sym
+          @option_pairs_batch[option_symbol] = v if override || !@option_pairs_batch.key?(option_symbol)
+        end
       end
 
       # check if there were unprocessed values to generate error
@@ -389,20 +400,21 @@ module Aspera
       end
 
       # get all original options on command line used to generate a config in config file
-      def get_options_table(remove_from_remaining: true)
+      # @return [Hash] options as taken from config file and command line just before command execution
+      def unprocessed_options_with_value
         result = {}
         @initial_cli_options.each do |option_value|
           case option_value
-          when /^--([^=]+)$/
+          when /^#{OPTION_PREFIX}([^=]+)$/o
             # ignore
-          when /^--([^=]+)=(.*)$/
+          when /^#{OPTION_PREFIX}([^=]+)=(.*)$/o
             name = Regexp.last_match(1)
             value = Regexp.last_match(2)
             name.gsub!(OPTION_SEP_LINE, OPTION_SEP_SYMBOL)
             value = ExtendedValue.instance.evaluate(value)
             Log.log.debug{"option #{name}=#{value}"}
             result[name] = value
-            @unprocessed_cmd_line_options.delete(option_value) if remove_from_remaining
+            @unprocessed_cmd_line_options.delete(option_value)
           else
             raise Cli::BadArgument, "wrong option format: #{option_value}"
           end
@@ -425,8 +437,8 @@ module Aspera
       def parse_options!
         Log.log.debug('parse_options!'.red)
         # first conf file, then env var
-        apply_options_preset(@unprocessed_defaults, 'file')
-        apply_options_preset(@unprocessed_env, 'env')
+        consume_option_pairs(@option_pairs_batch, 'set')
+        consume_option_pairs(@option_pairs_env, 'env')
         # command line override
         unknown_options = []
         begin
@@ -445,7 +457,7 @@ module Aspera
         @unprocessed_cmd_line_options = unknown_options
       end
 
-      def prompt_user_input(prompt, sensitive)
+      def prompt_user_input(prompt, sensitive: false)
         return $stdin.getpass("#{prompt}> ") if sensitive
         print("#{prompt}> ")
         line = $stdin.gets
@@ -459,7 +471,7 @@ module Aspera
       # @return [Symbol] selected symbol
       def prompt_user_input_in_list(prompt, sym_list)
         loop do
-          input = prompt_user_input(prompt, false).to_sym
+          input = prompt_user_input(prompt).to_sym
           if sym_list.any?{|a|a.eql?(input)}
             return input
           else
@@ -468,38 +480,53 @@ module Aspera
         end
       end
 
-      def get_interactive(type, descr, expected: :single)
+      # Prompt user for input in a list of symbols
+      # @param descr [String] description for help
+      # @param option [Boolean] true if command line option
+      # @param multiple [Boolean] true if multiple values expected
+      # @param accept_list [Array] list of expected values
+      def get_interactive(descr, option: false, multiple: false, accept_list: nil)
+        what = option ? 'option' : 'argument'
         if !@ask_missing_mandatory
-          raise Cli::BadArgument, "missing argument (#{expected}): #{descr}" unless expected.is_a?(Array)
-          self.class.multi_choice_assert(false, "missing: #{descr}", expected)
+          message = "missing #{what}: #{descr}"
+          if accept_list.nil?
+            raise Cli::BadArgument, message
+          else
+            self.class.multi_choice_assert(false, message, accept_list)
+          end
         end
         result = nil
-        sensitive = type.eql?(:option) && @declared_options[descr.to_sym].is_a?(Hash) && @declared_options[descr.to_sym][:sensitive]
-        default_prompt = "#{type}: #{descr}"
+        sensitive = option && @declared_options[descr.to_sym].is_a?(Hash) && @declared_options[descr.to_sym][:sensitive]
+        default_prompt = "#{what}: #{descr}"
         # ask interactively
-        case expected
-        when :multiple
-          result = []
-          puts(' (one per line, end with empty line)')
-          loop do
-            entry = prompt_user_input(default_prompt, sensitive)
-            break if entry.empty?
-            result.push(ExtendedValue.instance.evaluate(entry))
-          end
-        when :single
-          result = ExtendedValue.instance.evaluate(prompt_user_input(default_prompt, sensitive))
-        else # one fixed
-          result = self.class.get_from_list(prompt_user_input("#{expected.join(' ')}\n#{default_prompt}", sensitive), descr, expected)
+        result = []
+        puts(' (one per line, end with empty line)') if multiple
+        loop do
+          prompt = default_prompt
+          prompt = "#{accept_list.join(' ')}\n#{default_prompt}" if accept_list
+          entry = prompt_user_input(prompt, sensitive: sensitive)
+          break if entry.empty? && multiple
+          entry = ExtendedValue.instance.evaluate(entry)
+          entry = self.class.get_from_list(entry, descr, accept_list) if accept_list
+          return entry unless multiple
+          result.push(entry)
         end
         return result
       end
 
       private
 
+      def evaluate_extended_value(value, types)
+        if DEFAULT_PARSER_TYPES.include?(types) || (types.is_a?(Array) && types.all?{|t|DEFAULT_PARSER_TYPES.include?(t)})
+          return ExtendedValue.instance.evaluate_with_default(value)
+        end
+        return ExtendedValue.instance.evaluate(value)
+      end
+
       # generate command line option from option symbol
-      def symbol_to_option(symbol, opt_val)
-        result = '--' + symbol.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)
-        result = result + '=' + opt_val unless opt_val.nil?
+      def symbol_to_option(symbol, opt_val = nil)
+        result = [OPTION_PREFIX, symbol.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)].join
+        result = [result, OPTION_VALUE_SEPARATOR, opt_val].join unless opt_val.nil?
         return result
       end
 
@@ -507,23 +534,28 @@ module Aspera
         $stdout.isatty ? value.to_s.red.bold : "[#{value}]"
       end
 
-      def apply_options_preset(preset, where)
-        unprocessed = []
-        preset.each do |pair|
-          k, v = *pair
+      # try to evaluate options set ib batch
+      # @param unprocessed_options [Array] list of options to apply (key_sym,value)
+      # @param where [String] where the options come from
+      def consume_option_pairs(unprocessed_options, where)
+        Log.log.debug{"consume_option_pairs: #{where}"}
+        options_to_set = {}
+        unprocessed_options.each do |k, v|
           if @declared_options.key?(k)
             # constrained parameters as string are revert to symbol
             if @declared_options[k].key?(:values) && v.is_a?(String)
-              v = self.class.get_from_list(v, k.to_s + " in #{where}", @declared_options[k][:values])
+              v = self.class.get_from_list(v, "#{k} in #{where}", @declared_options[k][:values])
             end
-            set_option(k, v, where)
+            options_to_set[k] = v
           else
-            unprocessed.push(pair)
+            Log.log.debug{"unprocessed: #{k}: #{v}"}
           end
         end
-        # keep only unprocessed values for next parse
-        preset.clear
-        preset.push(*unprocessed)
+        options_to_set.each do |k, v|
+          set_option(k, v, where: where)
+          # keep only unprocessed values for next parse
+          unprocessed_options.delete(k)
+        end
       end
     end
   end

data/lib/aspera/cli/plugin.rb

@@ -19,6 +19,7 @@ module Aspera
       MAX_PAGES = 'pmax'
       # special identifier format: look for this name to find where supported
       REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/.freeze
+      # instance variables, also constructor parameters
       INIT_PARAMS = %i[options transfer config formatter persistency only_manual].freeze
 
       class << self
@@ -28,7 +29,6 @@ module Aspera
             :value, 'Value for create, update, list filter', types: Hash,
             deprecation: '(4.14) Use positional value for create/modify or option: query for list/delete')
           options.declare(:property, 'Name of property to set (modify operation)')
-          options.declare(:id, 'Resource identifier', deprecation: "(4.14) Use positional identifier after verb (#{INSTANCE_OPS.join(',')})")
           options.declare(:bulk, 'Bulk operation (only some)', values: :bool, default: :no)
           options.declare(:bfail, 'Bulk operation error handling', values: :bool, default: :yes)
         end
@@ -62,15 +62,14 @@ module Aspera
       # @param description [String] description of the identifier
       # @param as_option [Symbol] option name to use if identifier is an option
       # @param block [Proc] block to search for identifier based on attribute value
-      # @return [String] identifier
+      # @return [String, Array] identifier or list of ids
       def instance_identifier(description: 'identifier', as_option: nil, &block)
         if as_option.nil?
-          res_id = options.get_option(:id)
-          res_id = options.get_next_argument(description) if res_id.nil?
+          res_id = options.get_next_argument(description, multiple: options.get_option(:bulk)) if res_id.nil?
         else
           res_id = options.get_option(as_option)
         end
-        # cab be an Array
+        # can be an Array
         if res_id.is_a?(String) && (m = res_id.match(REGEX_LOOKUP_ID_BY_FIELD))
           if block
             res_id = yield(m[1], ExtendedValue.instance.evaluate(m[2]))
@@ -108,7 +107,9 @@ module Aspera
             # execute custom code
             res = yield(param)
             # if block returns a hash, let's use this (create)
-            result = res if param.is_a?(Hash)
+            result = res if res.is_a?(Hash)
+            # TODO: remove when faspio gw api fixes this
+            result = res.first if res.is_a?(Array) && res.first.is_a?(Hash)
             # create -> created
             result['status'] = "#{command}#{'e' unless command.to_s.end_with?('e')}d".gsub(/yed$/, 'ied')
           rescue StandardError => e
@@ -133,9 +134,16 @@ module Aspera
       # @param item_list_key [String] result is in a sub key of the json
       # @param id_as_arg [String] if set, the id is provided as url argument ?<id_as_arg>=<id>
       # @param is_singleton [Boolean] if true, res_class_path is the full path to the resource
+      # @param delete_style [String] if set, the delete operation by array in payload
       # @param block [Proc] block to search for identifier based on attribute value
       # @return result suitable for CLI result
-      def entity_command(command, rest_api, res_class_path, display_fields: nil, item_list_key: false, id_as_arg: false, is_singleton: false, &block)
+      def entity_command(command, rest_api, res_class_path,
+        display_fields: nil,
+        item_list_key: false,
+        id_as_arg: false,
+        is_singleton: false,
+        delete_style: nil,
+        &block)
         if is_singleton
           one_res_path = res_class_path
         elsif INSTANCE_OPS.include?(command)
@@ -152,14 +160,20 @@ module Aspera
           end
         when :delete
           raise 'cannot delete singleton' if is_singleton
+          if !delete_style.nil?
+            one_res_id = [one_res_id] unless one_res_id.is_a?(Array)
+            Aspera.assert_type(one_res_id, Array, exception_class: Cli::BadArgument)
+            rest_api.call(operation: 'DELETE', subpath: res_class_path, headers: {'Accept' => 'application/json'}, body: {delete_style => one_res_id}, body_type: :json)
+            return Main.result_status('deleted')
+          end
           return do_bulk_operation(command: command, descr: 'identifier', values: one_res_id) do |one_id|
-            rest_api.delete("#{res_class_path}/#{one_id}", old_query_read_delete)
+            rest_api.delete("#{res_class_path}/#{one_id}", query_read_delete)
             {'id' => one_id}
           end
         when :show
           return {type: :single_object, data: rest_api.read(one_res_path)[:data], fields: display_fields}
         when :list
-          resp = rest_api.read(res_class_path, old_query_read_delete)
+          resp = rest_api.read(res_class_path, query_read_delete)
           return Main.result_empty if resp[:http].code == '204'
           data = resp[:data]
           # TODO: not generic : which application is this for ?
@@ -215,14 +229,6 @@ module Aspera
         return query
       end
 
-      # TODO: when deprecation of `value` is completed: remove this method, replace with query_read_delete
-      # deprecation: 4.14
-      def old_query_read_delete
-        query = options.get_option(:value) # legacy, deprecated, remove, one day...
-        query = query_read_delete if query.nil?
-        return query
-      end
-
       # TODO: when deprecation of `value` is completed: remove this method, replace with options.get_option(:query)
       # deprecation: 4.14
       def query_option(mandatory: false, default: nil)
@@ -246,7 +252,7 @@ module Aspera
         Log.log.warn("option `value` is deprecated. Use positional parameter for #{command}") unless value.nil?
         value = options.get_next_argument(
           "parameters for #{command}#{description.nil? ? '' : " (#{description})"}", mandatory: default.nil?,
-          type: bulk ? Array : type) if value.nil?
+          validation: bulk ? Array : type) if value.nil?
         value = default if value.nil?
         unless type.nil?
           type = [type] unless type.is_a?(Array)
@@ -262,6 +268,6 @@ module Aspera
         end
         return value
       end
-    end # Plugin
-  end # Cli
-end # Aspera
+    end
+  end
+end