aspera-cli 4.18.0 → 4.19.0

data/lib/aspera/cli/manager.rb

@@ -20,7 +20,7 @@ module Aspera
         @method = method_name
         @option_name = option_name
         @has_writer = @object.respond_to?(writer_method)
-        Log.log.debug{"AttrAccessor: #{@option_name}: #{@object.class}.#{@method}: writer=#{@has_writer}"}
+        Log.log.trace1{"AttrAccessor: #{@option_name}: #{@object.class}.#{@method}: writer=#{@has_writer}"}
         Aspera.assert(@object.respond_to?(@method)) {"#{object} does not respond to #{method_name}"}
       end
 
@@ -55,12 +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)
@@ -86,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
@@ -102,14 +103,17 @@ module Aspera
 
         # @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
 
@@ -117,7 +121,7 @@ module Aspera
       attr_accessor :ask_missing_mandatory, :ask_missing_optional
       attr_writer :fail_on_missing_mandatory
 
-      def initialize(program_name)
+      def initialize(program_name, argv = nil)
         # command line values *not* starting with '-'
         @unprocessed_cmd_line_arguments = []
         # command line values starting with '-'
@@ -149,14 +153,7 @@ module Aspera
         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
@@ -174,65 +171,63 @@ module Aspera
         end
         @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
@@ -261,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
@@ -275,12 +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])
@@ -329,21 +328,21 @@ module Aspera
         if opt[:read_write].eql?(:accessor)
           Aspera.assert_type(handler, Hash)
           Aspera.assert(handler.keys.sort.eql?(%i[m o]))
-          Log.log.debug{"set attr obj #{option_symbol} (#{handler[:o]},#{handler[:m]})"}
+          Log.log.trace1{"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
@@ -355,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|
@@ -364,7 +363,7 @@ 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}"}
@@ -373,7 +372,7 @@ module Aspera
           @parser.on(*on_args, &block)
         else Aspera.error_unexpected_value(values)
         end
-        Log.log.debug{"on_args=#{on_args}"}
+        Log.log.trace1{"on_args=#{on_args}"}
       end
 
       # Adds each of the keys of specified hash as an option
@@ -401,6 +400,7 @@ module Aspera
       end
 
       # get all original options on command line used to generate a config in config file
+      # @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|
@@ -435,7 +435,7 @@ module Aspera
 
       # removes already known options from the list
       def parse_options!
-        Log.log.debug('parse_options!'.red)
+        Log.log.trace1('parse_options!'.red)
         # first conf file, then env var
         consume_option_pairs(@option_pairs_batch, 'set')
         consume_option_pairs(@option_pairs_env, 'env')
@@ -443,21 +443,21 @@ module Aspera
         unknown_options = []
         begin
           # remove known options one by one, exception if unknown
-          Log.log.debug('before parse'.red)
+          Log.log.trace1('before parse'.red)
           @parser.parse!(@unprocessed_cmd_line_options)
-          Log.log.debug('After parse'.red)
+          Log.log.trace1('After parse'.red)
         rescue OptionParser::InvalidOption => e
-          Log.log.debug{"InvalidOption #{e}".red}
+          Log.log.trace1{"InvalidOption #{e}".red}
           # save for later processing
           unknown_options.push(e.args.first)
           retry
         end
-        Log.log.debug{"remains: #{unknown_options}"}
+        Log.log.trace1{"remains: #{unknown_options}"}
         # set unprocessed options for next time
         @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
@@ -471,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
@@ -480,34 +480,49 @@ 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 = nil)
         result = [OPTION_PREFIX, symbol.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)].join
@@ -523,7 +538,7 @@ module Aspera
       # @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}"}
+        Log.log.trace1{"consume_option_pairs: #{where}"}
         options_to_set = {}
         unprocessed_options.each do |k, v|
           if @declared_options.key?(k)
@@ -533,11 +548,11 @@ module Aspera
             end
             options_to_set[k] = v
           else
-            Log.log.debug{"unprocessed: #{k}: #{v}"}
+            Log.log.trace1{"unprocessed: #{k}: #{v}"}
           end
         end
         options_to_set.each do |k, v|
-          set_option(k, v, where)
+          set_option(k, v, where: where)
           # keep only unprocessed values for next parse
           unprocessed_options.delete(k)
         end

data/lib/aspera/cli/plugin.rb

@@ -5,7 +5,7 @@ require 'aspera/assert'
 
 module Aspera
   module Cli
