aspera-cli 4.21.1 → 4.22.0

data/lib/aspera/cli/main.rb

@@ -15,14 +15,36 @@ require 'aspera/assert'
 
 module Aspera
   module Cli
+    # Global objects shared with plugins
+    class Objects
+      MEMBERS = %i[options transfer config formatter persistency].freeze
+      attr_accessor(*MEMBERS)
+
+      def validate
+        MEMBERS.each do |i|
+          Aspera.assert(instance_variable_defined?(:"@#{i}"))
+          Aspera.assert(!instance_variable_get(:"@#{i}").nil?)
+        end
+      end
+
+      def only_manual?
+        transfer.eql?(:only_manual)
+      end
+
+      def only_manual
+        @transfer = :only_manual
+      end
+    end
+
     # The main CLI class
     class Main
       # Plugins store transfer result using this key and use result_transfer_multiple()
       STATUS_FIELD = 'status'
       COMMAND_CONFIG = :config
       COMMAND_HELP = :help
+      SCALAR_TYPES = [String, Integer, Symbol].freeze
 
-      private_constant :COMMAND_CONFIG, :COMMAND_HELP
+      private_constant :COMMAND_CONFIG, :COMMAND_HELP, :SCALAR_TYPES
 
       class << self
         # expect some list, but nothing to display
@@ -33,6 +55,8 @@ module Aspera
 
         def result_status(status); return {type: :status, data: status}; end
 
+        def result_text(data); return {type: :text, data: data}; end
+
         def result_success; return result_status('complete'); end
 
         # Process statuses of finished transfer sessions
@@ -57,80 +81,189 @@ module Aspera
             item[STATUS_FIELD] = item[STATUS_FIELD].map(&:to_s).join(',')
           end
           raise global_status unless global_status.eql?(:success)
-          return {type: :object_list, data: status_table}
+          return result_object_list(status_table)
         end
 
         def result_image(blob, formatter:)
           return Main.result_status(formatter.status_image(blob))
         end
 
-        def result_single_object(data)
-          return {type: :single_object, data: data}
+        def result_single_object(data, fields: nil)
+          return {type: :single_object, data: data, fields: fields}
         end
 
         def result_object_list(data, fields: nil, total: nil)
-          return {type: :object_list, data: data, fields: fields, total: nil}
+          return {type: :object_list, data: data, fields: fields, total: total}
         end
 
         def result_value_list(data, name)
           return {type: :value_list, data: data, name: name}
         end
-      end
 
-      private
-
-      # shortcuts helpers like in plugins
-      %i[options transfer config formatter persistency].each do |name|
-        define_method(name){@plug_init[name]}
+        # Determines type of result based on data
+        def result_auto(data)
+          case data
+          when Hash
+            return result_single_object(data)
+          when Array
+            all_types = data.map(&:class).uniq
+            return result_object_list(data) if all_types.eql?([Hash])
+            unsupported_types = all_types - SCALAR_TYPES
+            return result_value_list(data, 'list') if unsupported_types.empty?
+            Aspera.error_unexpected_value(unsupported_types){'list item types'}
+          when *SCALAR_TYPES
+            return result_text(data)
+          else Aspera.error_unexpected_value(data.class.name){'result type'}
+          end
+        end
       end
 
-      # =============================================================
-      # Parameter handlers
-      #
-
       # minimum initialization, no exception raised
       def initialize(argv)
         @argv = argv
-        # environment provided to plugin for various capabilities
-        @plug_init = Plugin::INIT_PARAMS.each_with_object({}) { |key, hash| hash[key] = nil }
+        early_debug_setup
+        Log.log.trace2{Log.dump(:argv, @argv)}
         @option_help = false
         @option_show_config = false
         @bash_completion = false
-        early_debug_setup
-        Log.log.trace2{Log.dump(:argv, @argv)}
+        @env = Objects.new
       end
 
