aspera-cli 4.26.2 → 4.27.0

data/lib/aspera/cli/command_registry.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'aspera/cli/command_spec'
+
+module Aspera
+  module Cli
+    # Stores CommandSpec objects indexed by their full path (Array<Symbol>).
+    # Each plugin class gets its own instance (not shared across the inheritance chain).
+    #
+    # Public API:
+    #   register(spec)          - store a CommandSpec; raises on duplicate full_path
+    #   register_option(spec)   - store an OptionSpec by name
+    #   option_specs            - Hash{Symbol => OptionSpec} of all registered options
+    #   [](path)                - retrieve a CommandSpec by full path
+    #   children_of(path)       - Hash{Symbol => CommandSpec} of direct children (O(1))
+    #   all_paths               - Array of all registered full paths
+    #   any?                    - true if at least one spec has been registered
+    #   validate!               - cross-spec consistency checks; raises on violation
+    class CommandRegistry
+      # @param path [Array<Symbol>] full path to look up
+      # @return [CommandSpec, nil]
+      def [](path)
+        @specs[Array(path)]
+      end
+
+      # Register a CommandSpec. Raises if the full_path is already registered.
+      # Also updates the children index so children_of remains O(1).
+      # @param spec [CommandSpec]
+      # @raise [ArgumentError] on duplicate full path
+      # @return [CommandSpec] the registered spec
+      def register(spec)
+        path = spec.full_path
+        raise ArgumentError, "Duplicate command path: #{path.inspect}" if @specs.key?(path)
+        @specs[path] = spec
+        # Index: parent_path -> { child_id -> spec }
+        parent = path[0..-2] # [] for root-level commands
+        (@children_index[parent] ||= {})[spec.id] = spec
+        spec
+      end
+
+      # Returns a Hash mapping each child id to its CommandSpec for all direct
+      # children of `path`. Empty hash if no children are registered.
+      # O(1) lookup via the children index built in register().
+      # @param path [Array<Symbol>] parent path ([] for root-level commands)
+      # @return [Hash{Symbol => CommandSpec}]
+      def children_of(path)
+        @children_index[Array(path)] || {}
+      end
+
+      # @return [Array<Array<Symbol>>] all registered full paths
+      def all_paths
+        @specs.keys
+      end
+
+      # Register an OptionSpec. Raises if the option name is already registered.
+      # @param spec [OptionSpec]
+      # @raise [ArgumentError] on duplicate option name
+      # @return [OptionSpec] the registered spec
+      def register_option(spec)
+        raise ArgumentError, "Duplicate option: #{spec.name.inspect}" if @option_specs.key?(spec.name)
+        @option_specs[spec.name] = spec
+      end
+
+      # @return [Hash{Symbol => OptionSpec}] all registered option specs
+      def option_specs
+        @option_specs.dup
+      end
+
+      # @return [Boolean] true if at least one spec is registered
+      def any?
+        !@specs.empty?
+      end
+
+      # @return [Boolean] true if no specs have been registered
+      def none?
+        @specs.empty?
+      end
+
+      # Cross-spec consistency checks.
+      # @param plugin_class [Class, nil] when given, also verify that implicit action methods exist
+      # @raise [ArgumentError] on any violation
+      # @return [self]
+      def validate!(plugin_class: nil)
+        # Rule: every non-root parent path that appears in the children index must have
+        # a registered CommandSpec. A missing parent means commands_under(:x) was used
+        # without a matching command :x declaration.
+        @children_index.each_key do |parent_path|
+          next if parent_path.empty? # root is never a CommandSpec
+          unless @specs.key?(parent_path)
+            raise ArgumentError,
+              "commands_under(#{parent_path.map(&:inspect).join(', ')}) used but #{parent_path.last.inspect} has no command declaration"
+          end
+        end
+
+        @specs.each_value do |spec|
+          path = spec.full_path
+
+          # Rule: delegates_to must point to a known path when present (non-empty array or symbol)
+          if spec.delegates_to
+            dt_path =
+              case spec.delegates_to
+              when Symbol then [spec.delegates_to]
+              when Array  then spec.delegates_to
+              end
+            # An empty array [] means re-enter the root - always valid
+            unless dt_path.empty? || @specs.key?(dt_path)
+              raise ArgumentError,
+                "#{path.inspect}: delegates_to #{dt_path.inspect} points to unknown path"
+            end
+          end
+
+          # Rule: delegate_instance requires delegates_to
+          if spec.delegate_instance && spec.delegates_to.nil?
+            raise ArgumentError,
+              "#{path.inspect}: delegate_instance requires delegates_to to be set"
+          end
+
+          # Rule: leaf commands with no explicit action must have a matching instance method
+          next if spec.action # explicit action: skip
+          next if @children_index[path]&.any? # intermediate node: skip
+          next if spec.delegates_to || spec.entity_execute # delegated: skip
+          next unless plugin_class
+          implicit_method = CommandSpec.action_method(path)
+          unless plugin_class.method_defined?(implicit_method) || plugin_class.private_method_defined?(implicit_method)
+            raise ArgumentError,
+              "#{path.inspect}: no action: and no method #{implicit_method} on #{plugin_class}"
+          end
+        end
+        self
+      end
+
+      private
+
+      def initialize
+        # Keyed by Array<Symbol> full path
+        @specs = {}
+        # Keyed by Symbol option name
+        @option_specs = {}
+        # Children index: parent Array<Symbol> -> Hash{child_id Symbol => CommandSpec}
+        # Built incrementally in register(); enables O(1) children_of lookups.
+        @children_index = {}
+      end
+    end
+  end
+end

