aspera-cli 4.23.0 → 4.24.1

data/lib/aspera/cli/main.rb

@@ -16,10 +16,14 @@ require 'aspera/assert'
 module Aspera
   module Cli
     # Global objects shared with plugins
-    class Objects
-      MEMBERS = %i[options transfer config formatter persistency].freeze
+    class Context
+      MEMBERS = %i[options transfer config formatter persistency man_header].freeze
       attr_accessor(*MEMBERS)
 
+      def initialize
+        @man_header = true
+      end
+
       def validate
         MEMBERS.each do |i|
           Aspera.assert(instance_variable_defined?(:"@#{i}"))
@@ -42,19 +46,42 @@ module Aspera
       STATUS_FIELD = 'status'
       COMMAND_CONFIG = :config
       COMMAND_HELP = :help
+      # types that go to result of type = text
       SCALAR_TYPES = [String, Integer, Symbol].freeze
+      USER_INTERFACES = %i[text graphical].freeze
 
-      private_constant :COMMAND_CONFIG, :COMMAND_HELP, :SCALAR_TYPES
+      private_constant :COMMAND_CONFIG, :COMMAND_HELP, :SCALAR_TYPES, :USER_INTERFACES
 
       class << self
-        # expect some list, but nothing to display
-        def result_empty; return {type: :empty, data: :nil}; end
+        # early debug for parser
+        # Note: does not accept shortcuts
+        def early_debug_setup(argv)
+          Log.instance.program_name = Info::CMD_NAME
+          argv.each do |arg|
+            case arg
+            when '--' then break
+            when /^--log-level=(.*)/ then Log.instance.level = Regexp.last_match(1).to_sym
+            when /^--logger=(.*)/ then Log.instance.logger_type = Regexp.last_match(1).to_sym
+            end
+          rescue => e
+            $stderr.puts("Error: #{e}") # rubocop:disable Style/StderrPuts
+            Process.exit(1)
+          end
+        end
 
-        # nothing expected
-        def result_nothing; return {type: :nothing, data: :nil}; end
+        def result_special(how); {type: :special, data: how}; end
 
+        # Expect some list, but nothing to display
+        def result_empty; result_special(:empty); end
+
+        # Nothing expected
+        def result_nothing; result_special(:nothing); end
+
+        # Result is some status, such as "complete", "deleted"...
+        # @param status [String] The status
         def result_status(status); return {type: :status, data: status}; end
 
+        # text result coming from command result
         def result_text(data); return {type: :text, data: data}; end
 
         def result_success; return result_status('complete'); end
@@ -68,7 +95,7 @@ module Aspera
           return Main.result_nothing
         end
 
-        # used when one command executes several transfer jobs (each job being possibly multi session)
+        # Used when one command executes several transfer jobs (each job being possibly multi session)
         # @param status_table [Array] [{STATUS_FIELD=>[status array],...},...]
         # @return a status object suitable as command result
         # each element has a key STATUS_FIELD which contains the result of possibly multiple sessions
@@ -84,32 +111,40 @@ module Aspera
           return result_object_list(status_table)
         end
 
-        def result_image(blob, formatter:)
-          return Main.result_status(formatter.status_image(blob))
+        # Display image for that URL or directly blob
+        def result_image(url_or_blob)
+          return {type: :image, data: url_or_blob}
         end
 
+        # A single object, must be Hash
         def result_single_object(data, fields: nil)
           return {type: :single_object, data: data, fields: fields}
         end
 
+        # An Array of Hash
         def result_object_list(data, fields: nil, total: nil)
           return {type: :object_list, data: data, fields: fields, total: total}
         end
 
-        def result_value_list(data, name)
+        # A list of values
+        def result_value_list(data, name: 'id')
+          Aspera.assert_type(data, Array)
+          Aspera.assert_type(name, String)
           return {type: :value_list, data: data, name: name}
         end
 
         # Determines type of result based on data
         def result_auto(data)
           case data
