aspera-cli 4.12.0 → 4.14.0

data/lib/aspera/cli/main.rb

@@ -31,7 +31,7 @@ module Aspera
       STATUS_FIELD = 'status'
 
       # for testing only
-      SELF_SIGNED_CERT = OpenSSL::SSL.const_get(:enon_yfirev.to_s.upcase.reverse)
+      SELF_SIGNED_CERT = OpenSSL::SSL.const_get(:enon_yfirev.to_s.upcase.reverse) # cspell: disable-line
 
       class << self
         # expect some list, but nothing to display
@@ -87,7 +87,7 @@ module Aspera
         if @option_insecure
           url = http.inspect.gsub(/^[^ ]* /, 'https://').gsub(/ [^ ]*$/, '')
           if !@ssl_warned_urls.include?(url)
-            @formatter.display_message(:error, "#{WARNING_FLASH} ignoring certificate for: #{url}. Do not use unsafe certificates in production.")
+            @formatter.display_message(:error, "#{WARNING_FLASH} ignoring certificate for: #{url}. Do not deactivate certificate verification in production.")
             @ssl_warned_urls.push(url)
           end
           http.verify_mode = SELF_SIGNED_CERT
@@ -187,31 +187,25 @@ module Aspera
       # define header for manual
       def init_global_options
         Log.log.debug('init_global_options')
