aspera-cli 4.16.0 → 4.17.0

data/lib/aspera/assert.rb

@@ -6,40 +6,40 @@ module Aspera
 
   class AssertError < StandardError
   end
-end
-
-class Object
-  def assert(assertion, info = nil, level: 2, exception_class: Aspera::AssertError)
-    raise Aspera::InternalError, 'bad assert: both info and block given' unless info.nil? || !block_given?
-    return if assertion
-    message = 'assertion failed'
-    info = yield if block_given?
-    message = "#{message}: #{info}" if info
-    message = "#{message}: #{caller(level..level).first}"
-    raise exception_class, message
-  end
+  class << self
+    # the block is executed in the context of the Aspera module
+    def assert(assertion, info = nil, level: 2, exception_class: AssertError)
+      raise InternalError, 'bad assert: both info and block given' unless info.nil? || !block_given?
+      return if assertion
+      message = 'assertion failed'
+      info = yield if block_given?
+      message = "#{message}: #{info}" if info
+      message = "#{message}: #{caller(level..level).first}"
+      raise exception_class, message
+    end
 
-  # assert that value has the given type
-  # @param value [Object] the value to check
-  # @param type [Class] the expected type
-  def assert_type(value, type, exception_class: Aspera::AssertError)
-    assert(value.is_a?(type), level: 3, exception_class: exception_class){"#{block_given? ? "#{yield}: " : nil}expecting #{type}, but have #{value.inspect}"}
-  end
+    # assert that value has the given type
+    # @param value [Object] the value to check
+    # @param type [Class] the expected type
+    def assert_type(value, type, exception_class: AssertError)
+      assert(value.is_a?(type), level: 3, exception_class: exception_class){"#{block_given? ? "#{yield}: " : nil}expecting #{type}, but have #{value.inspect}"}
+    end
 
-  # assert that value is one of the given values
-  def assert_values(value, values, exception_class: Aspera::AssertError)
-    assert(values.include?(value), level: 3, exception_class: exception_class) do
-      "#{block_given? ? "#{yield}: " : nil}expecting one of #{values.inspect}, but have #{value.inspect}"
+    # assert that value is one of the given values
+    def assert_values(value, values, exception_class: AssertError)
+      assert(values.include?(value), level: 3, exception_class: exception_class) do
+        "#{block_given? ? "#{yield}: " : nil}expecting one of #{values.inspect}, but have #{value.inspect}"
+      end
     end
-  end
 
-  # the line with this shall never be reached
-  def error_unreachable_line
-    raise Aspera::InternalError, "unreachable line reached: #{caller(2..2).first}"
-  end
+    # the line with this shall never be reached
+    def error_unreachable_line
+      raise InternalError, "unreachable line reached: #{caller(2..2).first}"
+    end
 
-  # the value is not one of the expected values
-  def error_unexpected_value(value, exception_class: Aspera::InternalError)
-    raise exception_class, "#{block_given? ? "#{yield}: " : nil}unexpected value: #{value.inspect}"
+    # the value is not one of the expected values
+    def error_unexpected_value(value, exception_class: InternalError)
+      raise exception_class, "#{block_given? ? "#{yield}: " : nil}unexpected value: #{value.inspect}"
+    end
   end
 end

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -6,22 +6,23 @@ require 'aspera/cli/plugin'
 module Aspera
   module Cli
     # base class for applications supporting basic authentication
-    class BasicAuthPlugin < Aspera::Cli::Plugin
+    class BasicAuthPlugin < Cli::Plugin
       class << self
-        @@basic_options_declared = false # rubocop:disable Style/ClassVars
-        def declare_options(options, force: false)
-          return if @@basic_options_declared && !force
-          @@basic_options_declared = true # rubocop:disable Style/ClassVars
+        #@@basic_options_declared = false # rubocop:disable Style/ClassVars
+        def declare_options(options) # , force: false
+          #return if @@basic_options_declared && !force
+          #@@basic_options_declared = true # rubocop:disable Style/ClassVars
           options.declare(:url, 'URL of application, e.g. https://faspex.example.com/aspera/faspex')
-          options.declare(:username, 'Username to log in')
+          options.declare(:username, "User's name to log in")
           options.declare(:password, "User's password")
           options.parse_options!
         end
       end
 
-      def initialize(env)
-        super(env)
-        BasicAuthPlugin.declare_options(options, force: env[:all_manuals])
+      def initialize(basic_options: true, **env)
+        super(**env)
+        # , force: env[:all_manuals]
+        BasicAuthPlugin.declare_options(options) if basic_options
       end
 
       # returns a Rest object with basic auth
@@ -38,7 +39,7 @@ module Aspera
       end
 
       def basic_auth_api(subpath=nil)
-        return Rest.new(basic_auth_params(subpath))
+        return Rest.new(**basic_auth_params(subpath))
       end
     end # BasicAuthPlugin
   end # Cli

data/lib/aspera/cli/extended_value.rb

@@ -78,7 +78,7 @@ module Aspera
       # add a new handler
       def set_handler(name, method)
         Log.log.debug{"setting handler for #{name}"}
-        assert_type(name, Symbol){'name'}
+        Aspera.assert_type(name, Symbol){'name'}
         @handlers[name] = method
       end
 

data/lib/aspera/cli/formatter.rb

@@ -20,7 +20,7 @@ module Aspera
 
       # General method
       def flatten(something)
-        assert_type(something, Hash)
+        Aspera.assert_type(something, Hash)
         @result = {}
         flatten_any(something, '')
         return @result
@@ -107,7 +107,7 @@ module Aspera
       class << self
         # Highlight special values
         def special(what, use_colors: $stdout.isatty)
-          result = "<#{what}>"
+          result = $stdout.isatty ? "<#{what}>" : "&lt;#{what}&gt;"
           if use_colors
             result = if %w[null empty].any?{|s|what.include?(s)}
               result.dim
@@ -158,7 +158,7 @@ module Aspera
       end
 
       def option_handler(option_symbol, operation, value=nil)
-        assert_values(operation, %i[set get])
+        Aspera.assert_values(operation, %i[set get])
         case operation
         when :set
           @options[option_symbol] = value
@@ -170,7 +170,7 @@ module Aspera
             end
           end
         when :get then return @options[option_symbol]
-        else error_unreachable_line
+        else Aspera.error_unreachable_line
         end
         nil
       end
@@ -199,7 +199,7 @@ module Aspera
         when :data then $stdout.puts(message) unless @options[:display].eql?(:error)
         when :info then $stdout.puts(message) if @options[:display].eql?(:info)
         when :error then $stderr.puts(message)
-        else error_unexpected_value(message_level)
+        else Aspera.error_unexpected_value(message_level)
         end
       end
 
@@ -232,7 +232,7 @@ module Aspera
           when Array then @options[:fields]
           when Regexp then return all_fields(data).select{|i|i.match(@options[:fields])}
           when Proc then return all_fields(data).select{|i|@options[:fields].call(i)}
-          else error_unexpected_value(@options[:fields])
+          else Aspera.error_unexpected_value(@options[:fields])
           end
         result = []
         until request.empty?
@@ -265,7 +265,7 @@ module Aspera
       # object_array: array of hash
       # fields: list of column names
       def display_table(object_array, fields)
-        assert(!fields.nil?){'missing fields parameter'}
+        Aspera.assert(!fields.nil?){'missing fields parameter'}
         case @options[:select]
         when Proc
           object_array.select!{|i|@options[:select].call(i)}
@@ -309,10 +309,10 @@ module Aspera
 
       # this method displays the results, especially the table format
       def display_results(results)
-        assert_type(results, Hash)
-        assert((results.keys - RESULT_PARAMS).empty?){"result unsupported key: #{results.keys - RESULT_PARAMS}"}
-        assert(results.key?(:type)){"result must have type (#{results})"}
-        assert(results.key?(:data) || %i[empty nothing].include?(results[:type])){'result must have data'}
+        Aspera.assert_type(results, Hash)
+        Aspera.assert((results.keys - RESULT_PARAMS).empty?){"result unsupported key: #{results.keys - RESULT_PARAMS}"}
+        Aspera.assert(results.key?(:type)){"result must have type (#{results})"}
+        Aspera.assert(results.key?(:data) || %i[empty nothing].include?(results[:type])){'result must have data'}
         Log.log.debug{"display_results: #{results[:data].class} #{results[:type]}"}
         display_item_count(results[:data].length, results[:total]) if results.key?(:total)
         SecretHider.deep_remove_secret(results[:data]) unless @options[:show_secrets] || @options[:display].eql?(:data)
@@ -336,8 +336,8 @@ module Aspera
           when :object_list, :single_object
             obj_list = results[:data]
             obj_list = [obj_list] if results[:type].eql?(:single_object)
-            assert_type(obj_list, Array)
-            assert(obj_list.all?(Hash)){"expecting Array of Hash: #{obj_list.inspect}"}
+            Aspera.assert_type(obj_list, Array)
+            Aspera.assert(obj_list.all?(Hash)){"expecting Array of Hash: #{obj_list.inspect}"}
             # :object_list is an array of hash tables, where key=colum name
             obj_list = obj_list.map{|obj|Flattener.new.flatten(obj)} if @options[:flat_hash]
             display_table(obj_list, compute_fields(obj_list, results[:fields]))

data/lib/aspera/cli/hints.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'aspera/fasp/error'
+require 'aspera/transfer/error'
 require 'aspera/rest'
 require 'aspera/log'
 require 'aspera/assert'
@@ -14,7 +14,7 @@ module Aspera
       # Well know issues that users may get
       ERROR_HINTS = [
         {
-          exception:   Fasp::Error,
+          exception:   Transfer::Error,
           match:       'Remote host is not who we expected',
           remediation: [
             'For this specific error, refer to:',
@@ -24,7 +24,7 @@ module Aspera
           ]
         },
         {
-          exception:   Aspera::RestCallError,
+          exception:   RestCallError,
           match:       /Signature has expired/,
           remediation: [
             'There is too much time difference between your computer and the server',
@@ -60,13 +60,13 @@ module Aspera
             matches = hint[:match]
             matches = [matches] unless matches.is_a?(Array)
             matches.each do |m|
-              assert_values(m.class, [String, Regexp])
+              Aspera.assert_values(m.class, [String, Regexp])
               case m
               when String
                 next unless message.eql?(m)
               when Regexp
                 next unless message.match?(m)
-              else error_unexpected_value(m)
+              else Aspera.error_unexpected_value(m)
               end
               remediation = hint[:remediation]
               remediation = [remediation] unless remediation.is_a?(Array)

data/lib/aspera/cli/main.rb

@@ -4,6 +4,7 @@ require 'aspera/cli/manager'
 require 'aspera/cli/formatter'
 require 'aspera/cli/plugins/config'
 require 'aspera/cli/extended_value'
+require 'aspera/cli/plugin_factory'
 require 'aspera/cli/transfer_agent'
 require 'aspera/cli/version'
 require 'aspera/cli/info'
@@ -19,6 +20,9 @@ module Aspera
     class Main
       # Plugins store transfer result using this key and use result_transfer_multiple()
       STATUS_FIELD = 'status'
+      CONF_PLUGIN_SYM = :config
+
+      private_constant :CONF_PLUGIN_SYM
 
       class << self
         # expect some list, but nothing to display
@@ -69,7 +73,7 @@ module Aspera
 
       # shortcuts helpers like in plugins
       %i[options transfer config formatter persistency].each do |name|
-        define_method(name){@agents[name]}
+        define_method(name){@plug_init[name]}
       end
 
       # =============================================================
@@ -80,7 +84,7 @@ module Aspera
       def initialize(argv)
         @argv = argv
         # environment provided to plugin for various capabilities
-        @agents = {}
+        @plug_init = Plugin::INIT_PARAMS.each_with_object({}) { |key, hash| hash[key] = nil }
         @option_help = false
         @option_show_config = false
         @bash_completion = false
@@ -88,11 +92,12 @@ 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
+        @plug_init[:only_manual] = false
         # create formatter, in case there is an exception, it is used to display.
-        @agents[:formatter] = Formatter.new
+        @plug_init[:formatter] = Formatter.new
         # second : manage debug level (allows debugging of option parser)
         early_debug_setup
-        @agents[:options] = Manager.new(PROGRAM_NAME)
+        @plug_init[:options] = Manager.new(PROGRAM_NAME)
         # give command line arguments to option manager
         options.parse_command_line(@argv)
         # formatter adds options
@@ -105,11 +110,14 @@ module Aspera
         # declare and parse global options
         declare_global_options
         # the Config plugin adds the @preset parser, so declare before TransferAgent which may use it
-        @agents[:config] = Plugins::Config.new(@agents, gem: GEM_NAME, name: PROGRAM_NAME, help: DOC_URL, version: Aspera::Cli::VERSION)
+        @plug_init[:config] = Plugins::Config.new(**@plug_init, gem: GEM_NAME, name: PROGRAM_NAME, help: DOC_URL, version: Cli::VERSION)
+        @plug_init[:persistency] = @plug_init[:config].persistency
         # data persistency
-        assert(@agents[:persistency]){'missing persistency object'}
+        Aspera.assert(@plug_init[:persistency]){'missing persistency object'}
         # the TransferAgent plugin may use the @preset parser
-        @agents[:transfer] = TransferAgent.new(options, config)
+        @plug_init[:config].transfer = @plug_init[:transfer] = TransferAgent.new(options, config)
+        nil_keys = @plug_init.select{|_, value|value.nil?}.keys
+        Aspera.assert(nil_keys.empty?){"nil : #{nil_keys}"}
         Log.log.debug('plugin env created'.red)
         # set banner when all environment is created so that additional extended value modifiers are known, e.g. @preset
         options.parser.banner = app_banner
@@ -119,7 +127,7 @@ module Aspera
         t = ' ' * 8
         return <<~END_OF_BANNER
           NAME
-          #{t}#{PROGRAM_NAME} -- a command line tool for Aspera Applications (v#{Aspera::Cli::VERSION})
+          #{t}#{PROGRAM_NAME} -- a command line tool for Aspera Applications (v#{Cli::VERSION})
 
           SYNOPSIS
           #{t}#{PROGRAM_NAME} COMMANDS [OPTIONS] [ARGS]
@@ -155,7 +163,7 @@ module Aspera
         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, Aspera::Cli::VERSION); Process.exit(0) } # rubocop:disable Style/Semicolon, Layout/LineLength
+        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(:warnings, 'Check for language warnings', values: :none, short: 'w') { $VERBOSE = true }
         options.declare(
           :ui, 'Method to start browser',
@@ -177,20 +185,19 @@ module Aspera
       # 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 ||= @agents
+        env ||= @plug_init
         Log.log.debug{"get_plugin_instance_with_options(#{plugin_name_sym})"}
-        require config.plugins[plugin_name_sym][:require_stanza]
+        require PluginFactory.instance.plugins[plugin_name_sym][:require_stanza]
         # load default params only if no param already loaded before plugin instantiation
         env[:config].add_plugin_default_preset(plugin_name_sym)
-        command_plugin = Plugins::Config.plugin_class(plugin_name_sym).new(env)
+        command_plugin = PluginFactory.instance.create(plugin_name_sym, **env)
         Log.log.debug{"got #{command_plugin.class}"}
-        # TODO: check that ancestor is Plugin?
         return command_plugin
       end
 
       def generate_bash_completion
         if options.get_next_argument('', expected: :multiple, mandatory: false).nil?
-          config.plugins.each_key{|p|puts p.to_s}
+          PluginFactory.instance.plugins.each_key{|p|puts p}
         else
           Log.log.warn('only first level completion so far')
         end
@@ -203,11 +210,11 @@ module Aspera
         formatter.display_message(:error, options.parser)
         if all_plugins
           # list plugins that have a "require" field, i.e. all but main plugin
-          config.plugins.each_key do |plugin_name_sym|
-            next if plugin_name_sym.eql?(Plugins::Config::CONF_PLUGIN_SYM)
+          PluginFactory.instance.plugins.each_key do |plugin_name_sym|
+            next if plugin_name_sym.eql?(CONF_PLUGIN_SYM)
             # override main option parser with a brand new, to avoid having global options
-            plugin_env = @agents.clone
-            plugin_env[:all_manuals] = true # force declaration of all options
+            plugin_env = @plug_init.clone
+            plugin_env[:only_manual] = true # force declaration of all options
             plugin_env[:options] = Manager.new(PROGRAM_NAME)
             plugin_env[:options].parser.banner = '' # remove default banner
             get_plugin_instance_with_options(plugin_name_sym, plugin_env)
@@ -223,12 +230,12 @@ module Aspera
       # early debug for parser
       # Note: does not accept shortcuts
       def early_debug_setup
-        Aspera::Log.instance.program_name = PROGRAM_NAME
+        Log.instance.program_name = PROGRAM_NAME
         @argv.each do |arg|
           case arg
           when '--' then break
-          when /^--log-level=(.*)/ then Aspera::Log.instance.level = Regexp.last_match(1).to_sym
-          when /^--logger=(.*)/ then Aspera::Log.instance.logger_type = Regexp.last_match(1).to_sym
+          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}")
@@ -247,16 +254,16 @@ module Aspera
         begin
           init_agents_and_options
           # find plugins, shall be after parse! ?
-          config.add_plugins_from_lookup_folders
+          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?
-              Plugins::Config::CONF_PLUGIN_SYM
+              CONF_PLUGIN_SYM
             else
-              options.get_next_command(config.plugins.keys.dup.unshift(:help))
+              options.get_next_command(PluginFactory.instance.plugins.keys.dup.unshift(:help))
             end
           # command will not be executed, but we need manual
           options.fail_on_missing_mandatory = false if @option_help || @option_show_config
@@ -264,7 +271,7 @@ module Aspera
           case command_sym
           when :help
             exit_with_usage(true)
-          when Plugins::Config::CONF_PLUGIN_SYM
+          when CONF_PLUGIN_SYM
             command_plugin = config
           else
             # get plugin, set options, etc
@@ -307,8 +314,8 @@ module Aspera
         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 Fasp::Error => e;                    exception_info = {e: e, t: 'Transfer'}
-        rescue Aspera::RestCallError => e;          exception_info = {e: e, t: 'Rest'}
+        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}
@@ -317,7 +324,7 @@ module Aspera
         TempFileManager.instance.cleanup
         # 1- processing of error condition
         unless exception_info.nil?
-          Log.log.warn(exception_info[:e].message) if Aspera::Log.instance.logger_type.eql?(:syslog) && exception_info[:security]
+          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 ?

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.debug{"AttrAccessor: #{@option_name}: #{@object.class}.#{@method}: writer=#{@has_writer}"}
-        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
@@ -61,7 +61,7 @@ module Aspera
 
       class << self
         def enum_to_bool(enum)
-          assert_values(enum, BOOLEAN_VALUES){'boolean'}
+          Aspera.assert_values(enum, BOOLEAN_VALUES){'boolean'}
           return TRUE_VALUES.include?(enum)
         end
 
@@ -75,8 +75,8 @@ module Aspera
           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)}