+      # this is the main function called by initial script just after constructor
+      def process_command_line
+        # catch exception information , if any
+        exception_info = nil
+        # false if command shall not be executed (e.g. --show-config)
+        execute_command = true
+        # catch exceptions
+        begin
+          init_agents_and_options
+          # find plugins, shall be after parse! ?
+          PluginFactory.instance.add_plugins_from_lookup_folders
+          # help requested without command ? (plugins must be known here)
+          exit_with_usage(true) if @option_help && @env.options.command_or_arg_empty?
+          generate_bash_completion if @bash_completion
+          @env.config.periodic_check_newer_gem_version
+          command_sym =
+            if @option_show_config && @env.options.command_or_arg_empty?
+              COMMAND_CONFIG
+            else
+              @env.options.get_next_command(PluginFactory.instance.plugin_list.unshift(COMMAND_HELP))
+            end
+          # command will not be executed, but we need manual
+          @env.options.fail_on_missing_mandatory = false if @option_help || @option_show_config
+          # main plugin is not dynamically instantiated
+          case command_sym
+          when COMMAND_HELP
+            exit_with_usage(true)
+          when COMMAND_CONFIG
+            command_plugin = @env.config
+          else
+            # get plugin, set options, etc
+            command_plugin = get_plugin_instance_with_options(command_sym)
+            # parse plugin specific options
+            @env.options.parse_options!
+          end
+          # help requested for current plugin
+          exit_with_usage(false) if @option_help
+          if @option_show_config
+            @env.formatter.display_results(type: :single_object, data: @env.options.known_options(only_defined: true).stringify_keys)
+            execute_command = false
+          end
+          # locking for single execution (only after "per plugin" option, in case lock port is there)
+          lock_port = @env.options.get_option(:lock_port)
+          if !lock_port.nil?
+            begin
+              # no need to close later, will be freed on process exit. must save in member else it is garbage collected
+              Log.log.debug{"Opening lock port #{lock_port}"}
+              # loopback address, could also be 'localhost'
+              @tcp_server = TCPServer.new('127.0.0.1', lock_port)
+            rescue StandardError => e
+              execute_command = false
+              Log.log.warn{"Another instance is already running (#{e.message})."}
+            end
+          end
+          pid_file = @env.options.get_option(:pid_file)
+          if !pid_file.nil?
+            File.write(pid_file, Process.pid)
+            Log.log.debug{"Wrote pid #{Process.pid} to #{pid_file}"}
+            at_exit{File.delete(pid_file)}
+          end
+          # execute and display (if not exclusive execution)
+          @env.formatter.display_results(**command_plugin.execute_action) if execute_command
+          # save config file if command modified it
+          @env.config.save_config_file_if_needed
+          # finish
+          @env.transfer.shutdown
+        rescue Net::SSH::AuthenticationFailed => e; exception_info = {e: e, t: 'SSH', security: true}
+        rescue OpenSSL::SSL::SSLError => e;         exception_info = {e: e, t: 'SSL'}
+        rescue Cli::BadArgument => e;               exception_info = {e: e, t: 'Argument', usage: true}
+        rescue Cli::BadIdentifier => e;          exception_info = {e: e, t: 'Identifier'}
+        rescue Cli::Error => e;                     exception_info = {e: e, t: 'Tool', usage: true}
+        rescue Transfer::Error => e;                exception_info = {e: e, t: 'Transfer'}
+        rescue RestCallError => e;                  exception_info = {e: e, t: 'Rest'}
+        rescue SocketError => e;                    exception_info = {e: e, t: 'Network'}
+        rescue StandardError => e;                  exception_info = {e: e, t: "Other(#{e.class.name})", debug: true}
+        rescue Interrupt => e;                      exception_info = {e: e, t: 'Interruption', debug: true}
+        end
+        # cleanup file list files
+        TempFileManager.instance.cleanup
+        # 1- processing of error condition
+        unless exception_info.nil?
+          Log.log.warn(exception_info[:e].message) if Log.instance.logger_type.eql?(:syslog) && exception_info[:security]
+          @env.formatter.display_message(:error, "#{Formatter::ERROR_FLASH} #{exception_info[:t]}: #{exception_info[:e].message}")
+          @env.formatter.display_message(:error, 'Use option -h to get help.') if exception_info[:usage]
+          # Is that a known error condition with proposal for remediation ?
+          Hints.hint_for(exception_info[:e], @env.formatter)
+        end
+        # 2- processing of command not processed (due to exception or bad command line)
+        if execute_command || @option_show_config
+          @env.options.final_errors.each do |msg|
+            @env.formatter.display_message(:error, "#{Formatter::ERROR_FLASH} Argument: #{msg}")
+            # add code as exception if there is not already an error
+            exception_info = {e: Exception.new(msg), t: 'UnusedArg'} if exception_info.nil?
+          end
+        end
+        # 3- in case of error, fail the process status
+        unless exception_info.nil?
+          # show stack trace in debug mode
+          raise exception_info[:e] if Log.log.debug?
+          # else give hint and exit
+          @env.formatter.display_message(:error, 'Use --log-level=debug to get more details.') if exception_info[:debug]
+          Process.exit(1)
+        end
+        return nil
+      end
+
+      private
+
       # This can throw exception if there is a problem with the environment, needs to be caught by execute method
       def init_agents_and_options