+          when NilClass
+            return result_special(:null)
           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?
+            return result_value_list(data, name: 'list') if unsupported_types.empty?
             Aspera.error_unexpected_value(unsupported_types){'list item types'}
           when *SCALAR_TYPES
             return result_text(data)
@@ -121,12 +156,11 @@ module Aspera
       # minimum initialization, no exception raised
       def initialize(argv)
         @argv = argv
-        early_debug_setup
-        Log.log.trace2{Log.dump(:argv, @argv)}
+        Log.dump(:argv, @argv, level: :trace2)
         @option_help = false
         @option_show_config = false
         @bash_completion = false
-        @env = Objects.new
+        @context = Context.new
       end
 
       # this is the main function called by initial script just after constructor
@@ -137,41 +171,39 @@ module Aspera
         execute_command = true
         # catch exceptions
         begin
-          init_agents_and_options
-          # find plugins, shall be after parse! ?
-          PluginFactory.instance.add_plugins_from_lookup_folders
+          init_agents_options_plugins
           # help requested without command ? (plugins must be known here)
-          exit_with_usage(true) if @option_help && @env.options.command_or_arg_empty?
+          show_usage if @option_help && @context.options.command_or_arg_empty?
           generate_bash_completion if @bash_completion
-          @env.config.periodic_check_newer_gem_version
+          @context.config.periodic_check_newer_gem_version
           command_sym =
-            if @option_show_config && @env.options.command_or_arg_empty?
+            if @option_show_config && @context.options.command_or_arg_empty?
               COMMAND_CONFIG
             else
-              @env.options.get_next_command(PluginFactory.instance.plugin_list.unshift(COMMAND_HELP))
+              @context.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
+          @context.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)
+            show_usage
           when COMMAND_CONFIG
-            command_plugin = @env.config
+            command_plugin = @context.config
           else
             # get plugin, set options, etc
             command_plugin = get_plugin_instance_with_options(command_sym)
             # parse plugin specific options
-            @env.options.parse_options!
+            @context.options.parse_options!
           end
           # help requested for current plugin
-          exit_with_usage(false) if @option_help
+          show_usage(all: 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)
+            @context.formatter.display_results(type: :single_object, data: @context.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)
+          lock_port = @context.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
@@ -183,18 +215,18 @@ module Aspera
               Log.log.warn{"Another instance is already running (#{e.message})."}
             end
           end
-          pid_file = @env.options.get_option(:pid_file)
+          pid_file = @context.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
+          @context.formatter.display_results(**command_plugin.execute_action) if execute_command
           # save config file if command modified it
-          @env.config.save_config_file_if_needed
+          @context.config.save_config_file_if_needed
           # finish
-          @env.transfer.shutdown
+          @context.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}
@@ -211,15 +243,15 @@ module Aspera
         # 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]
+          @context.formatter.display_message(:error, "#{Formatter::ERROR_FLASH} #{exception_info[:t]}: #{exception_info[:e].message}")
+          @context.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)
+          Hints.hint_for(exception_info[:e], @context.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}")
+          @context.options.final_errors.each do |msg|
+            @context.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
@@ -229,10 +261,36 @@ module Aspera
           # 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]
+          @context.formatter.display_message(:error, 'Use --log-level=debug to get more details.') if exception_info[:debug]
           Process.exit(1)
         end
-        return nil
+        return
+      end
+
+      def init_agents_options_plugins
+        init_agents_and_options
+        # find plugins, shall be after parse! ?
+        PluginFactory.instance.add_plugins_from_lookup_folders
+      end
+
+      def show_usage(all: true, exit: true)
+        # display main plugin options (+config)
+        @context.formatter.display_message(:error, @context.options.parser)
+        if all
+          @context.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
+            @context.options = Manager.new(Info::CMD_NAME)
+            @context.options.parser.banner = '' # remove default banner
+            get_plugin_instance_with_options(plugin_name_sym)
+            # display generated help for plugin options
+            @context.formatter.display_message(:error, @context.options.parser.help)
+          end
+        end
+        Process.exit(0) if exit
       end
 
       private