-          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) 
+          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)
           return matching.first
         end
@@ -84,8 +84,8 @@ module Aspera
         # Generates error message with list of allowed values
         # @param error_msg [String] error message
         # @param choices [Array] list of allowed values
-        def multi_choice_assert(assertion,error_msg, choices)
-          raise Cli::BadArgument,  [error_msg, 'Use:'].concat(choices.map{|c|"- #{c}"}.sort).join("\n") unless assertion
+        def multi_choice_assert(assertion, error_msg, choices)
+          raise Cli::BadArgument, [error_msg, 'Use:'].concat(choices.map{|c|"- #{c}"}.sort).join("\n") unless assertion
         end
 
         # change option name with dash to name with underscore
@@ -103,7 +103,7 @@ module Aspera
         # @param type_list [NilClass, Class, Array[Class]] accepted value type(s)
         def validate_type(what, descr, value, type_list)
           return nil if type_list.nil?
-          assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}
+          Aspera.assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}
           raise Cli::BadArgument,
             "#{what.to_s.capitalize} #{descr} is a #{value.class} but must be #{type_list.length > 1 ? 'one of ' : ''}#{type_list.map(&:name).join(',')}" unless \
             type_list.any?{|t|value.is_a?(t)}
@@ -181,14 +181,15 @@ module Aspera
       # @param default [Object] default value
       # @return value, list or nil
       def get_next_argument(descr, expected: :single, mandatory: true, type: nil, aliases: nil, default: nil)