data/lib/aspera/cli/command_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Aspera
+  module Cli
+    # Declares a positional argument consumed by a command.
+    # Declaration order in a command's `arguments:` array defines parsing order.
+    # Mandatory arguments must come before optional ones.
+    #
+    # @!attribute name        [Symbol]                    Name used in help and error messages
+    # @!attribute description [String]                    User-facing description
+    # @!attribute type        [Class, Array<Class>, :identifier] Validated type; :identifier triggers instance_identifier
+    # @!attribute mandatory   [Boolean]                   Default true; optional args must come after all mandatory ones
+    # @!attribute multiple    [Boolean, String]           true: consume all remaining; String: consume until named marker
+    # @!attribute default     [Object, nil]               Default value when mandatory: false and no argument provided
+    # @!attribute schema      [String, nil]               JSON schema name for validation and --help introspection
+    # @!attribute bulk        [Boolean]                   When true, wraps read+loop for bulk mode (Array if --bulk yes)
+    # @!attribute lookup      [Symbol, nil]               Instance method name for percent-selector resolution (only used when type: :identifier)
+    # @!attribute allowed     [Array<Symbol>, nil]        Allowed Symbol values; when set, type is forced to Symbol and accept_list is applied
+    # @!attribute interactive [Boolean]                   When true, sets ask_missing_mandatory before resolving so interactive prompting is triggered when no CLI args are provided
+    ArgumentSpec = Struct.new(
+      :name,
+      :description,
+      :type,
+      :mandatory,
+      :multiple,
+      :default,
+      :schema,
+      :bulk,
+      :lookup,
+      :allowed,
+      :interactive,
+      keyword_init: true
+    ) do
+      def initialize(**kwargs)
+        kwargs[:mandatory]    = true  if kwargs[:mandatory].nil?
+        kwargs[:multiple]     = false if kwargs[:multiple].nil?
+        kwargs[:bulk]         = false if kwargs[:bulk].nil?
+        kwargs[:interactive]  = false if kwargs[:interactive].nil?
+        super
+      end
+    end
+
+    # Declares an option referenced by name from command declarations.
+    # Mirrors the existing `options.declare` call but associates the option with
+    # the command(s) that use it.
+    #
+    # @!attribute name        [Symbol]               Option name (same symbol used in options.declare)
+    # @!attribute description [String, nil]          User-facing description; nil derives it from schema:
+    # @!attribute allowed     [Array, nil]           Allowed values (forwarded to options.declare)
+    # @!attribute default     [Object, nil]          Default value
+    # @!attribute short       [String, nil]          Single-character short form (e.g. 'x')
+    # @!attribute handler     [Symbol, Hash, nil]
+    #   - Symbol: resolved to {o: <plugin instance>, m: <symbol>} at runtime (Category B)
+    #   - Hash:   {o: <object>, m: <method>} used as-is (Category A: singletons / class constants)
+    #   - nil:    option stores its value locally (no delegation)
+    # @!attribute deprecation [String, nil]          Forwarded to options.declare as deprecation:
+    # @!attribute schema      [String, nil]          JSON schema name; also derives description when nil
+    OptionSpec = Struct.new(
+      :name,
+      :description,
+      :allowed,
+      :default,
+      :short,
+      :handler, # kept as-is: this is the option accessor delegation, not a command action
+      :deprecation,
+      :schema,
+      keyword_init: true
+    )
+
+    # Declares a single command node in the flat registry.
+    #
+    # @!attribute id               [Symbol]                      Unique identifier within its parent's namespace
+    # @!attribute parent           [Symbol, Array<Symbol>, nil]  Full path to parent; nil for root commands
+    # @!attribute description      [String]                      User-facing help text
+    # @!attribute options          [Array<Symbol>]               Option names consumed by this command
+    # @!attribute arguments        [Array<ArgumentSpec>]         Positional arguments, in order.
+    #                                                            The first ArgumentSpec with type: :identifier is treated as the instance
+    #                                                            identifier for intermediate nodes (consumed in Phase A) and leaf nodes.
+    # @!attribute action           [Symbol, Proc, nil]           Instance method (Symbol) or inline block (Proc) called when this is a leaf command
+    # @!attribute setup            [Symbol, nil]                 Instance method called before dispatching to children; returns Hash merged into ctx
+    # @!attribute delegates_to     [Symbol, Array<Symbol>, nil]  Re-enter the command tree at this path
+    # @!attribute delegate_instance [Symbol, nil]                Instance method returning a different plugin object
+    # @!attribute aliases          [Array<Symbol>, nil] Alternative names accepted for this command (each resolves to this command's id)
+    # @!attribute entity_execute   [Hash, nil]                   Shorthand: expand to Base#entity_execute with these parameters
+    # @!attribute transfer_paths   [:send, :receive, nil]        File-list resolution delegated to TransferAgent; mutually exclusive with arguments
+    # @!attribute condition        [Symbol, nil]                 Instance method returning Boolean; if false command is hidden from dispatch
+    # @!attribute query_schema     [String, nil]                 Schema path for --query help; when set, the runner hints `--query=help`
+    CommandSpec = Struct.new(
+      :id,
+      :parent,
+      :description,
+      :options,
+      :arguments,
+      :action,
+      :setup,
+      :delegates_to,
+      :delegate_instance,
+      :aliases,
+      :entity_execute,
+      :transfer_paths,
+      :condition,
+      :query_schema,
+      keyword_init: true
+    ) do
+      def initialize(**kwargs)
+        # Coerce each element of arguments: from Hash to ArgumentSpec if needed
+        if kwargs[:arguments]
+          kwargs[:arguments] = kwargs[:arguments].map do |a|
+            a.is_a?(Hash) ? ArgumentSpec.new(**a) : a
+          end
+        end
+        super
+      end
+
+      class << self
+        # Derive the implicit action method name from a path array.
+        # e.g. [:admin, :user, :list] -> :action_admin_user_list
+        # @param path [Array<Symbol>]
+        # @return [Symbol]
+        def action_method(path)
+          :"action_#{path.join('_')}"
+        end
+      end
+
+      # Compute the full path as Array<Symbol> from parent + id.
+      # @return [Array<Symbol>]
+      def full_path
+        Array(parent) + [id]
+      end
+
+      # Derive the implicit action method name from the full path.
+      # @return [Symbol]
+      def action_method_name
+        self.class.action_method(full_path)
+      end
+    end
+  end
+end

