aspera-cli 4.26.0 → 4.26.2

data/lib/aspera/cli/{main.rb → runner.rb}

@@ -1,63 +1,28 @@
 # frozen_string_literal: true
 
+require 'aspera/cli/context'
 require 'aspera/cli/manager'
 require 'aspera/cli/formatter'
+require 'aspera/cli/plugins/factory'
 require 'aspera/cli/plugins/config'
 require 'aspera/cli/extended_value'
-require 'aspera/cli/plugins/factory'
 require 'aspera/cli/transfer_agent'
 require 'aspera/cli/version'
 require 'aspera/cli/info'
 require 'aspera/cli/hints'
+require 'aspera/cli/result'
 require 'aspera/secret_hider'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/schema/documentation'
+require 'aspera/schema/registry'
 require 'net/ssh/errors'
 require 'openssl'
 
 module Aspera
   module Cli
-    # Global objects shared with plugins
-    class Context
-      # @!attribute [rw] options
-      #   @return [Manager] the command line options manager
-      # @!attribute [rw] transfer
-      #   @return [TransferAgent] the transfer agent, used by transfer plugins
-      # @!attribute [rw] config
-      #   @return [Plugins::Config] the configuration plugin, used by plugins to get configuration values and presets
-      # @!attribute [rw] formatter
-      #   @return [Formatter] the formatter, used by plugins to display results and messages
-      # @!attribute [rw] persistency
-      #   @return [Object] # whatever the type is
-      # @!attribute [rw] man_header
-      #   @return [Boolean] whether to display the manual header in plugin help
-      MEMBERS = %i[options transfer config formatter persistency man_header].freeze
-      attr_accessor(*MEMBERS)
-
-      # Initialize all members to nil, so that they are defined and can be validated later
-      def initialize
-        MEMBERS.each{ |i| instance_variable_set(:"@#{i}", nil)}
-      end
-
-      # Validate that all members are set, raise exception if not
-      def validate
-        MEMBERS.each do |i|
-          Aspera.assert(instance_variable_defined?(:"@#{i}"))
-          Aspera.assert(!instance_variable_get(:"@#{i}").nil?)
-        end
-      end
-
-      def only_manual?
-        transfer.eql?(:only_manual)
-      end
-
-      def only_manual!
-        @transfer = :only_manual
-      end
-    end
-
     # The main CLI class
-    class Main
+    class Runner
       # Plugins store transfer result using this key and use result_transfer_multiple()
       STATUS_FIELD = 'status'
       COMMAND_CONFIG = :config
@@ -69,35 +34,19 @@ module Aspera
       private_constant :COMMAND_CONFIG, :COMMAND_HELP, :SCALAR_TYPES, :USER_INTERFACES
 
       class << self
-        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
-
         # Process statuses of finished transfer sessions
-        # @raise exception if there is one error
-        # else returns an empty status
+        # @param statuses [Array] array of transfer session statuses
+        # @raise [Symbol] exception if there is one error
+        # @return [Result] empty status result if all transfers succeeded
         def result_transfer(statuses)
           worst = TransferAgent.session_status(statuses)
           raise worst unless worst.eql?(:success)
-          return Main.result_nothing
+          return Result::Nothing.new
         end
 
         # 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
+        # @return [Result] a status object suitable as command result
         # Each element has a key STATUS_FIELD which contains the result of possibly multiple sessions
         def result_transfer_multiple(status_table)
           global_status = :success
@@ -108,68 +57,25 @@ module Aspera
             item[STATUS_FIELD] = item[STATUS_FIELD].join(',')
           end
           raise global_status unless global_status.eql?(:success)
-          return result_object_list(status_table)
-        end
-
-        # Display image for that URL or directly blob
-        #
-        # @param url_or_blob [String] URL or blob to display as image
-        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
-
-        # A list of values
-        #
-        # @param data [Array] The list of values
-        # @param name [String] The name of the list (used for display)
-        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, name: 'list') if unsupported_types.empty?
-            Aspera.error_unexpected_value(unsupported_types){'list item types'}
-          when *SCALAR_TYPES
-            return result_text(data)
-          else Aspera.error_unexpected_value(data.class.name){'result type'}
-          end
+          return Result::ObjectList.new(status_table)
         end
       end
 
       # Minimum initialization, no exception raised