-        @plug_init[:only_manual] = false
         # create formatter, in case there is an exception, it is used to display.
-        @plug_init[:formatter] = Formatter.new
+        @env.formatter = Formatter.new
         # create command line manager with arguments
-        @plug_init[:options] = Manager.new(Info::CMD_NAME, @argv)
+        @env.options = Manager.new(Info::CMD_NAME, @argv)
         # formatter adds options
-        @plug_init[:formatter].declare_options(options)
-        ExtendedValue.instance.default_decoder = options.get_option(:struct_parser)
+        @env.formatter.declare_options(@env.options)
+        ExtendedValue.instance.default_decoder = @env.options.get_option(:struct_parser)
         # compare $0 with expected name
         current_prog_name = File.basename($PROGRAM_NAME)
-        formatter.display_message(
+        @env.formatter.display_message(
           :error,
           "#{Formatter::WARNING_FLASH} Please use '#{Info::CMD_NAME}' instead of '#{current_prog_name}'") unless current_prog_name.eql?(Info::CMD_NAME)
         # declare and parse global options
         declare_global_options
         # the Config plugin adds the @preset parser, so declare before TransferAgent which may use it
-        @plug_init[:config] = Plugins::Config.new(**@plug_init, man_header: false)
-        @plug_init[:persistency] = @plug_init[:config].persistency
-        # data persistency
-        Aspera.assert(@plug_init[:persistency]){'missing persistency object'}
+        @env.config = Plugins::Config.new(broker: @env, man_header: false)
+        # data persistency is set in config
+        Aspera.assert(@env.persistency){'missing persistency object'}
         # the TransferAgent plugin may use the @preset parser
-        @plug_init[:config].transfer = @plug_init[:transfer] = TransferAgent.new(options, config)
+        @env.transfer = TransferAgent.new(@env.options, @env.config)
         # add commands for config plugin after all options have been added
-        @plug_init[:config].add_manual_header(false)
-        nil_keys = @plug_init.select{|_, value|value.nil?}.keys
-        Aspera.assert(nil_keys.empty?){"nil : #{nil_keys}"}
-        Log.log.debug('plugin env created'.red)
+        @env.config.add_manual_header(false)
+        @env.validate
         # set banner when all environment is created so that additional extended value modifiers are known, e.g. @preset
-        options.parser.banner = app_banner
+        @env.options.parser.banner = app_banner
       end
 
       def app_banner
@@ -170,41 +303,40 @@ module Aspera
       # define header for manual
       def declare_global_options
         Log.log.debug('declare_global_options')
-        options.declare(:help, 'Show this message', values: :none, short: 'h') { @option_help = true }
-        options.declare(:bash_comp, 'Generate bash completion for command', values: :none) { @bash_completion = true }
-        options.declare(:show_config, 'Display parameters used for the provided action', values: :none) { @option_show_config = true }
-        options.declare(:version, 'Display version', values: :none, short: 'v') { formatter.display_message(:data, Cli::VERSION); Process.exit(0) } # rubocop:disable Style/Semicolon, Layout/LineLength
-        options.declare(
+        @env.options.declare(:help, 'Show this message', values: :none, short: 'h'){@option_help = true}
+        @env.options.declare(:bash_comp, 'Generate bash completion for command', values: :none){@bash_completion = true}
+        @env.options.declare(:show_config, 'Display parameters used for the provided action', values: :none){@option_show_config = true}
+        @env.options.declare(:version, 'Display version', values: :none, short: 'v'){@env.formatter.display_message(:data, Cli::VERSION); Process.exit(0)} # rubocop:disable Style/Semicolon, Layout/LineLength
+        @env.options.declare(
           :ui, 'Method to start browser',
           values: Environment::USER_INTERFACES,
           handler: {o: Environment.instance, m: :url_method},
           default: Environment.default_gui_mode)
-        options.declare(:log_level, 'Log level', values: Log.levels, handler: {o: Log.instance, m: :level})
-        options.declare(:logger, 'Logging method', values: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
-        options.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron', coerce: Integer, types: Integer)
-        options.declare(:once_only, 'Process only new items (some commands)', values: :bool, default: false)
-        options.declare(:log_secrets, 'Show passwords in logs', values: :bool, handler: {o: SecretHider, m: :log_secrets})
-        options.declare(:clean_temp, 'Cleanup temporary files on exit', values: :bool, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
-        options.declare(:pid_file, 'Write process identifier to file, delete on exit', types: String)
+        @env.options.declare(:log_level, 'Log level', values: Log.levels, handler: {o: Log.instance, m: :level})
+        @env.options.declare(:logger, 'Logging method', values: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
+        @env.options.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron', coerce: Integer, types: Integer)
+        @env.options.declare(:once_only, 'Process only new items (some commands)', values: :bool, default: false)
+        @env.options.declare(:log_secrets, 'Show passwords in logs', values: :bool, handler: {o: SecretHider, m: :log_secrets})
+        @env.options.declare(:clean_temp, 'Cleanup temporary files on exit', values: :bool, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
+        @env.options.declare(:pid_file, 'Write process identifier to file, delete on exit', types: String)
         # parse declared options
-        options.parse_options!
+        @env.options.parse_options!
       end
 
       # @return the plugin instance, based on name
       # also loads the plugin options, and default values from conf file
       # @param plugin_name_sym : symbol for plugin name
-      def get_plugin_instance_with_options(plugin_name_sym, env=nil)
-        env ||= @plug_init
+      def get_plugin_instance_with_options(plugin_name_sym)
         Log.log.debug{"get_plugin_instance_with_options(#{plugin_name_sym})"}
         # load default params only if no param already loaded before plugin instantiation
-        env[:config].add_plugin_default_preset(plugin_name_sym)
-        command_plugin = PluginFactory.instance.create(plugin_name_sym, **env)
+        @env.config.add_plugin_default_preset(plugin_name_sym)
+        command_plugin = PluginFactory.instance.create(plugin_name_sym, broker: @env)
         return command_plugin
       end
 
       def generate_bash_completion
-        if options.get_next_argument('', multiple: true, mandatory: false).nil?
-          PluginFactory.instance.plugin_list.each{|p|puts p}
+        if @env.options.get_next_argument('', multiple: true, mandatory: false).nil?
+          PluginFactory.instance.plugin_list.each{ |p| puts p}
         else
           Log.log.warn('only first level completion so far')
         end
@@ -214,27 +346,24 @@ module Aspera
       def exit_with_usage(include_all_plugins)
         Log.log.debug{"exit_with_usage(#{include_all_plugins})".bg_red}
         # display main plugin options (+config)
-        formatter.display_message(:error, options.parser)
+        @env.formatter.display_message(:error, @env.options.parser)
         if include_all_plugins
+          @env.only_manual
           # list plugins that have a "require" field, i.e. all but main plugin
           PluginFactory.instance.plugin_list.each do |plugin_name_sym|
             # config was already included in the global options
             next if plugin_name_sym.eql?(COMMAND_CONFIG)
             # override main option parser with a brand new, to avoid having global options
-            plugin_env = @plug_init.clone
-            plugin_env[:only_manual] = true # force declaration of all options
-            plugin_env[:options] = Manager.new(Info::CMD_NAME)
-            plugin_env[:options].parser.banner = '' # remove default banner
-            get_plugin_instance_with_options(plugin_name_sym, plugin_env)
+            @env.options = Manager.new(Info::CMD_NAME)
+            @env.options.parser.banner = '' # remove default banner
+            get_plugin_instance_with_options(plugin_name_sym)
             # display generated help for plugin options
-            formatter.display_message(:error, plugin_env[:options].parser.help)
+            @env.formatter.display_message(:error, @env.options.parser.help)
           end
         end
         Process.exit(0)
       end
 
-      protected
-
       # early debug for parser
       # Note: does not accept shortcuts
       def early_debug_setup
@@ -249,113 +378,6 @@ module Aspera
           $stderr.puts("Error: #{e}")
         end
       end
-
-      public
-
-      # this is the main function called by initial script just after constructor
-      def process_command_line
-        # catch exception information , if any
-        exception_info = nil
-        # false if command shall not be executed (e.g. --show-config)
-        execute_command = true
-        # catch exceptions
-        begin
-          init_agents_and_options
-          # find plugins, shall be after parse! ?
-          PluginFactory.instance.add_plugins_from_lookup_folders
-          # help requested without command ? (plugins must be known here)
-          exit_with_usage(true) if @option_help && options.command_or_arg_empty?
-          generate_bash_completion if @bash_completion
-          config.periodic_check_newer_gem_version
-          command_sym =
-            if @option_show_config && options.command_or_arg_empty?
-              COMMAND_CONFIG
-            else
-              options.get_next_command(PluginFactory.instance.plugin_list.unshift(COMMAND_HELP))
-            end
-          # command will not be executed, but we need manual
-          options.fail_on_missing_mandatory = false if @option_help || @option_show_config
-          # main plugin is not dynamically instantiated
-          case command_sym
-          when COMMAND_HELP
-            exit_with_usage(true)
-          when COMMAND_CONFIG
-            command_plugin = config
-          else
-            # get plugin, set options, etc
-            command_plugin = get_plugin_instance_with_options(command_sym)
-            # parse plugin specific options
-            options.parse_options!
-          end
-          # help requested for current plugin
-          exit_with_usage(false) if @option_help
-          if @option_show_config
-            formatter.display_results(type: :single_object, data: options.known_options(only_defined: true).stringify_keys)
-            execute_command = false
-          end
-          # locking for single execution (only after "per plugin" option, in case lock port is there)
-          lock_port = options.get_option(:lock_port)
-          if !lock_port.nil?
-            begin
-              # no need to close later, will be freed on process exit. must save in member else it is garbage collected
-              Log.log.debug{"Opening lock port #{lock_port}"}
-              @tcp_server = TCPServer.new('127.0.0.1', lock_port)
-            rescue StandardError => e
-              execute_command = false
-              Log.log.warn{"Another instance is already running (#{e.message})."}
-            end
-          end
-          pid_file = options.get_option(:pid_file)
-          if !pid_file.nil?
-            File.write(pid_file, Process.pid)
-            Log.log.debug{"Wrote pid #{Process.pid} to #{pid_file}"}
-            at_exit{File.delete(pid_file)}
-          end
-          # execute and display (if not exclusive execution)
-          formatter.display_results(**command_plugin.execute_action) if execute_command
-          # save config file if command modified it
-          config.save_config_file_if_needed
-          # finish
-          transfer.shutdown
-        rescue Net::SSH::AuthenticationFailed => e; exception_info = {e: e, t: 'SSH', security: true}
-        rescue OpenSSL::SSL::SSLError => e;         exception_info = {e: e, t: 'SSL'}
-        rescue Cli::BadArgument => e;               exception_info = {e: e, t: 'Argument', usage: true}
-        rescue Cli::NoSuchIdentifier => e;          exception_info = {e: e, t: 'Identifier'}
-        rescue Cli::Error => e;                     exception_info = {e: e, t: 'Tool', usage: true}
-        rescue Transfer::Error => e;                exception_info = {e: e, t: 'Transfer'}
-        rescue RestCallError => e;                  exception_info = {e: e, t: 'Rest'}
-        rescue SocketError => e;                    exception_info = {e: e, t: 'Network'}
-        rescue StandardError => e;                  exception_info = {e: e, t: "Other(#{e.class.name})", debug: true}
-        rescue Interrupt => e;                      exception_info = {e: e, t: 'Interruption', debug: true}
-        end
-        # cleanup file list files
-        TempFileManager.instance.cleanup
-        # 1- processing of error condition
-        unless exception_info.nil?
-          Log.log.warn(exception_info[:e].message) if Log.instance.logger_type.eql?(:syslog) && exception_info[:security]
-          formatter.display_message(:error, "#{Formatter::ERROR_FLASH} #{exception_info[:t]}: #{exception_info[:e].message}")
-          formatter.display_message(:error, 'Use option -h to get help.') if exception_info[:usage]
-          # Is that a known error condition with proposal for remediation ?
-          Hints.hint_for(exception_info[:e], formatter)
-        end
-        # 2- processing of command not processed (due to exception or bad command line)
-        if execute_command || @option_show_config
-          options.final_errors.each do |msg|
-            formatter.display_message(:error, "#{Formatter::ERROR_FLASH} Argument: #{msg}")
-            # add code as exception if there is not already an error
-            exception_info = {e: Exception.new(msg), t: 'UnusedArg'} if exception_info.nil?
-          end
-        end
-        # 3- in case of error, fail the process status
-        unless exception_info.nil?
-          # show stack trace in debug mode
-          raise exception_info[:e] if Log.log.debug?
-          # else give hint and exit
-          formatter.display_message(:error, 'Use --log-level=debug to get more details.') if exception_info[:debug]
-          Process.exit(1)
-        end
-        return nil
-      end
     end
   end
 end

data/lib/aspera/cli/manager.rb

@@ -21,7 +21,7 @@ module Aspera
         @option_name = option_name
         @has_writer = @object.respond_to?(writer_method)
         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}"}
+        Aspera.assert(@object.respond_to?(@method)){"#{object} does not respond to #{method_name}"}
       end
 
       def value
@@ -48,7 +48,7 @@ module Aspera
       BOOLEAN_SIMPLE = %i[no yes].freeze
       FALSE_VALUES = [BOOLEAN_SIMPLE.first, false].freeze
       TRUE_VALUES = [BOOLEAN_SIMPLE.last, true].freeze
-      BOOLEAN_VALUES = [TRUE_VALUES, FALSE_VALUES].flatten.freeze
+      BOOLEAN_VALUES = (TRUE_VALUES + FALSE_VALUES).freeze
 
       # option name separator on command line
       OPTION_SEP_LINE = '-'
@@ -76,9 +76,9 @@ module Aspera
         # find shortened string value in allowed symbol list
         def get_from_list(short_value, descr, allowed_values)
           # we accept shortcuts
-          matching_exact = allowed_values.select{|i| i.to_s.eql?(short_value)}
+          matching_exact = allowed_values.select{ |i| i.to_s.eql?(short_value)}
           return matching_exact.first if matching_exact.length == 1
-          matching = allowed_values.select{|i| i.to_s.start_with?(short_value)}
+          matching = allowed_values.select{ |i| i.to_s.start_with?(short_value)}
           multi_choice_assert(!matching.empty?, "unknown value for #{descr}: #{short_value}", allowed_values)
           multi_choice_assert(matching.length.eql?(1), "ambiguous shortcut for #{descr}: #{short_value}", matching)
           return enum_to_bool(matching.first) if allowed_values.eql?(BOOLEAN_VALUES)
@@ -89,7 +89,7 @@ module Aspera
         # @param error_msg [String] error message
         # @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
+          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
@@ -112,8 +112,8 @@ module Aspera
           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)}
+              "#{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
@@ -182,7 +182,7 @@ module Aspera
 
       # @param descr [String] description for help
       # @param mandatory [Boolean] if true, raise error if option not set
-      # @param multiple [Boolean] if true, return remaining arguments
+      # @param multiple [Boolean] if true, return remaining arguments (Array)
       # @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
@@ -202,13 +202,13 @@ module Aspera
           if !@unprocessed_cmd_line_arguments.empty?
             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)}
+            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)
+            values = values.first if multiple && 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?
-              values = values.map{|v|self.class.get_from_list(v, descr, allowed_values)}
+              values = values.map{ |v| self.class.get_from_list(v, descr, allowed_values)}
             end
             multiple ? values : values.first
           elsif !default.nil? then default