data/lib/aspera/cli/context.rb

@@ -1,15 +1,18 @@
 # frozen_string_literal: true
 
 require 'aspera/assert'
+require 'aspera/cli/mailer'
+require 'aspera/cli/secret_finder'
 
 module Aspera
   module Cli
     # Global objects shared with plugins
     class Context
       # @type [Array<Symbol>]
-      MEMBERS = %i[options transfer config formatter persistency man_header presets http_config].freeze
+      # Members that must be non-nil after bootstrap (validated in #validate)
+      MEMBERS = %i[options transfer config formatter persistency man_header presets http_config main_folder mailer secret_finder].freeze
       # @!attribute [rw] options
-      #   @return [Manager] the command line options manager
+      #   @return [Parser] the command line options manager
       # @!attribute [rw] transfer
       #   @return [TransferAgent] the transfer agent, used by transfer plugins
       # @!attribute [rw] config
@@ -24,15 +27,25 @@ module Aspera
       #   @return [PresetManager] manages the YAML config file and preset resolution
       # @!attribute [rw] http_config
       #   @return [Http] manages HTTP/S and TLS runtime options
+      # @!attribute [rw] mailer
+      #   @return [Mailer] sends emails (SMTP) via ERB templates
+      # @!attribute [rw] secret_finder
+      #   @return [SecretFinder] resolves secrets for url+username pairs
       attr_accessor(*MEMBERS)