+      # @param argv [Array<String>] command line arguments
+      # @return [nil]
       def initialize(argv)
         @argv = argv
         Log.dump(:argv, @argv, level: :trace2)
         @option_help = false
         @option_show_config = false
-        @bash_completion = false
         @context = Context.new
       end
 
       # This is the main function called by initial script just after constructor
-      def process_command_line
+      # Processes command line arguments, executes commands, and handles exceptions
+      # @return [nil]
+      def run
         # Catch exception information , if any
         exception_info = nil
         # False if command shall not be executed (e.g. --show-config)
@@ -181,7 +87,6 @@ module Aspera
           Plugins::Factory.instance.add_plugins_from_lookup_folders
           # Help requested without command ? (plugins must be known here)
           show_usage if @option_help && @context.options.command_or_arg_empty?
-          generate_bash_completion if @bash_completion
           @context.config.periodic_check_newer_gem_version
           command_sym =
             if @option_show_config && @context.options.command_or_arg_empty?
@@ -206,7 +111,7 @@ module Aspera
           # Help requested for current plugin
           show_usage(all: false) if @option_help
           if @option_show_config
-            @context.formatter.display_results(type: :single_object, data: @context.options.known_options(only_defined: true).stringify_keys)
+            @context.formatter.display_results(Result::SingleObject.new(@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)
@@ -229,7 +134,7 @@ module Aspera
             at_exit{File.delete(pid_file)}
           end
           # Execute and display (if not exclusive execution)
-          @context.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
           @context.config.save_config_file_if_needed
           # Finish
@@ -237,8 +142,9 @@ module Aspera
         rescue Net::SSH::AuthenticationFailed => e; exception_info = {e: e, t: 'SSH', security: true}
         rescue OpenSSL::SSL::SSLError => e;         exception_info = {e: e, t: 'SSL'}
         rescue Cli::BadArgument => e;               exception_info = {e: e, t: 'Argument', usage: true}
-        rescue Cli::MissingArgument => e;           exception_info = {e: e, t: 'Missing', usage: true}
+        rescue Cli::MissingArgument => e;           exception_info = {e: e, t: 'Missing'}
         rescue Cli::BadIdentifier => e;             exception_info = {e: e, t: 'Identifier'}
+        rescue Cli::SchemaRequest => e;             exception_info = {e: e, t: 'Schema'}
         rescue Cli::Error => e;                     exception_info = {e: e, t: 'Tool', usage: true}
         rescue Transfer::Error => e;                exception_info = {e: e, t: 'Transfer'}
         rescue RestCallError => e;                  exception_info = {e: e, t: 'Rest'}
@@ -251,11 +157,22 @@ 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]
-          Log.log.error{"#{exception_info[:t]}: #{exception_info[:e].message}"}
+          Log.log.error{"#{exception_info[:t]}: #{exception_info[:e].message}"} unless exception_info[:e].is_a?(Cli::SchemaRequest)
           Log.log.debug{(['Backtrace:'] + exception_info[:e].backtrace).join("\n")} if exception_info[:debug]
           @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], @context.formatter)
+          # Requested help for a Hash parameter/option ?
+          if exception_info[:e].is_a?(Cli::SchemaRequest)
+            Log.log.info{"#{exception_info[:t]}: #{exception_info[:e].message}"}
+            schema_path = exception_info[:e].path
+            if schema_path.nil?
+              Log.log.warn{'Sorry, no schema provided yet. Please refer to the manual or API.'}
+            else
+              builder = Schema::Documentation.new(TerminalFormatter, Schema::Registry.instance.reader(schema_path)).build
+              @context.formatter.display_results(Result::ObjectList.new(builder.rows, fields: builder.columns))
+            end
+          end
         end
         # 2- processing of command not processed (due to exception or bad command line)
         if execute_command || @option_show_config
@@ -276,6 +193,10 @@ module Aspera
         return
       end
 
+      # Display usage information and help
+      # @param all [Boolean] if true, show help for all plugins; if false, show only current plugin
+      # @param exit [Boolean] if true, exit the process after displaying help
+      # @return [nil]
       def show_usage(all: true, exit: true)
         # Display main plugin options (+config)
         @context.formatter.display_message(:error, @context.options.parser)