-        assert(%i[single multiple].include?(expected) || (expected.is_a?(Array) && expected.all?(Symbol))){'expected must be single, multiple, or array of symbol'}
-        assert(type.nil? || type.is_a?(Class) || (type.is_a?(Array) && type.all?(Class))){'type must be Class or Array of Class'}
-        assert(aliases.nil? || (aliases.is_a?(Hash) && aliases.keys.all?(Symbol) && aliases.values.all?(Symbol))){'aliases must be Hash'}
+        Aspera.assert(%i[single multiple].include?(expected) || (expected.is_a?(Array) && expected.all?(Symbol))) do
+          'expected must be single, multiple, or array of symbol'
+        end
+        Aspera.assert(type.nil? || type.is_a?(Class) || (type.is_a?(Array) && type.all?(Class))){'type must be Class or Array of Class'}
+        Aspera.assert(aliases.nil? || (aliases.is_a?(Hash) && aliases.keys.all?(Symbol) && aliases.values.all?(Symbol))){'aliases must be Hash'}
         allowed_types = type
         unless allowed_types.nil?
           allowed_types = [allowed_types] unless allowed_types.is_a?(Array)
           descr = "#{descr} (#{allowed_types.join(', ')})"
-          Log.log.debug{">>>> #{descr}=#{allowed_types}"}
         end
         result =
           if !@unprocessed_cmd_line_arguments.empty?