@@ -240,30 +298,34 @@ module Aspera
       # This can throw exception if there is a problem with the environment, needs to be caught by execute method
       def init_agents_and_options
         # create formatter, in case there is an exception, it is used to display.
-        @env.formatter = Formatter.new
+        @context.formatter = Formatter.new
         # create command line manager with arguments
-        @env.options = Manager.new(Info::CMD_NAME, @argv)
+        @context.options = Manager.new(Info::CMD_NAME, @argv)
         # formatter adds options
-        @env.formatter.declare_options(@env.options)
-        ExtendedValue.instance.default_decoder = @env.options.get_option(:struct_parser)
+        @context.formatter.declare_options(@context.options)
+        ExtendedValue.instance.default_decoder = @context.options.get_option(:struct_parser)
         # compare $0 with expected name
         current_prog_name = File.basename($PROGRAM_NAME)
-        @env.formatter.display_message(
+        @context.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)
+          "#{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
+        # do not display config commands if help is asked
+        @context.man_header = false
         # the Config plugin adds the @preset parser, so declare before TransferAgent which may use it
-        @env.config = Plugins::Config.new(broker: @env, man_header: false)
+        @context.config = Plugins::Config.new(context: @context)
+        @context.man_header = true
         # data persistency is set in config
-        Aspera.assert(@env.persistency){'missing persistency object'}
+        Aspera.assert(@context.persistency){'missing persistency object'}
         # the TransferAgent plugin may use the @preset parser
-        @env.transfer = TransferAgent.new(@env.options, @env.config)
+        @context.transfer = TransferAgent.new(@context.options, @context.config)
         # add commands for config plugin after all options have been added
-        @env.config.add_manual_header(false)
-        @env.validate
+        @context.config.add_manual_header(false)
+        @context.validate
         # set banner when all environment is created so that additional extended value modifiers are known, e.g. @preset
-        @env.options.parser.banner = app_banner
+        @context.options.parser.banner = app_banner
       end
 
       def app_banner
@@ -303,24 +365,29 @@ module Aspera
       # define header for manual
       def declare_global_options
         Log.log.debug('declare_global_options')