@@ -298,7 +219,10 @@ module Aspera
 
       private
 
+      # Initialize agents and options
       # This can throw exception if there is a problem with the environment, needs to be caught by execute method
+      # @raise [StandardError] if there is a problem with the environment
+      # @return [nil]
       def init_agents_and_options
         @context.man_header = true
         # Create formatter, in case there is an exception, it is used to display.
@@ -318,7 +242,7 @@ module Aspera
         @context.config = Plugins::Config.new(context: @context)
         @context.man_header = true
         # Data persistency is set in config
-        Aspera.assert(@context.persistency){'missing persistency object'}
+        Aspera.assert(@context.persistency, 'missing persistency object')
         # The TransferAgent plugin may use the @preset parser
         @context.transfer = TransferAgent.new(@context.options, @context.config)
         # Add commands for config plugin after all options have been added
@@ -328,6 +252,8 @@ module Aspera
         @context.options.parser.banner = app_banner
       end
 
+      # Generate the application banner for help display
+      # @return [String] formatted banner text
       def app_banner
         t = ' ' * 8
         return <<~END_OF_BANNER
@@ -362,11 +288,11 @@ module Aspera
         END_OF_BANNER
       end
 
-      # Define header for manual
+      # Define header for manual and declare all global options
+      # @return [nil]
       def declare_global_options
         Log.log.debug('declare_global_options')
         @context.options.declare(:help, 'Show this message', allowed: Allowed::TYPES_NONE, short: 'h'){@option_help = true}
-        @context.options.declare(:bash_comp, 'Generate bash completion for command', allowed: Allowed::TYPES_NONE){@bash_completion = true}
         @context.options.declare(:show_config, 'Display parameters used for the provided action', allowed: Allowed::TYPES_NONE){@option_show_config = true}
         @context.options.declare(:version, 'Display version', allowed: Allowed::TYPES_NONE, short: 'v'){@context.formatter.display_message(:data, Cli::VERSION); Process.exit(0)} # rubocop:disable Style/Semicolon
         @context.options.declare(
@@ -397,9 +323,10 @@ module Aspera
         @context.options.parse_options!
       end
 
-      # @return the plugin instance, based on name
+      # Get the plugin instance based on name
       # Also loads the plugin options, and default values from conf file
-      # @param plugin_name_sym : symbol for plugin name
+      # @param plugin_name_sym [Symbol] symbol for plugin name
+      # @return [Plugins::Base] the plugin instance
       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
@@ -407,15 +334,6 @@ module Aspera
         command_plugin = Plugins::Factory.instance.create(plugin_name_sym, context: @context)
         return command_plugin
       end
-
-      def generate_bash_completion
-        if @context.options.get_next_argument('', multiple: true, mandatory: false).nil?
-          Plugins::Factory.instance.plugin_list.each{ |p| puts p}
-        else
-          Log.log.warn('only first level completion so far')
-        end
-        Process.exit(0)
-      end
     end
   end
 end

data/lib/aspera/cli/sync_actions.rb

@@ -15,7 +15,8 @@ module Aspera
         %w[Syncd Error Confl Pconf] +
         (23..24).map{ |i| "P(#{i})"}).freeze
       class << self
-        def declare_options(_options)
+        def declare_options(options)
+          options.declare(:sql, 'SQL suffix appended to sqlite3 queries for admin subcommands (e.g. WHERE clause)')
         end
       end
 
@@ -27,13 +28,13 @@ module Aspera
       # @return [Hash] sync info
       def async_info_from_args(direction: nil)
         path = options.get_next_argument('path')
-        sync_info = options.get_next_argument('sync info', mandatory: false, validation: Hash, default: {})
+        sync_info = options.get_next_argument('sync info', mandatory: false, validation: Hash, default: {}, schema: Schema::Registry::SYNC_CONF)
         # is the positional path a remote path ?
         path_is_remote = direction.eql?(:pull)
         if sync_info.key?('sessions') || sync_info.key?('instance')
           # `args`
           sync_info['sessions'] ||= [{}]
-          Aspera.assert(sync_info['sessions'].length == 1){'Only one session is supported'}
+          Aspera.assert(sync_info['sessions'].length == 1, 'Only one session is supported')
           session = sync_info['sessions'].first
           dir_key = path_is_remote ? 'remote_dir' : 'local_dir'
           raise "Parameter #{dir_key} shall not be in sync_info" if session.key?(dir_key)