-        @opt_mgr.add_opt_switch(:help, '-h', 'Show this message.') { @option_help = true }
-        @opt_mgr.add_opt_switch(:bash_comp, 'generate bash completion for command') { @bash_completion = true }
-        @opt_mgr.add_opt_switch(:show_config, 'Display parameters used for the provided action.') { @option_show_config = true }
-        @opt_mgr.add_opt_switch(:rest_debug, '-r', 'more debug for HTTP calls') { @option_rest_debug = true }
-        @opt_mgr.add_opt_switch(:version, '-v', 'display version') { @formatter.display_message(:data, Aspera::Cli::VERSION); Process.exit(0) } # rubocop:disable Style/Semicolon, Layout/LineLength
-        @opt_mgr.add_opt_switch(:warnings, '-w', 'check for language warnings') { $VERBOSE = true }
-        # handler must be set before declaration
-        @opt_mgr.set_obj_attr(:log_level, Log.instance, :level)
-        @opt_mgr.set_obj_attr(:logger, Log.instance, :logger_type)
-        @opt_mgr.set_obj_attr(:insecure, self, :option_insecure, :no)
-        @opt_mgr.set_obj_attr(:ui, self, :option_ui)
-        @opt_mgr.set_obj_attr(:http_options, self, :option_http_options)
-        @opt_mgr.set_obj_attr(:log_secrets, SecretHider, :log_secrets)
-        @opt_mgr.set_obj_attr(:cache_tokens, self, :option_cache_tokens)
-        @opt_mgr.add_opt_list(:ui, OpenApplication.user_interfaces, 'method to start browser')
-        @opt_mgr.add_opt_list(:log_level, Log.levels, 'Log level')
-        @opt_mgr.add_opt_list(:logger, Log::LOG_TYPES, 'logging method')
-        @opt_mgr.add_opt_simple(:lock_port, 'prevent dual execution of a command, e.g. in cron')
-        @opt_mgr.add_opt_simple(:http_options, 'options for http socket (extended value)')
-        @opt_mgr.add_opt_boolean(:insecure, 'do not validate HTTPS certificate')
-        @opt_mgr.add_opt_boolean(:once_only, 'process only new items (some commands)')
-        @opt_mgr.add_opt_boolean(:log_secrets, 'show passwords in logs')
-        @opt_mgr.add_opt_boolean(:cache_tokens, 'save and reuse Oauth tokens')
-        @opt_mgr.set_option(:ui, OpenApplication.default_gui_mode)
-        @opt_mgr.set_option(:once_only, false)
+        @opt_mgr.declare(:help, 'Show this message', values: :none, short: 'h') { @option_help = true }
+        @opt_mgr.declare(:bash_comp, 'Generate bash completion for command', values: :none) { @bash_completion = true }
+        @opt_mgr.declare(:show_config, 'Display parameters used for the provided action', values: :none) { @option_show_config = true }
+        @opt_mgr.declare(:rest_debug, 'More debug for HTTP calls (REST)', values: :none, short: 'r') { @option_rest_debug = true }
+        @opt_mgr.declare(:version, 'Display version', values: :none, short: 'v') { @formatter.display_message(:data, Aspera::Cli::VERSION); Process.exit(0) } # rubocop:disable Style/Semicolon, Layout/LineLength
+        @opt_mgr.declare(:warnings, 'Check for language warnings', values: :none, short: 'w') { $VERBOSE = true }
+        @opt_mgr.declare(
+          :ui, 'Method to start browser',
+          values: OpenApplication.user_interfaces,
+          handler: {o: self, m: :option_ui},
+          default: OpenApplication.default_gui_mode)
+        @opt_mgr.declare(:log_level, 'Log level', values: Log.levels, handler: {o: Log.instance, m: :level})
+        @opt_mgr.declare(:logger, 'Logging method', values: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
+        @opt_mgr.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron')
+        @opt_mgr.declare(:http_options, 'Options for http socket', types: Hash, handler: {o: self, m: :option_http_options})
+        @opt_mgr.declare(:insecure, 'Do not validate HTTPS certificate', values: :bool, handler: {o: self, m: :option_insecure}, default: :no)
+        @opt_mgr.declare(:once_only, 'Process only new items (some commands)', values: :bool, default: false)
+        @opt_mgr.declare(:log_secrets, 'Show passwords in logs', values: :bool, handler: {o: SecretHider, m: :log_secrets})
+        @opt_mgr.declare(:cache_tokens, 'Save and reuse Oauth tokens', values: :bool, handler: {o: self, m: :option_cache_tokens})
         # parse declared options
         @opt_mgr.parse_options!
       end
@@ -335,6 +329,7 @@ module Aspera
           # finish
           @plugin_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 CliBadArgument => e;                 exception_info = {e: e, t: 'Argument', usage: true}
         rescue CliNoSuchId => e;                    exception_info = {e: e, t: 'Identifier'}
         rescue CliError => e;                       exception_info = {e: e, t: 'Tool', usage: true}
@@ -351,10 +346,15 @@ module Aspera
           Log.log.warn(exception_info[:e].message) if Aspera::Log.instance.logger_type.eql?(:syslog) && exception_info[:security]
           @formatter.display_message(:error, "#{ERROR_FLASH} #{exception_info[:t]}: #{exception_info[:e].message}")
           @formatter.display_message(:error, 'Use option -h to get help.') if exception_info[:usage]
+          # Provide hint on FASP errors
           if exception_info[:e].is_a?(Fasp::Error) && exception_info[:e].message.eql?('Remote host is not who we expected')
             @formatter.display_message(:error, "For this specific error, refer to:\n"\
               "#{SRC_URL}#error-remote-host-is-not-who-we-expected\nAdd this to arguments:\n--ts=@json:'{\"sshfp\":null}'")
           end
+          # Provide hint on SSL errors
+          if exception_info[:e].is_a?(OpenSSL::SSL::SSLError) && ['does not match the server certificate'].any?{|m|exception_info[:e].message.include?(m)}
+            @formatter.display_message(:error, "You can ignore SSL errors with option:\n--insecure=yes")
+          end
         end
         # 2- processing of command not processed (due to exception or bad command line)
         if execute_command || @option_show_config

data/lib/aspera/cli/manager.rb

@@ -2,6 +2,7 @@
 
 require 'aspera/colors'
 require 'aspera/log'
+require 'aspera/secret_hider'
 require 'aspera/cli/extended_value'
 require 'optparse'
 require 'io/console'
@@ -52,9 +53,9 @@ module Aspera
       # option name separator on command line
       OPTION_SEP_LINE = '-'
       # option name separator in code (symbol)
-      OPTION_SEP_NAME = '_'
+      OPTION_SEP_SYMB = '_'
 
-      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_NAME
+      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMB
 
       class << self
         def enum_to_bool(enum)
@@ -81,6 +82,15 @@ module Aspera
         def bad_arg_message_multi(error_msg, choices)
           return [error_msg, 'Use:'].concat(choices.map{|c|"- #{c}"}.sort).join("\n")
         end
+
+        # change option name with dash to name with underscore
+        def option_line_to_name(name)
+          return name.gsub(OPTION_SEP_LINE, OPTION_SEP_SYMB)
+        end
+
+        def option_name_to_line(name)
+          return "--#{name.to_s.gsub(OPTION_SEP_SYMB, OPTION_SEP_LINE)}"
+        end
       end
 
       attr_reader :parser
@@ -94,7 +104,7 @@ module Aspera
         @unprocessed_cmd_line_options = []
         # a copy of all initial options
         @initial_cli_options = []
-        # option description: key = option symbol, value=hash, :type, :accessor, :value, :accepted
+        # option description: key = option symbol, value=hash, :read_write, :accessor, :value, :accepted
         @declared_options = {}
         # do we ask missing options and arguments to user ?
         @ask_missing_mandatory = false # STDIN.isatty
@@ -108,7 +118,7 @@ module Aspera
         @parser = OptionParser.new
         @parser.program_name = program_name
         # options can also be provided by env vars : --param-name -> ASCLI_PARAM_NAME
-        env_prefix = program_name.upcase + OPTION_SEP_NAME
+        env_prefix = program_name.upcase + OPTION_SEP_SYMB
         ENV.each do |k, v|
           if k.start_with?(env_prefix)
             @unprocessed_env.push([k[env_prefix.length..-1].downcase.to_sym, v])
@@ -121,10 +131,8 @@ module Aspera
         unless argv.nil?
           @parser.separator('')
           @parser.separator('OPTIONS: global')
-          set_obj_attr(:interactive, self, :ask_missing_mandatory)
-          set_obj_attr(:ask_options, self, :ask_missing_optional)
-          add_opt_boolean(:interactive, 'use interactive input of missing params')
-          add_opt_boolean(:ask_options, 'ask even optional options')
+          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!
           process_options = true
           until argv.empty?
@@ -144,21 +152,20 @@ module Aspera
         Log.log.debug{"add_cmd_line_options:commands/args=#{@unprocessed_cmd_line_arguments},options=#{@unprocessed_cmd_line_options}".red}
       end
 
-      def get_next_command(command_list); return get_next_argument('command', expected: command_list); end
-
       # @param expected is
       #    - Array of allowed value (single value)
       #    - :multiple for remaining values
       #    - :single for a single unconstrained value
       # @param mandatory true/false
       # @param type expected class for result
+      # @param aliases list of aliases for the value
       # @return value, list or nil
-      def get_next_argument(descr, expected: :single, mandatory: true, type: nil)
+      def get_next_argument(descr, expected: :single, mandatory: true, type: nil, aliases: nil, default: nil)
         unless type.nil?
           raise 'internal: type must be a Class' unless type.is_a?(Class)
           descr = "#{descr} (#{type})"
         end
-        result = nil
+        result = default
         if !@unprocessed_cmd_line_arguments.empty?
           # there are values
           case expected
@@ -170,66 +177,37 @@ module Aspera
             if result.length.eql?(1) && result.first.is_a?(Array)
               result = result.first
             end
+          when Array
+            allowed_values = [].concat(expected)
+            allowed_values.concat(aliases.keys) unless aliases.nil?
+            raise "internal error: only symbols allowed: #{allowed_values}" unless allowed_values.all?(Symbol)
+            result = self.class.get_from_list(@unprocessed_cmd_line_arguments.shift, descr, allowed_values)
           else
-            result = self.class.get_from_list(@unprocessed_cmd_line_arguments.shift, descr, expected)
+            raise 'internal error'
           end
         elsif mandatory
           # no value provided
           result = get_interactive(:argument, descr, expected: expected)
         end
         Log.log.debug{"#{descr}=#{result}"}
+        result = aliases[result] if !aliases.nil? && aliases.key?(result)
         raise "argument shall be #{type.name}" unless type.nil? || result.is_a?(type)
         return result
       end
 
-      # declare option of type :accessor, or :value
-      def declare_option(option_symbol, type)
-        Log.log.debug{"declare_option: #{option_symbol}: #{type}: skip=#{@declared_options.key?(option_symbol)}".green}
-        if @declared_options.key?(option_symbol)
-          raise "INTERNAL ERROR: option #{option_symbol} already declared. only accessor can be re-declared and ignored" \
-          unless @declared_options[option_symbol][:type].eql?(:accessor)
-          return
-        end
-        @declared_options[option_symbol] = {type: type}
-        # by default passwords and secrets are sensitive, else specify when declaring the option
-        @declared_options[option_symbol][:sensitive] = true if !%w[password secret key].select{|i| option_symbol.to_s.end_with?(i)}.empty?
-      end
-
-      # define option with handler
-      def set_obj_attr(option_symbol, object, attr_symb, default_value=nil)
-        Log.log.debug{"set attr obj #{option_symbol} (#{object},#{attr_symb})"}
-        declare_option(option_symbol, :accessor)
-        @declared_options[option_symbol][:accessor] = AttrAccessor.new(object, attr_symb)
-        set_option(option_symbol, default_value, 'default obj attr') if !default_value.nil?
-      end
-
-      # set an option value by name, either store value or call handler
-      def set_option(option_symbol, value, where='default')
-        if !@declared_options.key?(option_symbol)
-          Log.log.debug{"set unknown option: #{option_symbol}"}
-          raise 'ERROR: cannot set undeclared option'
-          # declare_option(option_symbol)
-        end
-        value = ExtendedValue.instance.evaluate(value)
-        value = Manager.enum_to_bool(value) if @declared_options[option_symbol][:values].eql?(BOOLEAN_VALUES)
-        Log.log.debug{"(#{@declared_options[option_symbol][:type]}/#{where}) set #{option_symbol}=#{value}"}
-        case @declared_options[option_symbol][:type]
-        when :accessor
-          @declared_options[option_symbol][:accessor].value = value
-        when :value
-          @declared_options[option_symbol][:value] = value
-        else # nil or other
-          raise 'error'
-        end
-      end
+      def get_next_command(command_list, aliases: nil); return get_next_argument('command', expected: command_list, aliases: aliases); end
 
-      # get an option value by name
-      # either return value or call handler, can return nil
+      # Get an option value by name
+      # either return value or calls handler, can return nil
       # ask interactively if requested/required
-      def get_option(option_symbol, is_type: :optional)
+      # @param mandatory [Boolean] if true, raise error if option not set
+      # @param allowed_types [Array] list of allowed types
+      def get_option(option_symbol, mandatory: false, allowed_types: nil)
+        allowed_types = [allowed_types] if allowed_types.is_a?(Class)
+        raise 'Internal Error: allowed_types must be an Array of Class or a Class' unless allowed_types.nil? || allowed_types.is_a?(Array)
         result = nil
         if @declared_options.key?(option_symbol)
-          case @declared_options[option_symbol][:type]
+          case @declared_options[option_symbol][:read_write]
           when :accessor
             result = @declared_options[option_symbol][:accessor].value
           when :value
@@ -237,15 +215,15 @@ module Aspera
           else
             raise 'unknown type'
           end
-          Log.log.debug{"(#{@declared_options[option_symbol][:type]}) get #{option_symbol}=#{result}"}
+          Log.log.debug{"(#{@declared_options[option_symbol][:read_write]}) get #{option_symbol}=#{result}"}
         end
         # do not fail for manual generation if option mandatory but not set
-        result = '' if result.nil? && is_type.eql?(:mandatory) && !@fail_on_missing_mandatory
+        result = '' if result.nil? && mandatory && !@fail_on_missing_mandatory
         # Log.log.debug{"interactive=#{@ask_missing_mandatory}"}
         if result.nil?
           if !@ask_missing_mandatory
-            raise CliBadArgument, "Missing mandatory option: #{option_symbol}" if is_type.eql?(:mandatory)
-          elsif @ask_missing_optional || is_type.eql?(:mandatory)
+            raise CliBadArgument, "Missing mandatory option: #{option_symbol}" if mandatory
+          elsif @ask_missing_optional || mandatory
             # ask_missing_mandatory
             expected = :single
             # print "please enter: #{option_symbol.to_s}"
@@ -256,72 +234,117 @@ module Aspera
             set_option(option_symbol, result, 'interactive')
           end
         end
+        raise "option #{option_symbol} is #{result.class} but must be one of #{allowed_types}" unless \
+          !mandatory || allowed_types.nil? || allowed_types.any? { |t|result.is_a?(t)}
         return result
       end
 
-      # param must be hash
-      def add_option_preset(preset_hash, op: :push)
-        Log.log.debug{"add_option_preset=#{preset_hash}"}
-        raise "internal error: setting default with no hash: #{preset_hash.class}" if !preset_hash.is_a?(Hash)
-        # incremental override
-        preset_hash.each{|k, v|@unprocessed_defaults.send(op, [k.to_sym, v])}
-      end
-
-      # define an option with restricted values
-      def add_opt_list(option_symbol, values, help, *on_args)
-        declare_option(option_symbol, :value)
-        Log.log.debug{"add_opt_list #{option_symbol}"}
-        on_args.unshift(symbol_to_option(option_symbol, 'ENUM'))
-        # this option value must be a symbol
-        @declared_options[option_symbol][:values] = values
-        value = get_option(option_symbol)
-        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(', ')
+      # set an option value by name, either store value or call handler
+      def set_option(option_symbol, value, where='code override')
+        raise CliBadArgument, "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 = Manager.enum_to_bool(value) if attributes[:values].eql?(BOOLEAN_VALUES)
+        Log.log.debug{"(#{attributes[:read_write]}/#{where}) set #{option_symbol}=#{value}"}
+        case attributes[:read_write]
+        when :accessor
+          attributes[:accessor].value = value
+        when :value
+          attributes[:value] = value
+        else # nil or other
+          raise 'error'
         end
-        on_args.push(values)
-        on_args.push("#{help}: #{help_values}")
-        Log.log.debug{"on_args=#{on_args}"}
-        @parser.on(*on_args){|v|set_option(option_symbol, self.class.get_from_list(v.to_s, help, values), 'cmdline')}
-      end
-
-      def add_opt_boolean(option_symbol, help, *on_args)
-        add_opt_list(option_symbol, BOOLEAN_VALUES, help, *on_args)
-        # if default was defined for obj, it may still be enum (yes/no) instead of boolean
-        default_value = get_option(option_symbol)
-        set_option(option_symbol, default_value, 'opt boolean') unless default_value.nil?
-      end
-
-      # define an option with open values
-      def add_opt_simple(option_symbol, *on_args)
-        declare_option(option_symbol, :value)
-        Log.log.debug{"add_opt_simple #{option_symbol}"}
-        on_args.unshift(symbol_to_option(option_symbol, 'VALUE'))
-        Log.log.debug{"on_args=#{on_args}"}
-        @parser.on(*on_args) { |v| set_option(option_symbol, v, 'cmdline') }
       end
 
-      # define an option with date format
-      def add_opt_date(option_symbol, *on_args)
-        declare_option(option_symbol, :value)
-        Log.log.debug{"add_opt_date #{option_symbol}"}
-        on_args.unshift(symbol_to_option(option_symbol, 'DATE'))
-        Log.log.debug{"on_args=#{on_args}"}
-        @parser.on(*on_args) do |v|
-          case v
-          when 'now' then set_option(option_symbol, Manager.time_to_string(Time.now), 'cmdline')
-          when /^-([0-9]+)h/ then set_option(option_symbol, Manager.time_to_string(Time.now - (Regexp.last_match(1).to_i * 3600)), 'cmdline')
-          else set_option(option_symbol, v, 'cmdline')
+      # declare an option
+      # @param option_symbol [Symbol] option name
+      # @param description [String] description for help
+      # @param handler [Hash] handler for option value: keys: o (object) and m (method)
+      # @param default [Object] default value
+      # @param values [nil, Array, :bool, :date, :none] list of allowed values, :bool for true/false, :date for dates, :none for on/off switch
+      # @param short [String] short option name
+      # @param coerce [Class] one of the coerce types accepted par option parser
+      # @param types [Class, Array] accepted value type(s)
+      # @param block [Proc] block to execute when option is found
+      def declare(option_symbol, description, handler: nil, default: nil, values: nil, short: nil, coerce: nil, types: nil, deprecation: nil, &block)
+        raise "INTERNAL ERROR: #{option_symbol} already declared" if @declared_options.key?(option_symbol)
+        raise "INTERNAL ERROR: #{option_symbol} ends with dot" unless description[-1] != '.'
+        raise "INTERNAL ERROR: #{option_symbol} does not start with capital" unless description[0] == description[0].upcase
+        raise "INTERNAL ERROR: #{option_symbol} shall use :types" if description.downcase.include?('hash') || description.downcase.include?('extended value')
+        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, '')
+        }
+        if !types.nil?
+          types = [types] unless types.is_a?(Array)
+          raise "INTERNAL ERROR: types must be classes: #{types}" unless types.all?(Class)
+          opt[:types] = types
+          description = "#{description} (#{types.map(&:name).join(', ')})"
+        end
+        if deprecation
+          opt[:deprecation] = deprecation
+          description = "#{description} (#{'deprecated'.blue}: #{deprecation})"
+        end
+        Log.log.debug{"declare: #{option_symbol}: #{opt[:read_write]}".green}
+        if opt[:read_write].eql?(:accessor)
+          raise 'internal error' unless handler.is_a?(Hash)
+          raise 'internal error' unless handler.keys.sort.eql?(%i[m o])
+          Log.log.debug{"set attr obj #{option_symbol} (#{handler[:o]},#{handler[:m]})"}
+          opt[:accessor] = AttrAccessor.new(handler[:o], handler[:m])
+        end
+        set_option(option_symbol, default, '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, 'cmdline') }
+        when Array, :bool
+          if values.eql?(:bool)
+            values = BOOLEAN_VALUES
+            set_option(option_symbol, Manager.enum_to_bool(default), 'default') unless default.nil?
+          end
+          # 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(', ')
+          if values.eql?(BOOLEAN_VALUES)
+            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), 'cmdline')}
+        when :date
+          on_args.push(symbol_to_option(option_symbol, 'DATE'))
+          @parser.on(*on_args) do |v|
+            time_string = case v
+            when 'now' then Manager.time_to_string(Time.now)
+            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, 'cmdline')
           end