@@ -309,7 +309,7 @@ module Aspera
         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"}
-        Aspera.assert(!['hash', 'extended value'].any?{|s|description.downcase.include?(s) }){"#{option_symbol} shall use :types"}
+        Aspera.assert(!['hash', 'extended value'].any?{ |s| description.downcase.include?(s)}){"#{option_symbol} shall use :types"}
         opt = @declared_options[option_symbol] = {
           read_write: handler.nil? ? :value : :accessor,
           # by default passwords and secrets are sensitive, else specify when declaring the option
@@ -339,7 +339,7 @@ module Aspera
           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, where: 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
@@ -348,14 +348,14 @@ module Aspera
           # this option value must be a symbol
           opt[:values] = values
           value = get_option(option_symbol)
-          help_values = values.map{|i|i.eql?(value) ? highlight_current(i) : i}.join(', ')
+          help_values = values.map{ |i| i.eql?(value) ? highlight_current(i) : i}.join(', ')
           if values.eql?(BOOLEAN_VALUES)
-            help_values = BOOLEAN_SIMPLE.map{|i|(i.eql?(:yes) && value) || (i.eql?(:no) && !value) ? highlight_current(i) : i}.join(', ')
+            help_values = BOOLEAN_SIMPLE.map{ |i| (i.eql?(:yes) && value) || (i.eql?(:no) && !value) ? highlight_current(i) : i}.join(', ')
           end
           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), where: 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|
@@ -478,7 +478,7 @@ module Aspera
       def prompt_user_input_in_list(prompt, sym_list)
         loop do
           input = prompt_user_input(prompt).to_sym
-          if sym_list.any?{|a|a.eql?(input)}
+          if sym_list.any?{ |a| a.eql?(input)}
             return input
           else
             $stderr.puts("No such #{prompt}: #{input}, select one of: #{sym_list.join(', ')}")
@@ -522,7 +522,7 @@ module Aspera
       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)})
+        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)