@@ -94,31 +95,34 @@ module Aspera
       end
 
       def execute_sync_admin
-        command2 = options.get_next_command(%i[status find meta counters file_info overview])
+        command2 = options.get_next_command(%i[status find meta counters file_info overview query])
         require 'aspera/sync/database' unless command2.eql?(:status)
+        sql_suffix = options.get_option(:sql)
         case command2
         when :status
-          return Main.result_single_object(Sync::Operations.admin_status(async_info_from_args))
+          return Result::SingleObject.new(Sync::Operations.admin_status(async_info_from_args))
         when :find
           folder = options.get_next_argument('path')
           dbs = Sync::Operations.list_db_files(folder)
-          return Main.result_object_list(dbs.keys.map{ |n| {name: n, path: dbs[n]}})
+          return Result::ObjectList.new(dbs.keys.map{ |n| {name: n, path: dbs[n]}})
         when :meta, :counters
-          return Main.result_single_object(db_from_args.send(command2))
+          return Result::SingleObject.new(db_from_args.send(command2, sql_suffix))
         when :file_info
-          result = db_from_args.send(command2)
+          result = db_from_args.file_info(sql_suffix)
           result.each do |r|
             r['sstate'] = SyncActions::STATE_STR[r['state']] if r['state']
           end
-          return Main.result_object_list(
+          return Result::ObjectList.new(
             result,
             fields: %w[sstate record_id f_meta_path message]
           )
         when :overview
-          return Main.result_object_list(
+          return Result::ObjectList.new(
             db_from_args.overview,
             fields: %w[table name type]
           )
+        when :query
+          return Result.auto(db_from_args.execute(options.get_option(:sql, mandatory: true)))
         else Aspera.error_unexpected_value(command2)
         end
       end
@@ -131,7 +135,7 @@ module Aspera
         case command
         when *Sync::Operations::DIRECTIONS
           Sync::Operations.start(async_info_from_args(direction: command), transfer.user_transfer_spec, &block)
-          return Main.result_success
+          return Result::Success.new
         when :admin
           return execute_sync_admin
         else Aspera.error_unexpected_value(command)

data/lib/aspera/cli/terminal_formatter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'aspera/environment'
+require 'aspera/formatter_interface'
+require 'aspera/markdown'
+require 'aspera/assert'
+
+module Aspera
+  module Cli
+    # Terminal formatter with ANSI colors and Unicode support
+    # @see FormatterInterface
+    # @see MarkdownFormatter (in build/lib/doc_helper.rb)
+    module TerminalFormatter
+      HINT = 'HINT:'.bg_green.gray.blink.freeze
+      include FormatterInterface
+
+      # Format boolean with colored symbol (✓/✗ or Y/ )
+      def tick(yes)
+        result =
+          if Environment.terminal_supports_unicode?
+            yes ? "\u2713" : "\u2717"
+          else
+            yes ? 'Y' : ' '
+          end
+        return result.green if yes
+        return result.red
+      end
+
+      # Format special values with colors (dim for empty, reverse for others)
+      def special_format(what)
+        result = "<#{what}>"
+        return %w[null empty].any?{ |s| what.include?(s)} ? result.dim : result.reverse_color
+      end
+
+      # Prepare table row for terminal display (word wrap arrays)
+      def check_row(row)
+        row.each_key do |k|
+          row[k] = row[k].map{ |i| WordWrap.ww(i.to_s, 120).chomp}.join("\n") if row[k].is_a?(Array)
+        end
+      end
+
+      # Convert Markdown to terminal format (**bold** -> blue, `code` -> bold)
+      # @param match [MatchData, String]
+      def markdown_text(match)
+        if match.is_a?(String)
+          match = Markdown::FORMATS.match(match)
+          Aspera.assert(match, 'markdown text does not match any known format')
+        end
+        Aspera.assert_type(match, MatchData)
+        if match[:entity]
+          Aspera.assert_values(match[:entity], %w[bsol])
+          '\\'
+        elsif match[:bold]
+          match[:bold].to_s.blue
+        elsif match[:code]
+          match[:code].to_s.bold
+        else
+          Aspera.error_unexpected_value(match.to_s)
+        end
+      end
+
+      module_function :tick, :special_format, :check_row, :markdown_text
+    end
+  end
+end

data/lib/aspera/cli/transfer_agent.rb

@@ -5,6 +5,7 @@ require 'aspera/transfer/spec'
 require 'aspera/cli/info'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/schema/registry'
 
 module Aspera
   module Cli
@@ -12,9 +13,9 @@ module Aspera
     # one of the supported transfer agents.
     # Provide CLI options to select one of the transfer agents (FASP/ascp client)
     class TransferAgent
-      # @args special value for --sources : read file list from arguments
+      # `@args` special value for --sources : read file list from arguments
       FILE_LIST_FROM_ARGS = '@args'
-      # @ts special value for --sources : read file list from transfer spec (--ts)
+      # `@ts` special value for --sources : read file list from transfer spec (--ts)
       FILE_LIST_FROM_TRANSFER_SPEC = '@ts'
       FILE_LIST_OPTIONS = [FILE_LIST_FROM_ARGS, FILE_LIST_FROM_TRANSFER_SPEC, 'Array'].freeze
       DEFAULT_TRANSFER_NOTIFY_TEMPLATE = <<~END_OF_TEMPLATE
@@ -63,12 +64,12 @@ module Aspera
         @transfer_paths = nil
         # HTTPGW URL provided by webapp
         @httpgw_url_lambda = nil
-        @opt_mgr.declare(:ts, 'Override transfer spec values', allowed: Hash, handler: {o: self, m: :user_transfer_spec})
+        @opt_mgr.declare(:ts, 'Override transfer spec values', allowed: Hash, handler: {o: self, m: :user_transfer_spec}, schema: Schema::Registry::TRANSFER_SPEC)
         @opt_mgr.declare(:to_folder, 'Destination folder for transferred files')
         @opt_mgr.declare(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})", default: FILE_LIST_FROM_ARGS)
         @opt_mgr.declare(:src_type, 'Type of file list', allowed: %i[list pair], default: :list)
         @opt_mgr.declare(:transfer, 'Type of transfer agent', allowed: Agent::Factory::ALL.keys, default: :direct)
-        @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', allowed: Hash, handler: {o: self, m: :transfer_info})
+        @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', allowed: Hash, handler: {o: self, m: :transfer_info}, schema: Schema::Registry::TRANSFER_INFO)
         @opt_mgr.parse_options!
         @notification_cb = nil
         if !@opt_mgr.get_option(:notify_to).nil?
@@ -154,24 +155,25 @@ module Aspera
       end
 
       # Transform the list of paths to a list of hash with source/dest
-      # @param file_list [Array]
+      # @param file_list [Array<Hash>]
       def list_to_paths(file_list)
         source_type = @opt_mgr.get_option(:src_type, mandatory: true)
-        case source_type
-        when :list
-          # when providing a list, just specify source
-          @transfer_paths = file_list.map{ |i| {'source' => i}}
-        when :pair
-          Aspera.assert(file_list.length.even?, type: Cli::BadArgument){"When using pair, provide an even number of paths: #{file_list.length}"}
-          @transfer_paths = file_list.each_slice(2).map{ |s, d| {'source' => s, 'destination' => d}}
-        else Aspera.error_unexpected_value(source_type)
-        end
+        @transfer_paths =
+          case source_type
+          when :list
+            # when providing a list, just specify source
+            file_list.map{ |i| {'source' => i}}
+          when :pair
+            Aspera.assert(file_list.length.even?, type: Cli::BadArgument){"When using pair, provide an even number of paths: #{file_list.length}"}
+            file_list.each_slice(2).map{ |s, d| {'source' => s, 'destination' => d}}
+          else Aspera.error_unexpected_value(source_type)
+          end
       end
 
       # This is how the list of files to be transferred is specified
       # get paths suitable for transfer spec from command line
       # computation is done only once, cache is kept in @transfer_paths
-      # @param default [Array] of [String] if set, used as default file for --sources=@args
+      # @param default [nil, Array<String>] If set, used as default file for --sources=@args
       # @return [Array, nil] of Hash {source: (mandatory), destination: (optional)}
       def ts_source_paths(default: nil)
         # return cache if set

data/lib/aspera/cli/transfer_progress.rb

@@ -43,13 +43,13 @@ module Aspera
         case type
         when :sessions_init
           # Give opportunity to show progress of initialization with multiple status
-          Aspera.assert(session_id.nil?)
+          Aspera.assert(session_id.nil?, 'session_id must be nil for :sessions_init event')
           Aspera.assert_type(info, String)
           # Initialization of progress bar
           @title = info
         when :session_start
           Aspera.assert_type(session_id, String)
-          Aspera.assert(info.nil?)
+          Aspera.assert(info.nil?, 'info must be nil for :session_start event')
           raise "Session #{session_id} already started" if @sessions[session_id]
           @sessions[session_id] = {
             job_size: 0, # Total size of transfer (pre-calc)
@@ -60,7 +60,7 @@ module Aspera
           @title = nil
         when :session_size
           Aspera.assert_type(session_id, String)
-          Aspera.assert(!info.nil?)
+          Aspera.assert(!info.nil?, 'info must not be nil for :session_size event')
           Aspera.assert_type(@sessions[session_id], Hash)
           @sessions[session_id][:job_size] = info.to_i
           sessions_total = total(:job_size)
@@ -76,12 +76,12 @@ module Aspera
           end
         when :session_end
           Aspera.assert_type(session_id, String)
-          Aspera.assert(info.nil?)
+          Aspera.assert(info.nil?, 'info must be nil for :session_end event')
           # A session may be too short and finish before it has been started
           @sessions[session_id][:running] = false if @sessions[session_id].is_a?(Hash)
         when :end
-          Aspera.assert(session_id.nil?)
-          Aspera.assert(info.nil?)
+          Aspera.assert(session_id.nil?, 'session_id must be nil for :end event')
+          Aspera.assert(info.nil?, 'info must be nil for :end event')
           @progress_bar.finish
         else Aspera.error_unexpected_value(type){'event type'}
         end

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # For beta add extension : .beta1
     # For dev version add extension : .pre
-    VERSION = '4.26.0'
+    VERSION = '4.26.2'
   end
 end

data/lib/aspera/cli/wizard.rb

@@ -80,7 +80,7 @@ module Aspera
         end
         RestParameters.instance.spinner_cb.call(action: :success)
         raise "No known application found at #{app_url}" if found_apps.empty?
-        Aspera.assert(found_apps.all?{ |a| a.keys.all?(Symbol)})
+        Aspera.assert(found_apps.all?{ |a| a.keys.all?(Symbol)}, 'all app info keys must be symbols')
         return found_apps
       end
 
@@ -128,7 +128,8 @@ module Aspera
           apps.first
         else
           formatter.display_status('Multiple applications detected, please select from:')
-          formatter.display_results(type: :object_list, data: apps, fields: %w[product url version])
+          require 'aspera/cli/result'
+          formatter.display_results(Result::ObjectList.new(apps, fields: %w[product url version]))
           answer = options.prompt_user_input_in_list('product', apps.map{ |a| a[:product]})
           apps.find{ |a| a[:product].eql?(answer)}
         end
@@ -140,9 +141,7 @@ module Aspera
         options.add_option_preset({url: wiz_url}, 'wizard')
         # Instantiate plugin: command line options will be known, e.g. private_key, and wizard can be called
         plugin_instance = Plugins::Factory.instance.plugin_class(identification[:product]).new(context: @parent.context)
-        Aspera.assert(plugin_instance.respond_to?(:wizard), type: Cli::BadArgument) do
-          "Detected: #{identification[:product]}, but this application has no wizard"
-        end
+        Aspera.assert(plugin_instance.respond_to?(:wizard), type: Cli::BadArgument){"Detected: #{identification[:product]}, but this application has no wizard"}
         # Call the wizard
         wizard_result = plugin_instance.wizard(self, wiz_url)
         Log.log.debug{"wizard result: #{wizard_result}"}
@@ -166,7 +165,7 @@ module Aspera
         test_args = "-P#{wiz_preset_name} #{test_args}" unless option_default
         # TODO: actually test the command
         test_cmd = "#{Info::CMD_NAME} #{identification[:product]} #{test_args}"
-        return Main.result_status("You can test with:\n#{test_cmd.red}")
+        return Result::Status.new("You can test with:\n#{test_cmd.red}")
       end
     end
   end