-        @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(
+        @context.options.declare(:help, 'Show this message', values: :none, short: 'h'){@option_help = true}
+        @context.options.declare(:bash_comp, 'Generate bash completion for command', values: :none){@bash_completion = true}
+        @context.options.declare(:show_config, 'Display parameters used for the provided action', values: :none){@option_show_config = true}
+        @context.options.declare(:version, 'Display version', values: :none, short: 'v'){@context.formatter.display_message(:data, Cli::VERSION); Process.exit(0)} # rubocop:disable Style/Semicolon
+        @context.options.declare(
           :ui, 'Method to start browser',
-          values: Environment::USER_INTERFACES,
-          handler: {o: Environment.instance, m: :url_method},
-          default: Environment.default_gui_mode)
-        @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)
+          values: USER_INTERFACES,
+          handler: {o: Environment.instance, m: :url_method}
+        )
+        @context.options.declare(
+          :invalid_characters, 'Replacement character and invalid filename characters',
+          handler: {o: Environment.instance, m: :file_illegal_characters}
+        )
+        @context.options.declare(:log_level, 'Log level', values: Log::LEVELS, handler: {o: Log.instance, m: :level})
+        @context.options.declare(:log_format, 'Log formatter', types: [Proc, Logger::Formatter, String], handler: {o: Log.instance, m: :formatter})
+        @context.options.declare(:logger, 'Logging method', values: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
+        @context.options.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron', coerce: Integer, types: Integer)
+        @context.options.declare(:once_only, 'Process only new items (some commands)', values: :bool, default: false)
+        @context.options.declare(:log_secrets, 'Show passwords in logs', values: :bool, handler: {o: SecretHider.instance, m: :log_secrets})
+        @context.options.declare(:clean_temp, 'Cleanup temporary files on exit', values: :bool, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
+        @context.options.declare(:pid_file, 'Write process identifier to file, delete on exit', types: String)
         # parse declared options
-        @env.options.parse_options!
+        @context.options.parse_options!
       end
 
       # @return the plugin instance, based on name
@@ -329,55 +396,19 @@ module Aspera
       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, broker: @env)
+        @context.config.add_plugin_default_preset(plugin_name_sym)
+        command_plugin = PluginFactory.instance.create(plugin_name_sym, context: @context)
         return command_plugin
       end
 
       def generate_bash_completion
-        if @env.options.get_next_argument('', multiple: true, mandatory: false).nil?
+        if @context.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
         Process.exit(0)
       end
-
-      def exit_with_usage(include_all_plugins)
-        Log.log.debug{"exit_with_usage(#{include_all_plugins})".bg_red}
-        # display main plugin options (+config)
-        @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
-            @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
-            @env.formatter.display_message(:error, @env.options.parser.help)
-          end
-        end
-        Process.exit(0)
-      end
-
-      # early debug for parser
-      # Note: does not accept shortcuts
-      def early_debug_setup
-        Log.instance.program_name = Info::CMD_NAME
-        @argv.each do |arg|
-          case arg
-          when '--' then break
-          when /^--log-level=(.*)/ then Log.instance.level = Regexp.last_match(1).to_sym
-          when /^--logger=(.*)/ then Log.instance.logger_type = Regexp.last_match(1).to_sym
-          end
-        rescue => e
-          $stderr.puts("Error: #{e}")
-        end
-      end
     end
   end
 end

data/lib/aspera/cli/manager.rb

@@ -54,14 +54,19 @@ module Aspera
       OPTION_SEP_LINE = '-'
       # option name separator in code (symbol)
       OPTION_SEP_SYMBOL = '_'
-      SOURCE_USER = 'cmdline' # cspell:disable-line
       OPTION_VALUE_SEPARATOR = '='
+      # an option like --a.b.c=d does: a={"b":{"c":ext_val(d)}}
+      # TODO: all Hash are additive, + way to reset Hash (e.g. --opt=@none:)
+      OPTION_HASH_SEPARATOR = '.'
+      # starts an option
       OPTION_PREFIX = '--'
+      # when this is alone, this stops option processing
       OPTIONS_STOP = '--'
+      SOURCE_USER = 'cmdline' # cspell:disable-line
 
       DEFAULT_PARSER_TYPES = [Array, Hash].freeze
 
-      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :SOURCE_USER
+      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :OPTION_VALUE_SEPARATOR, :OPTION_HASH_SEPARATOR, :OPTION_PREFIX, :OPTIONS_STOP, :SOURCE_USER, :DEFAULT_PARSER_TYPES
 
       class << self
         def enum_to_bool(enum)
@@ -75,6 +80,7 @@ module Aspera
 
         # find shortened string value in allowed symbol list
         def get_from_list(short_value, descr, allowed_values)
+          Aspera.assert_type(short_value, String)
           # we accept shortcuts
           matching_exact = allowed_values.select{ |i| i.to_s.eql?(short_value)}
           return matching_exact.first if matching_exact.length == 1
@@ -107,7 +113,7 @@ module Aspera
         # @param type_list [NilClass, Class, Array[Class]] accepted value type(s)
         # @param check_array [bool] set to true if it is a list of values to check
         def validate_type(what, descr, to_check, type_list, check_array: false)
-          return nil if type_list.nil?
+          return if type_list.nil?
           Aspera.assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}
           value_list = check_array ? to_check : [to_check]
           value_list.each do |value|
