aspera-cli 4.18.0 → 4.18.1

data/lib/aspera/cli/manager.rb

@@ -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])
@@ -332,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
@@ -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}"}
@@ -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|
@@ -457,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
@@ -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
@@ -537,7 +552,7 @@ module Aspera
           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

@@ -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
@@ -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/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],

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

@@ -3,6 +3,7 @@
 # cspell:ignore initdemo genkey pubkey asperasoft filelists
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/cli/extended_value'
+require 'aspera/cli/special_values'
 require 'aspera/cli/version'
 require 'aspera/cli/formatter'
 require 'aspera/cli/info'
@@ -15,7 +16,7 @@ require 'aspera/transfer/spec'
 require 'aspera/keychain/encrypted_hash'
 require 'aspera/keychain/macos_security'
 require 'aspera/proxy_auto_config'
-require 'aspera/open_application'
+require 'aspera/environment'
 require 'aspera/persistency_action_once'
 require 'aspera/id_generator'
 require 'aspera/persistency_folder'
@@ -293,7 +294,7 @@ module Aspera
             Aspera.assert_type(path, String){'Expecting a String for certificate location'}
             paths_to_add = [path]
             Log.log.debug{"Adding cert location: #{path}"}
-            if path.eql?(ExtendedValue::DEF)
+            if path.eql?(SpecialValues::DEF)
               @certificate_store.set_default_paths
               paths_to_add = [
                 OpenSSL::X509::DEFAULT_CERT_DIR,
@@ -324,7 +325,7 @@ module Aspera
           locations = @certificate_paths
           if locations.nil?
             # compute default locations
-            self.trusted_cert_locations = ExtendedValue::DEF
+            self.trusted_cert_locations = SpecialValues::DEF
             locations = @certificate_paths
             # restore defaults
             @certificate_paths = @certificate_store = nil
@@ -685,7 +686,7 @@ module Aspera
               api_connect_cdn.call(operation: 'GET', subpath: file_url, save_to_file: File.join(folder_dest, filename))
               return Main.result_status("Downloaded: #{filename}")
             when :open
-              OpenApplication.instance.uri(one_link['href'])
+              Environment.instance.open_uri(one_link['href'])
               return Main.result_status("Opened: #{one_link['href']}")
             end
           end
@@ -786,11 +787,11 @@ module Aspera
           when :set
             param_name = options.get_next_argument('parameter name')
             param_name = Manager.option_line_to_name(param_name)
-            param_value = options.get_next_argument('parameter value')
+            param_value = options.get_next_argument('parameter value', validation: nil)
             set_preset_key(name, param_name, param_value)
             return Main.result_nothing
           when :initialize
-            config_value = options.get_next_argument('extended value', type: Hash)
+            config_value = options.get_next_argument('extended value', validation: Hash)
             if @config_presets.key?(name)
               Log.log.warn{"configuration already exists: #{name}, overwriting"}
             end
@@ -804,10 +805,10 @@ module Aspera
             @config_presets[name].merge!(unprocessed_options)
             return Main.result_status("Updated: #{name}")
           when :ask
-            options.ask_missing_mandatory = :yes
+            options.ask_missing_mandatory = true
             @config_presets[name] ||= {}
-            options.get_next_argument('option names', expected: :multiple).each do |option_name|
-              option_value = options.get_interactive(:option, option_name)
+            options.get_next_argument('option names', multiple: true).each do |option_name|
+              option_value = options.get_interactive(option_name, option: true)
               @config_presets[name][option_name] = option_value
             end
             return Main.result_status("Updated: #{name}")
@@ -879,16 +880,16 @@ module Aspera
           when :preset # newer syntax
             return execute_preset
           when :open
-            OpenApplication.editor(@option_config_file.to_s)
+            Environment.open_editor(@option_config_file.to_s)
             return Main.result_nothing
           when :documentation
             section = options.get_next_argument('private key file path', mandatory: false)
             section = "##{section}" unless section.nil?
-            OpenApplication.instance.uri("#{@help}#{section}")
+            Environment.instance.open_uri("#{@help}#{section}")
             return Main.result_nothing
           when :genkey # generate new rsa key
             private_key_path = options.get_next_argument('private key file path')
-            private_key_length = options.get_next_argument('size in bits', mandatory: false, type: Integer, default: DEFAULT_PRIV_KEY_LENGTH)
+            private_key_length = options.get_next_argument('size in bits', mandatory: false, validation: Integer, default: DEFAULT_PRIV_KEY_LENGTH)
             self.class.generate_rsa_private_key(path: private_key_path, length: private_key_length)
             return Main.result_status("Generated #{private_key_length} bit RSA key: #{private_key_path}")
           when :pubkey # get pub key
@@ -908,7 +909,7 @@ module Aspera
               return Main.result_status(remote_chain.first.subject.to_a.find { |name, _, _| name == 'CN' }[1])
             end
           when :echo # display the content of a value given on command line
-            return Formatter.auto_type(options.get_next_argument('value'))
+            return Formatter.auto_type(options.get_next_argument('value', validation: nil))
           when :flush_tokens
             deleted_files = OAuth::Factory.instance.flush_tokens
             return {type: :value_list, data: deleted_files, name: 'file'}
@@ -927,8 +928,8 @@ module Aspera
               end
               return {type: :object_list, data: result, fields: %w[plugin detect wizard path]}
             when :create
-              plugin_name = options.get_next_argument('name', expected: :single).downcase
-              destination_folder = options.get_next_argument('folder', expected: :single, mandatory: false) || File.join(@main_folder, ASPERA_PLUGINS_FOLDERNAME)
+              plugin_name = options.get_next_argument('name').downcase
+              destination_folder = options.get_next_argument('folder', mandatory: false) || File.join(@main_folder, ASPERA_PLUGINS_FOLDERNAME)
               plugin_file = File.join(destination_folder, "#{plugin_name}.rb")
               content = <<~END_OF_PLUGIN_CODE
                 require 'aspera/cli/plugin'
@@ -1077,7 +1078,7 @@ module Aspera
           Log.log.debug{"wizard result: #{wizard_result}"}
           Aspera.assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)){"missing or extra keys in wizard result: #{wizard_result.keys}"}
           # get preset name from user or default
-          wiz_preset_name = options.get_option(:id)
+          wiz_preset_name = nil
           if wiz_preset_name.nil?
             elements = [
               identification[:product],
@@ -1217,8 +1218,8 @@ module Aspera
           when :show
             return {type: :single_object, data: vault.get(label: options.get_next_argument('label'))}
           when :create
-            label = options.get_next_argument('label', type: String)
-            info = options.get_next_argument('info', type: Hash)
+            label = options.get_next_argument('label', validation: String)
+            info = options.get_next_argument('info', validation: Hash)
             info = info.symbolize_keys
             info[:label] = label
             vault.set(info)
@@ -1270,7 +1271,7 @@ module Aspera
                 info[:password])
             when 'system'
               case Environment.os
-              when Environment::OS_X
+              when Environment::OS_MACOS
                 @vault = Keychain::MacosSystem.new(info[:name], info[:password])
               else
                 raise 'not implemented for this OS'