-    # base class for plugins modules
+    # Base class for plugins
     class Plugin
       # operations without id
       GLOBAL_OPS = %i[create list].freeze
@@ -29,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
@@ -54,8 +53,8 @@ module Aspera
         options.parser.separator('OPTIONS:')
       end
 
+      # @return a hash of instance variables
       def init_params
-        # return a hash of instance variables
         INIT_PARAMS.map{|p| [p, instance_variable_get("@#{p}".to_sym)]}.to_h
       end
 
@@ -66,9 +65,7 @@ module Aspera
       # @return [String, Array] identifier or list of ids
       def instance_identifier(description: 'identifier', as_option: nil, &block)
         if as_option.nil?
-          # use of option `id` is deprecated
-          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
@@ -255,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)

data/lib/aspera/cli/plugin_factory.rb

@@ -3,7 +3,7 @@
 require 'singleton'
 module Aspera
   module Cli
-    # option is retrieved from another object using accessor
+    # Instantiate plugin from well-known locations
     class PluginFactory
       include Singleton
 
@@ -19,14 +19,17 @@ module Aspera
         @plugins = {}
       end
 
+      # @return list of registered plugins
       def plugin_list
         @plugins.keys
       end
 
+      # @return path to source file of plugin
       def plugin_source(plugin_name_sym)
         @plugins[plugin_name_sym][:source]
       end
 
+      # add a folder to the list of folders to look for plugins
       def add_lookup_folder(folder)
         @lookup_folders.unshift(folder)
       end
@@ -43,6 +46,7 @@ module Aspera
         end
       end
 
+      # @return Class object for plugin
       def plugin_class(plugin_name_sym)
         raise "ERROR: plugin not found: #{plugin_name_sym}" unless @plugins.key?(plugin_name_sym)
         require @plugins[plugin_name_sym][:require_stanza]
@@ -50,6 +54,9 @@ module Aspera
         return Object.const_get("#{Module.nesting[1]}::#{PLUGINS_MODULE}::#{plugin_name_sym.to_s.capitalize}")
       end
 
+      # Create specified plugin
+      # @param plugin_name_sym [Symbol] name of plugin
+      # @param args [Hash] arguments to pass to plugin constructor
       def create(plugin_name_sym, **args)
         # TODO: check that ancestor is Plugin?
         plugin_class(plugin_name_sym).new(**args)
@@ -57,6 +64,8 @@ module Aspera
 
       private
 
+      # add plugin information to list
+      # @param path [String] path to plugin source file
       def add_plugin_info(path)
         raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
         plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym

data/lib/aspera/cli/plugins/aoc.rb

@@ -4,6 +4,7 @@ require 'aspera/cli/plugins/node'
 require 'aspera/cli/plugins/ats'
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/cli/transfer_agent'
+require 'aspera/cli/special_values'
 require 'aspera/agent/node'
 require 'aspera/transfer/spec'
 require 'aspera/api/aoc'
@@ -123,7 +124,7 @@ module Aspera
               formatter.display_status(pub_key_pem)
               if !options.get_option(:test_mode)
                 formatter.display_status('Once updated or validated, press enter.')
-                OpenApplication.instance.uri(instance_url)
+                Environment.instance.open_uri(instance_url)
                 $stdin.gets
               end
             else
@@ -137,7 +138,7 @@ module Aspera
                 formatter.display_status('- origin: localhost')
                 formatter.display_status('Use the generated client id and secret in the following prompts.'.red)
               end
-              OpenApplication.instance.uri("#{instance_url}/admin/api-clients")
+              Environment.instance.open_uri("#{instance_url}/admin/api-clients")
               options.get_option(:client_id, mandatory: true)
               options.get_option(:client_secret, mandatory: true)
               use_browser_authentication = true
@@ -319,8 +320,8 @@ module Aspera
             # client side is agent
             # server side is transfer server
             # in same workspace
-            push_pull = options.get_next_argument('direction', expected: %i[push pull])
-            source_folder = options.get_next_argument('folder of source files', type: String)
+            push_pull = options.get_next_argument('direction', accept_list: %i[push pull])
+            source_folder = options.get_next_argument('folder of source files', validation: String)
             case push_pull
             when :push
               client_direction = Transfer::Spec::DIRECTION_SEND
@@ -415,7 +416,7 @@ module Aspera
             fields = object.keys.reject{|k|k.eql?('certificate')}
             return { type: :single_object, data: object, fields: fields }
           when :modify