@@ -147,14 +153,13 @@ module Aspera
         # options can also be provided by env vars : --param-name -> ASCLI_PARAM_NAME
         env_prefix = program_name.upcase + OPTION_SEP_SYMBOL
         ENV.each do |k, v|
-          if k.start_with?(env_prefix)
-            @option_pairs_env[k[env_prefix.length..-1].downcase.to_sym] = v
-          end
+          @option_pairs_env[k[env_prefix.length..-1].downcase.to_sym] = v if k.start_with?(env_prefix)
         end
         Log.log.debug{"env=#{@option_pairs_env}".red}
         @unprocessed_cmd_line_options = []
         @unprocessed_cmd_line_arguments = []
         return if argv.nil?
+        # true until `--` is found (stop options)
         process_options = true
         until argv.empty?
           value = argv.shift
@@ -171,7 +176,7 @@ module Aspera
           end
         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}
+        Log.log.trace1{"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})
@@ -244,10 +249,9 @@ module Aspera
           result = attributes[:accessor].value
         when :value
           result = attributes[:value]
-        else
-          raise 'unknown type'
+        else Aspera.error_unexpected_value(attributes[:read_write]){'attribute read/write'}
         end
-        Log.log.debug{"(#{attributes[:read_write]}) get #{option_symbol}=#{result}"}
+        Log.log.trace1{"(#{attributes[:read_write]}) get #{option_symbol}=#{result}"}
         result = default if result.nil?
         # do not fail for manual generation if option mandatory but not set
         result = '' if result.nil? && mandatory && !@fail_on_missing_mandatory
@@ -259,9 +263,7 @@ module Aspera
             # ask_missing_mandatory
             accept_list = nil
             # print "please enter: #{option_symbol.to_s}"
-            if @declared_options.key?(option_symbol) && attributes.key?(:values)
-              accept_list = attributes[:values]
-            end
+            accept_list = attributes[:values] if @declared_options.key?(option_symbol) && attributes.key?(:values)
             result = get_interactive(option_symbol.to_s, option: true, accept_list: accept_list)
             set_option(option_symbol, result, where: 'interactive')
           end
@@ -282,15 +284,14 @@ module Aspera
         Log.log.warn("#{option_symbol}: Option is deprecated: #{attributes[:deprecation]}") if attributes[:deprecation]
         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}"}
+        Log.log.trace1{"(#{attributes[:read_write]}/#{where}) set #{option_symbol}=#{value}"}
         self.class.validate_type(:option, option_symbol, value, attributes[:types])
         case attributes[:read_write]
         when :accessor
           attributes[:accessor].value = value
         when :value
           attributes[:value] = value
-        else # nil or other
-          raise 'error'
+        else Aspera.error_unexpected_value(attributes[:read_write]){'attribute read/write'}
         end
       end
 
@@ -308,12 +309,12 @@ module Aspera
         Aspera.assert_type(option_symbol, Symbol)
         Aspera.assert(!@declared_options.key?(option_symbol)){"#{option_symbol} already declared"}
         Aspera.assert(description[-1] != '.'){"#{option_symbol} ends with dot"}
-        Aspera.assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with capital"}
+        Aspera.assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with an uppercase"}
         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
-          sensitive:  SecretHider.secret?(option_symbol, '')
+          sensitive:  SecretHider.instance.secret?(option_symbol, '')
         }
         if !types.nil?
           types = [types] unless types.is_a?(Array)
@@ -325,7 +326,7 @@ module Aspera
           opt[:deprecation] = deprecation
           description = "#{description} (#{'deprecated'.blue}: #{deprecation})"
         end
-        Log.log.debug{"declare: #{option_symbol}: #{opt[:read_write]}".green}
+        Log.log.trace1{"declare: #{option_symbol}: #{opt[:read_write]}".green}
         if opt[:read_write].eql?(:accessor)
           Aspera.assert_type(handler, Hash)
           Aspera.assert(handler.keys.sort.eql?(%i[m o]))