+      # Optional: nil when progress bar is disabled
+      attr_accessor :progress_bar
+      # Optional: nil when no PAC script is configured
+      attr_accessor :pac_executor
 
       # Initialize all members to nil, so that they are defined and can be validated later
       # @return [nil]
       def initialize
         MEMBERS.each{ |i| instance_variable_set(:"@#{i}", nil)}
+        @progress_bar = nil
+        @pac_executor = nil
       end
 
-      # Validate that all members are set, raise exception if not
+      # Validate that all mandatory members are non-nil (detect bootstrap bugs)
       # @raise [Aspera::AssertionError] if any member is not set
       # @return [nil]
       def validate

data/lib/aspera/cli/error.rb

@@ -4,9 +4,25 @@ module Aspera
   module Cli
     # CLI base exception
     class Error < StandardError; end
+
+    # Raised by dispatch_from_registry when --help is encountered mid-dispatch.
+    # Carries the plugin instance (with #help_path set) so the runner can display
+    # context-sensitive help without unwinding through a full rescue chain.
+    class HelpRequest < StandardError
+      # @return [Plugins::Base]
+      attr_reader :plugin
+
+      def initialize(plugin)
+        super('help requested')
+        @plugin = plugin
+      end
+    end
+
     # Raised when an unexpected argument is provided.
     class BadArgument < Error; end
+
     class MissingArgument < Error; end
+
     class NoSuchElement < Error; end
 
     # Raised when a lookup for a specific entity fails to return exactly one result.

data/lib/aspera/cli/extended_value.rb

@@ -3,6 +3,7 @@
 # cspell:ignore csvt jsonpp stdbin
 require 'aspera/uri_reader'
 require 'aspera/environment'
+require 'aspera/yaml'
 require 'aspera/log'
 require 'aspera/assert'
 require 'aspera/cli/error'
@@ -104,7 +105,7 @@ module Aspera
           s:      lambda(&:to_s),
           secret: lambda{ |i| prompt = i.empty? ? 'secret' : i; $stdin.getpass("#{prompt}> ")}, # rubocop:disable Style/Semicolon
           stdin:  lambda{ |i| ExtendedValue.read_stdin(i)},
-          yaml:   lambda{ |i| YAML.load(i)},
+          yaml:   lambda{ |i| YAML.safe_load(i)},
           zlib:   lambda{ |i| Zlib::Inflate.inflate(i)},
           extend: lambda{ |i| ExtendedValue.instance.evaluate_extend(i)}
         }

data/lib/aspera/cli/formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # cspell:ignore jsonpp
+require 'aspera/schema/registry'
 require 'aspera/cli/special_values'
 require 'aspera/cli/terminal_formatter'
 require 'aspera/preview/terminal'
@@ -108,28 +109,41 @@ module Aspera
         end
       end
 