-            changes = options.get_next_argument('properties', type: Hash)
+            changes = options.get_next_argument('properties', validation: Hash)
             return do_bulk_operation(command: command, descr: 'identifier', values: res_id) do |one_id|
               aoc_api.update("#{resource_class_path}/#{one_id}", changes)
               {'id' => one_id}
@@ -427,7 +428,7 @@ module Aspera
             end
           when :set_pub_key
             # special : reads private and generate public
-            the_private_key = options.get_next_argument('private_key PEM value', type: String)
+            the_private_key = options.get_next_argument('private_key PEM value', validation: String)
             the_public_key = OpenSSL::PKey::RSA.new(the_private_key).public_key.to_s
             aoc_api.update(resource_instance_path, {jwt_grant_enabled: true, public_key: the_public_key})
             return Main.result_success
@@ -449,7 +450,7 @@ module Aspera
           case command_admin
           when :resource
             Log.log.warn('resource command is deprecated (4.18), directly use the specific command instead')
-            return execute_resource_action(options.get_next_argument('resource', expected: ADMIN_OBJECTS))
+            return execute_resource_action(options.get_next_argument('resource', accept_list: ADMIN_OBJECTS))
           when *ADMIN_OBJECTS
             return execute_resource_action(command_admin)
           when :auth_providers
@@ -534,7 +535,7 @@ module Aspera
               return {type: :object_list, data: events}
             when :transfers
               event_type = command_analytics.to_s
-              filter_resource = options.get_next_argument('resource', expected: %i[organizations users nodes])
+              filter_resource = options.get_next_argument('resource', accept_list: %i[organizations users nodes])
               filter_id = options.get_next_argument('identifier', mandatory: false) ||
                 case filter_resource
                 when :organizations then aoc_api.current_user_info['organization_id']
@@ -622,7 +623,7 @@ module Aspera
               when :show
                 return { type: :single_object, data: aoc_api.current_user_info(exception: true) }
               when :modify
-                aoc_api.update("users/#{aoc_api.current_user_info(exception: true)['id']}", options.get_next_argument('properties', type: Hash))
+                aoc_api.update("users/#{aoc_api.current_user_info(exception: true)['id']}", options.get_next_argument('properties', validation: Hash))
                 return Main.result_status('modified')
               end
             when :preferences
@@ -631,7 +632,7 @@ module Aspera
               when :show
                 return { type: :single_object, data: aoc_api.read(user_preferences_res)[:data] }
               when :modify
-                aoc_api.update(user_preferences_res, options.get_next_argument('properties', type: Hash))
+                aoc_api.update(user_preferences_res, options.get_next_argument('properties', validation: Hash))
                 return Main.result_status('modified')
               end
             end
@@ -690,13 +691,13 @@ module Aspera
                     ].concat(aoc_api.additional_persistence_ids)))
               end
               case ids_to_download
-              when ExtendedValue::ALL, ExtendedValue::INIT
+              when SpecialValues::ALL, SpecialValues::INIT
                 query = query_read_delete(default: PACKAGE_RECEIVED_BASE_QUERY)
                 Aspera.assert_type(query, Hash){'query'}
                 resolve_dropbox_name_default_ws_id(query)
                 # remove from list the ones already downloaded
                 all_ids = api_read_all('packages', query)[:data].map{|e|e['id']}
-                if ids_to_download.eql?(ExtendedValue::INIT)
+                if ids_to_download.eql?(SpecialValues::INIT)
                   Aspera.assert(skip_ids_persistency){'Only with option once_only'}
                   skip_ids_persistency.data.clear.concat(all_ids)
                   skip_ids_persistency.save
@@ -758,9 +759,9 @@ module Aspera
             when *NODE4_EXT_COMMANDS
               return execute_nodegen4_command(command_repo, aoc_api.context[:home_node_id], file_id: aoc_api.context[:home_file_id], scope: Api::Node::SCOPE_USER)
             when :short_link
-              link_type = options.get_next_argument('link type', expected: %i[public private])
+              link_type = options.get_next_argument('link type', accept_list: %i[public private])
               short_link_command = options.get_next_command(%i[create delete list])
-              folder_dest = options.get_next_argument('path', type: String)
+              folder_dest = options.get_next_argument('path', validation: String)
               home_node_api = aoc_api.node_api_from(
                 node_id:        aoc_api.context[:home_node_id],
                 workspace_id:   aoc_api.context[:workspace_id],