@@ -449,11 +450,20 @@ module Aspera
         unknown_options = []
         begin
           # remove known options one by one, exception if unknown
-          Log.log.trace1('before parse'.red)
+          Log.log.trace1('Before parse')
           @parser.parse!(@unprocessed_cmd_line_options)
-          Log.log.trace1('After parse'.red)
+          Log.log.trace1('After parse')
         rescue OptionParser::InvalidOption => e
           Log.log.trace1{"InvalidOption #{e}".red}
+          if (m = e.args.first.match(/^--([a-z\-]+)\.([^=]+)=(.+)$/))
+            option, path, raw_value = m.captures
+            option_sym = self.class.option_line_to_name(option).to_sym
+            if @declared_options.key?(option_sym)
+              value = path.split(OPTION_HASH_SEPARATOR).reverse.inject(smart_convert(raw_value)){ |v, k| {k => v}}
+              set_option(option_sym, value, where: 'dotted')
+              retry
+            end
+          end
           # save for later processing
           unknown_options.push(e.args.first)
           retry
@@ -467,7 +477,7 @@ module Aspera
         return $stdin.getpass("#{prompt}> ") if sensitive
         print("#{prompt}> ")
         line = $stdin.gets
-        raise 'Unexpected end of standard input' if line.nil?
+        Aspera.assert_type(line, String){'Unexpected end of standard input'}
         return line.chomp
       end
 
@@ -481,7 +491,7 @@ module Aspera
           if sym_list.any?{ |a| a.eql?(input)}
             return input
           else
-            $stderr.puts("No such #{prompt}: #{input}, select one of: #{sym_list.join(', ')}")
+            $stderr.puts("No such #{prompt}: #{input}, select one of: #{sym_list.join(', ')}") # rubocop:disable Style/StderrPuts
           end
         end
       end
@@ -521,10 +531,21 @@ 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)})
-          return ExtendedValue.instance.evaluate_with_default(value)
+      # Using dotted hash notation, convert value to bool, int, float or extended value
+      def smart_convert(value)
+        return true  if value == 'true'
+        return false if value == 'false'
+        Integer(value)
+      rescue ArgumentError
+        begin
+          Float(value)
+        rescue ArgumentError
+          evaluate_extended_value(value, nil)
         end
+      end
+
+      def evaluate_extended_value(value, types)
+        return ExtendedValue.instance.evaluate_with_default(value) if DEFAULT_PARSER_TYPES.include?(types) || (types.is_a?(Array) && types.all?{ |t| DEFAULT_PARSER_TYPES.include?(t)})
         return ExtendedValue.instance.evaluate(value)
       end
 
@@ -535,11 +556,12 @@ module Aspera
         return result
       end
 
+      # TODO: use formatter
       def highlight_current(value)
         $stdout.isatty ? value.to_s.red.bold : "[#{value}]"
       end
 
-      # try to evaluate options set ib batch
+      # try to evaluate options set in batch
       # @param unprocessed_options [Array] list of options to apply (key_sym,value)
       # @param where [String] where the options come from
       def consume_option_pairs(unprocessed_options, where)
@@ -548,9 +570,7 @@ module Aspera
         unprocessed_options.each do |k, v|
           if @declared_options.key?(k)
             # constrained parameters as string are revert to symbol
-            if @declared_options[k].key?(:values) && v.is_a?(String)
-              v = self.class.get_from_list(v, "#{k} in #{where}", @declared_options[k][:values])
-            end
+            v = self.class.get_from_list(v, "#{k} in #{where}", @declared_options[k][:values]) if @declared_options[k].key?(:values) && v.is_a?(String)
             options_to_set[k] = v
           else
             Log.log.trace1{"unprocessed: #{k}: #{v}"}