-      def declare_options(options)
-        options.declare(:display, 'Output only some information', allowed: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :data)
-        options.declare(:format, 'Output format', allowed: DISPLAY_FORMATS, handler: {o: self, m: :option_handler}, default: :table)
-        options.declare(:output, 'Destination for results', handler: {o: self, m: :option_handler})
-        options.declare(
-          :fields, "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", handler: {o: self, m: :option_handler},
-          allowed: [String, Array, Regexp, Proc],
-          default: SpecialValues::DEF
-        )
-        options.declare(:select, 'Select only some items in lists: column, value', allowed: [Hash, Proc], handler: {o: self, m: :option_handler})
-        options.declare(:table_style, '(Table) Display style', allowed: [Hash], handler: {o: self, m: :option_handler}, default: {})
-        options.declare(:flat_hash, '(Table) Display deep values as additional keys', allowed: Allowed::TYPES_BOOLEAN, handler: {o: self, m: :option_handler}, default: true)
-        options.declare(
-          :multi_single, '(Table) Control how object list is displayed as single table, or multiple objects', allowed: %i[no yes single],
-          handler: {o: self, m: :option_handler}, default: :no
-        )
-        options.declare(:show_secrets, 'Show secrets on command output', allowed: Allowed::TYPES_BOOLEAN, handler: {o: self, m: :option_handler}, default: false)
-        options.declare(:image, 'Options for image display', allowed: Hash, handler: {o: self, m: :option_handler}, default: {})
+      class << self
+        # Declare all formatter CLI options (metadata only - no handler binding yet).
+        # @param options [Aspera::Cli::Parser]
+        # @return [nil]
+        def declare_options(options)
+          options.declare(:display,      description: 'Output only some information',                                                                      allowed: DISPLAY_LEVELS,             default: :data)
+          options.declare(:format,       description: 'Output format',                                                                                     allowed: DISPLAY_FORMATS,            default: :table)
+          options.declare(:output,       description: 'Destination for results')
+          options.declare(:fields,       description: "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", allowed: [String, Array, Regexp, Proc], default: SpecialValues::DEF)
+          options.declare(:select,       description: 'Select only some items in lists: column, value',                                                    allowed: [Hash, Proc])
+          options.declare(:table_style,  description: '(Table) Display style',                                                                             allowed: [Hash])
+          options.declare(:flat_hash,    description: '(Table) Display deep values as additional keys',                                                    allowed: Allowed::TYPES_BOOLEAN,     default: true)
+          options.declare(:multi_single, description: '(Table) Control how object list is displayed as single table, or multiple objects',                 allowed: %i[no yes single],          default: :no)
+          options.declare(:show_secrets, description: 'Show secrets on command output',                                                                    allowed: Allowed::TYPES_BOOLEAN,     default: false)
+          options.declare(:image,        schema: Schema::Registry::IMAGE_OPTIONS)
+          nil
+        end
+      end
+
+      # Bind all formatter options to this instance using set_handler.
+      # Called from Runner after Formatter.new.
+      # @param options [Aspera::Cli::Parser]
+      # @return [nil]
+      def bind_options(options)
+        %i[display format output fields select table_style flat_hash multi_single show_secrets image].each do |opt|
+          options.set_handler(opt, object: self, method: :option_handler)
+        end
+        nil
       end
 
-      # method accessed by option manager
-      # options are: format, output, display, fields, select, table_style, flat_hash, multi_single
+      # Getter/setter handler called by the option manager for all formatter options
+      # @param option_symbol [Symbol]       Option name (one of :format, :output, :display, :fields, :select, :table_style, :flat_hash, :multi_single, :show_secrets, :image)
+      # @param operation     [Symbol]       :get or :set
+      # @param value         [Object, nil]  Value to set (only used when operation is :set)
+      # @return [Object, nil] Current option value when operation is :get; nil otherwise
       def option_handler(option_symbol, operation, value = nil)
         Aspera.assert_values(operation, %i[set get])
         case operation
@@ -150,7 +164,7 @@ module Aspera
             allowed_options = Preview::Terminal.method(:build).parameters.select{ |i| i[0].eql?(:key)}.map{ |i| i[1]}
             # check that only supported options are given
             unknown_options = value.keys.map(&:to_sym) - allowed_options
-            raise "Invalid parameter(s) for option image: #{unknown_options.join(', ')}, use #{allowed_options.join(', ')}" unless unknown_options.empty?
+            Aspera.assert(unknown_options.empty?){"Invalid parameter(s) for option image: #{unknown_options.join(', ')}, use #{allowed_options.join(', ')}"}
           end
         when :get then return @options[option_symbol]
         else Aspera.error_unreachable_line
@@ -163,7 +177,7 @@ module Aspera
       # @param message_level [Symbol] The level of the message - must be one of: :data, :info, :error
       # @param message [String] The message to display
       # @param hide_secrets [Boolean] Whether to hide secrets in the message (default: true)
-      # @return [void]
+      # @return [nil]
       # @note Message display behavior depends on the message_level:
       #   - +:data+ messages are displayed unless display level is +:error+
       #   - +:info+ messages are only displayed when display level is +:info+
@@ -218,7 +232,7 @@ module Aspera
       end
 
       # Set the format type (used by Image result)
-      def set_format_type(format)
+      def format_type=(format)
         @options[:format] = format
       end
 
@@ -242,12 +256,12 @@ module Aspera
         @options[:image].symbolize_keys
       end
 
-      # @return all fields of all objects in list of objects
+      # @return [Array<String>] all fields of all objects in list of objects
       def all_fields(data)
         data.each_with_object({}){ |v, m| v.each_key{ |c| m[c] = true}}.keys
       end
 
-      # @return the list of fields to display
+      # @return [Array<String>] the list of fields to display
       # @param data    [Array<Hash>]         data to display
       # @param default [Array<String>, Proc] list of fields to display by default (may contain special values)
       def compute_fields(data, default)