+        when :none
+          raise "internal error: missing block for #{option_symbol}" if block.nil?
+          on_args.push(symbol_to_option(option_symbol, nil))
+          on_args.push("-#{short}") if short.is_a?(String)
+          @parser.on(*on_args, &block)
+        else raise 'internal error'
         end
+        Log.log.debug{"on_args=#{on_args}"}
       end
 
-      # define an option without value
-      def add_opt_switch(option_symbol, *on_args, &block)
-        Log.log.debug{"add_opt_on #{option_symbol}"}
-        on_args.unshift(symbol_to_option(option_symbol, nil))
-        Log.log.debug{"on_args=#{on_args}"}
-        @parser.on(*on_args, &block)
+      # Adds each of the keys of specified hash as an option
+      # @param preset_hash [Hash] hash of options to add
+      def add_option_preset(preset_hash, op: :push)
+        Log.log.debug{"add_option_preset=#{preset_hash}"}
+        raise "internal error: default expects Hash: #{preset_hash.class}" unless preset_hash.is_a?(Hash)
+        # incremental override
+        preset_hash.each{|k, v|@unprocessed_defaults.send(op, [k.to_sym, v])}
       end
 
       # check if there were unprocessed values to generate error
@@ -337,7 +360,7 @@ module Aspera
         return result
       end
 
-      # get all original options  on command line used to generate a config in config file
+      # get all original options on command line used to generate a config in config file
       def get_options_table(remove_from_remaining: true)
         result = {}
         @initial_cli_options.each do |optionval|
@@ -347,7 +370,7 @@ module Aspera
           when /^--([^=]+)=(.*)$/
             name = Regexp.last_match(1)
             value = Regexp.last_match(2)
-            name.gsub!(OPTION_SEP_LINE, OPTION_SEP_NAME)
+            name.gsub!(OPTION_SEP_LINE, OPTION_SEP_SYMB)
             value = ExtendedValue.instance.evaluate(value)
             Log.log.debug{"option #{name}=#{value}"}
             result[name] = value
@@ -429,7 +452,7 @@ module Aspera
 
       # generate command line option from option symbol
       def symbol_to_option(symbol, opt_val)
-        result = '--' + symbol.to_s.gsub(OPTION_SEP_NAME, OPTION_SEP_LINE)
+        result = '--' + symbol.to_s.gsub(OPTION_SEP_SYMB, OPTION_SEP_LINE)
         result = result + '=' + opt_val unless opt_val.nil?
         return result
       end