@@ -207,7 +208,7 @@ module Aspera
               allowed_values = [].concat(expected)
               allowed_values.concat(aliases.keys) unless aliases.nil?
               self.class.get_from_list(@unprocessed_cmd_line_arguments.shift, descr, allowed_values)
-            else error_unexpected_value(expected)
+            else Aspera.error_unexpected_value(expected)
             end
           elsif !default.nil? then default
             # no value provided, either get value interactively, or exception
@@ -232,7 +233,7 @@ module Aspera
       # @param mandatory [Boolean] if true, raise error if option not set
       def get_option(option_symbol, mandatory: false, default: nil)
         attributes = @declared_options[option_symbol]
-        assert(attributes){"option not declared: #{option_symbol}"}
+        Aspera.assert(attributes){"option not declared: #{option_symbol}"}
         result = nil
         case attributes[:read_write]
         when :accessor
@@ -295,10 +296,10 @@ module Aspera
       # @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)
-        assert(!@declared_options.key?(option_symbol)){"#{option_symbol} already declared"}
-        assert(description[-1] != '.'){"#{option_symbol} ends with dot"}
-        assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with capital"}
-        assert(!['hash', 'extended value'].any?{|s|description.downcase.include?(s) }){"#{option_symbol} shall use :types"}
+        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"}
         opt = @declared_options[option_symbol] = {
           read_write: handler.nil? ? :value : :accessor,
           # by default passwords and secrets are sensitive, else specify when declaring the option
@@ -306,7 +307,7 @@ module Aspera
         }
         if !types.nil?
           types = [types] unless types.is_a?(Array)