@@ -313,7 +327,7 @@ module Aspera
         when Proc
           begin
             data.select!{ |i| @options[:select].call(i)}
-          rescue Exception => e # rubocop:disable Lint/RescueException
+          rescue StandardError => e
             raise Cli::BadArgument, "Error in user-provided ruby lambda code during select: #{e.message}"
           end
         when Hash
@@ -356,7 +370,7 @@ module Aspera
         final_table_rows = object_array.map{ |r| fields.map{ |c| r[c].to_s}}
         # remove empty rows
         final_table_rows.select!{ |i| !(i.is_a?(Hash) && i.empty?)}
-        # here : fields : list of column names
+        # fields: list of column names to display
         case @options[:format]
         when :table
           format_style[:border] = :unicode_round if Environment.terminal_supports_unicode?

data/lib/aspera/cli/gem_checker.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'aspera/cli/version'
+require 'aspera/cli/info'
+require 'aspera/environment'
+require 'aspera/persistency_action_once'
+require 'aspera/rest'
+require 'aspera/log'
+require 'date'
+
+module Aspera
+  module Cli
+    # Mixin providing gem version-check functionality to Plugin::Config.
+    # Depends on `options` and `persistency` being available in the including class.
+    module GemChecker
+      GEM_CHECK_DATE_FMT = '%Y/%m/%d'
+
+      # @return [Hash] current vs latest gem version info
+      def check_gem_version
+        latest_version =
+          begin
+            Rest.new(base_url: 'https://rubygems.org/api/v1').read("versions/#{Info::GEM_NAME}/latest.json")['version']
+          rescue StandardError
+            Log.log.warn('Could not retrieve latest gem version on rubygems.')
+            '0'
+          end
+        if Gem::Version.new(Environment.ruby_version) < Gem::Version.new(Info::RUBY_FUTURE_MINIMUM_VERSION)
+          Log.log.warn do
+            "Note that a future version will require Ruby version #{Info::RUBY_FUTURE_MINIMUM_VERSION} at minimum, " \
+              "you are using #{Environment.ruby_version}"
+          end
+        end
+        return {
+          name:        Info::GEM_NAME,
+          current:     Cli::VERSION,
+          latest:      latest_version,
+          need_update: Gem::Version.new(Cli::VERSION) < Gem::Version.new(latest_version)
+        }
+      end
+
+      # Check periodically if a newer gem version is available; log a warning if so.
+      # Called once per run by Runner, before command execution.
+      def periodic_check_newer_gem_version
+        delay_days = options.get_option(:version_check_days, mandatory: true).to_i
+        return if delay_days.eql?(0)
+        last_check_array = []
+        check_date_persist = PersistencyActionOnce.new(
+          manager: persistency,
+          data:    last_check_array,
+          id:      'version_last_check'
+        )
+        current_date = Date.today
+        last_check_days = (current_date - Date.strptime(last_check_array.first, GEM_CHECK_DATE_FMT)) rescue nil
+        Log.log.debug{"gem check new version: #{delay_days}, #{last_check_days}, #{current_date}, #{last_check_array}"}
+        return if !last_check_days.nil? && last_check_days < delay_days
+        last_check_array[0] = current_date.strftime(GEM_CHECK_DATE_FMT)
+        check_date_persist.save
+        check_data = check_gem_version
+        Log.log.warn do
+          "A new version is available: #{check_data[:latest]}. You have #{check_data[:current]}. Upgrade with: gem update #{check_data[:name]}"
+        end if check_data[:need_update]
+      end
+    end
+  end
+end

data/lib/aspera/cli/hints.rb

@@ -129,6 +129,7 @@ module Aspera
       class << self
         # @param error [Exception] exception object
         def hint_for(error, formatter)
+          # Loop on known error hints
           ERROR_HINTS.each do |hint|
             next unless error.is_a?(hint[:exception])
             message = error.message
@@ -141,12 +142,11 @@ module Aspera
                 next unless message.eql?(m)
               when Regexp
                 next unless message.match?(m)
-              else Aspera.error_unexpected_value(m)
+              else Aspera.error_unexpected_value(m){'hint match'}
               end
               hint[:remediation].each do |r|
                 Log.log.info{"#{'HINT:'.bg_green.gray.blink.freeze} #{r}"}
               end
-              break
             end
           end
         end