-          assert(types.all?(Class)){"types must be Array of Class: #{types}"}
+          Aspera.assert(types.all?(Class)){"types must be Array of Class: #{types}"}
           opt[:types] = types
           description = "#{description} (#{types.map(&:name).join(', ')})"
         end
@@ -316,8 +317,8 @@ module Aspera
         end
         Log.log.debug{"declare: #{option_symbol}: #{opt[:read_write]}".green}
         if opt[:read_write].eql?(:accessor)
-          assert_type(handler, Hash)
-          assert(handler.keys.sort.eql?(%i[m o]))
+          Aspera.assert_type(handler, Hash)
+          Aspera.assert(handler.keys.sort.eql?(%i[m o]))
           Log.log.debug{"set attr obj #{option_symbol} (#{handler[:o]},#{handler[:m]})"}
           opt[:accessor] = AttrAccessor.new(handler[:o], handler[:m], option_symbol)
         end
@@ -356,11 +357,11 @@ module Aspera
             set_option(option_symbol, time_string, SOURCE_USER)
           end
         when :none
-          assert(!block.nil?){"missing block for #{option_symbol}"}
+          Aspera.assert(!block.nil?){"missing block for #{option_symbol}"}
           on_args.push(symbol_to_option(option_symbol, nil))
           on_args.push("-#{short}") if short.is_a?(String)
           @parser.on(*on_args, &block)
-        else error_unexpected_value(values)
+        else Aspera.error_unexpected_value(values)
         end
         Log.log.debug{"on_args=#{on_args}"}
       end
@@ -368,7 +369,7 @@ module Aspera
       # 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)
-        assert_type(preset_hash, Hash)
+        Aspera.assert_type(preset_hash, Hash)
         Log.log.debug{"add_option_preset=#{preset_hash}"}
         # incremental override
         preset_hash.each{|k, v|@unprocessed_defaults.send(op, [k.to_sym, v])}
@@ -470,7 +471,7 @@ module Aspera
       def get_interactive(type, descr, expected: :single)
         if !@ask_missing_mandatory
           raise Cli::BadArgument, "missing argument (#{expected}): #{descr}" unless expected.is_a?(Array)
-          self.class.multi_choice_assert(false,"missing: #{descr}", expected)
+          self.class.multi_choice_assert(false, "missing: #{descr}", expected)
         end
         result = nil
         sensitive = type.eql?(:option) && @declared_options[descr.to_sym].is_a?(Hash) && @declared_options[descr.to_sym][:sensitive]