aspera-cli 4.26.2 → 4.27.1

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'
@@ -67,7 +68,7 @@ module Aspera
         # @param value [String] The value as parameter
         # @param ext_type [Symbol] The method of extended value
         def assert_no_value(value, ext_type)
-          Aspera.assert(value.empty?, type: BadArgument){"no value allowed for extended value type: #{ext_type}"}
+          Aspera.assert(value.empty?, type: BadArgument) { "no value allowed for extended value type: #{ext_type}" }
         end
 
         def read_stdin(mode)
@@ -88,25 +89,25 @@ module Aspera
         # e.g. `preset` is reader in config plugin
         # @type [Hash{Symbol => Proc}]
         @handlers = {
-          val:    lambda{ |i| i},
-          base64: lambda{ |i| Base64.decode64(i)},
-          csvt:   lambda{ |i| ExtendedValue.decode_csvt(i)},
-          env:    lambda{ |i| ENV.fetch(i, nil)},
-          file:   lambda{ |i| File.read(File.expand_path(i))},
-          uri:    lambda{ |i| UriReader.read(i)},
-          json:   lambda{ |i| ExtendedValue.JSON_parse(i)},
-          lines:  lambda{ |i| i.split("\n")},
-          list:   lambda{ |i| i[1..].split(i[0])},
-          none:   lambda{ |i| ExtendedValue.assert_no_value(i, :none); nil}, # rubocop:disable Style/Semicolon
-          path:   lambda{ |i| File.expand_path(i)},
-          re:     lambda{ |i| Regexp.new(i, Regexp::MULTILINE)},
-          ruby:   lambda{ |i| Environment.secure_eval(i, __FILE__, __LINE__)},
+          val:    lambda { |i| i },
+          base64: lambda { |i| Base64.decode64(i) },
+          csvt:   lambda { |i| ExtendedValue.decode_csvt(i) },
+          env:    lambda { |i| ENV.fetch(i, nil) },
+          file:   lambda { |i| File.read(File.expand_path(i)) },
+          uri:    lambda { |i| UriReader.read(i) },
+          json:   lambda { |i| ExtendedValue.JSON_parse(i) },
+          lines:  lambda { |i| i.split("\n") },
+          list:   lambda { |i| i[1..].split(i[0]) },
+          none:   lambda { |i| ExtendedValue.assert_no_value(i, :none); nil }, # rubocop:disable Style/Semicolon
+          path:   lambda { |i| File.expand_path(i) },
+          re:     lambda { |i| Regexp.new(i, Regexp::MULTILINE) },
+          ruby:   lambda { |i| Environment.secure_eval(i, __FILE__, __LINE__) },
           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)},
-          zlib:   lambda{ |i| Zlib::Inflate.inflate(i)},
-          extend: lambda{ |i| ExtendedValue.instance.evaluate_extend(i)}
+          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.safe_load(i) },
+          zlib:   lambda { |i| Zlib::Inflate.inflate(i) },
+          extend: lambda { |i| ExtendedValue.instance.evaluate_extend(i) }
         }
         @regex_single = nil
         @regex_extend = nil
@@ -126,7 +127,7 @@ module Aspera
       attr_reader :default_decoder
 
       def default_decoder=(value)
-        Log.log.debug{"Setting default decoder to (#{value.class}) #{value}"}
+        Log.log.debug { "Setting default decoder to (#{value.class}) #{value}" }
         Aspera.assert_values(value, DEFAULT_DECODERS)
         value = nil if value.eql?(:none)
         @default_decoder = value
@@ -137,9 +138,9 @@ module Aspera
 
       # Add a new handler
       def on(name, &block)
-        Aspera.assert_type(name, Symbol){'name'}
-        Aspera.assert(block){"block required when registering handler for #{name}"}
-        Log.log.debug{"Setting handler for #{name}"}
+        Aspera.assert_type(name, Symbol) { 'name' }
+        Aspera.assert(block) { "block required when registering handler for #{name}" }
+        Log.log.debug { "Setting handler for #{name}" }
         @handlers[name] = block
         update_regex
       end
@@ -155,7 +156,7 @@ module Aspera
         return value unless value.is_a?(String)
         Aspera.assert_array_all(allowed, Class) unless allowed.nil?
         # use default decoder if not an extended value and expect complex types
-        using_default_decoder = allowed&.all?{ |t| DEFAULT_PARSER_TYPES.include?(t)} && !@regex_single.match?(value) && !@default_decoder.nil?
+        using_default_decoder = allowed&.all? { |t| DEFAULT_PARSER_TYPES.include?(t) } && !@regex_single.match?(value) && !@default_decoder.nil?
         value = [MARKER_START, @default_decoder, MARKER_END, value].join if using_default_decoder
         # First determine decoders, in reversed order
         handlers_reversed = []
@@ -165,7 +166,7 @@ module Aspera
           value = m[2]
           break if SPECIAL_HANDLERS.include?(handler)
         end
-        Log.log.trace1{"evaluating: #{handlers_reversed}, value: #{value}"}
+        Log.log.trace1 { "evaluating: #{handlers_reversed}, value: #{value.class}:#{value}" }
         handlers_reversed.each do |handler|
           value = @handlers[handler].call(value)
         rescue => e
@@ -179,7 +180,7 @@ module Aspera
       def evaluate_extend(value)
         while (m = value.match(@regex_extend))
           sub_value = "@#{m[2]}:#{m[3]}"
-          Log.log.debug{"evaluating #{sub_value}"}
+          Log.log.debug { "evaluating #{sub_value}" }
           value = "#{m[1]}#{evaluate(sub_value, context: 'composite extended value')}#{m[4]}"
         end
         return value

data/lib/aspera/cli/formatter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 # cspell:ignore jsonpp
+require 'aspera/schema/registry'
+require 'aspera/cli/option_declarator'
 require 'aspera/cli/special_values'
 require 'aspera/cli/terminal_formatter'
 require 'aspera/preview/terminal'
@@ -21,6 +23,33 @@ module Aspera
   module Cli
     # Take care of CLI output on terminal
     class Formatter
+      extend OptionDeclarator
+
+      # remove a fields from the list
+      FIELDS_LESS = '-'
+      # supported output formats
+      DISPLAY_FORMATS = %i[text nagios ruby json jsonpp yaml table csv image].freeze
+      # user output levels
+      DISPLAY_LEVELS = %i[info data error].freeze
+      # column names for single object display in table
+      SINGLE_OBJECT_COLUMN_NAMES = %i[field value].freeze
+      # Terminal: vertical separator for list of strings.
+      STR_LST_SEP_VERT = "\n"
+
+      private_constant :FIELDS_LESS, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :SINGLE_OBJECT_COLUMN_NAMES, :STR_LST_SEP_VERT
+
+      option :out,          description: 'Output rendering options (dot-notation: format, level, file, fields, select, table[.pivot], flat, secrets, img)', schema: Schema::Registry::OUT_OPTIONS
+      option :display,      description: 'Output only some information', allowed: DISPLAY_LEVELS, default: :data, deprecation: 'use --out.level'
+      option :format,       description: 'Output format (also: --out.format)', allowed: DISPLAY_FORMATS, default: :table
+      option :output,       description: 'Destination for results', deprecation: 'use --out.file'
+      option :fields,       description: "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF} (also: --out.fields)", allowed: [String, Array, Regexp, Proc], default: SpecialValues::DEF
+      option :select,       description: 'Select only some items in lists: column, value (also: --out.select)', allowed: [Hash, Proc]
+      option :table_style,  description: '(Table) Display style',                                                                             allowed: [Hash], deprecation: 'use --out.table'
+      option :flat_hash,    description: '(Table) Display deep values as additional keys',                                                    allowed: Type::BOOLEAN, default: true,                    deprecation: 'use --out.flat'
+      option :multi_single, description: '(Table) Control how object list is displayed as single table, or multiple objects',                 allowed: %i[no yes single], default: :no,                 deprecation: 'use --out.table.pivot'
+      option :show_secrets, description: 'Show secrets on command output',                                                                    allowed: Type::BOOLEAN, default: false,                   deprecation: 'use --out.secrets'
+      option :image,        schema: Schema::Registry::IMAGE_OPTIONS, deprecation: 'use --out.img'
+
       class << self
         # Replace special values with a readable version on terminal
         def replace_specific_for_terminal(input_hash, string_list_separator)
@@ -57,7 +86,7 @@ module Aspera
         end
 
         def all_but(list)
-          Array(list).map{ |i| "#{FIELDS_LESS}#{i}"}.unshift(SpecialValues::ALL)
+          Array(list).map { |i| "#{FIELDS_LESS}#{i}" }.unshift(SpecialValues::ALL)
         end
       end
 
@@ -108,32 +137,50 @@ 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: {})
+      # 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)
+        @parser = options
+        %i[out 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 :out, :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
         when :set
+          # --out is a composite hash: dispatch each sub-key through the parser (validation included)
+          if option_symbol.eql?(:out)
+            Aspera.assert_type(value, Hash)
+            value.each do |k, v|
+              case k.to_sym
+              when :format   then @parser.set_option(:format,       v, warn_deprecation: false)
+              when :level    then @parser.set_option(:display,      v, warn_deprecation: false)
+              when :file     then @parser.set_option(:output,       v, warn_deprecation: false)
+              when :fields   then @parser.set_option(:fields,       v, warn_deprecation: false)
+              when :select   then @parser.set_option(:select,       v, warn_deprecation: false)
+              when :table
+                Aspera.assert_type(v, Hash)
+                table_hash = v.transform_keys(&:to_sym)
+                @parser.set_option(:multi_single, table_hash.delete(:pivot).to_s, warn_deprecation: false) if table_hash.key?(:pivot)
+                @parser.set_option(:table_style,  table_hash, warn_deprecation: false) unless table_hash.empty?
+              when :flat     then @parser.set_option(:flat_hash,    v, warn_deprecation: false)
+              when :secrets  then @parser.set_option(:show_secrets, v, warn_deprecation: false)
+              when :img      then @parser.set_option(:image,        v, warn_deprecation: false)
+              else Aspera.error_unexpected_value(k) { 'out sub-option (format, level, file, fields, select, table[.pivot], flat, secrets, img)' }
+              end
+            end
+            return
+          end
           @options[option_symbol] = value
           # special handling of some options
           case option_symbol
@@ -147,12 +194,14 @@ module Aspera
             end
           when :image
             # get list if key arguments of method
-            allowed_options = Preview::Terminal.method(:build).parameters.select{ |i| i[0].eql?(:key)}.map{ |i| i[1]}
+            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]
+        when :get
+          return if option_symbol.eql?(:out)
+          return @options[option_symbol]
         else Aspera.error_unreachable_line
         end
         nil
@@ -163,7 +212,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+
@@ -198,9 +247,9 @@ module Aspera
       # @param result [Result] Result object to display
       def display_results(result)
         require 'aspera/cli/result'
-        Aspera.assert_type(result, Cli::Result){'result must be a Result object'}
+        Aspera.assert_type(result, Cli::Result) { 'result must be a Result object' }
 
-        Log.log.debug{"display_results: result class=#{result.class.name}"}
+        Log.log.debug { "display_results: result class=#{result.class.name}" }
         Log.dump(:data, result.data, level: :trace1)
         Log.dump(:fields, result.fields, level: :trace1)
 
@@ -218,7 +267,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,16 +291,16 @@ 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
+        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)
-        Log.log.debug{"compute_fields: data:#{data.class} default:#{default.class} #{default}"}
+        Log.log.debug { "compute_fields: data:#{data.class} default:#{default.class} #{default}" }
         Log.dump(:compute_fields_default, default, level: :trace1)
         # the requested list of fields, but if can contain special values
         request =
@@ -259,8 +308,8 @@ module Aspera
           # when NilClass then [SpecialValues::DEF]
           when String then @options[:fields].split(',')
           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)}
+          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 Aspera.error_unexpected_value(@options[:fields])
           end
         Aspera.assert_array_all(request, String)
@@ -277,12 +326,12 @@ module Aspera
             # get the list of all column names used in all lines, not just first one, as all lines may have different columns
             request.unshift(*all_fields(data))
           when SpecialValues::DEF
-            default = all_fields(data).select{ |i| default.call(i)} if default.is_a?(Proc)
+            default = all_fields(data).select { |i| default.call(i) } if default.is_a?(Proc)
             default = all_fields(data) if default.nil?
             request.unshift(*default)
           else
             if removal
-              result = result.reject{ |i| i.eql?(item)}
+              result = result.reject { |i| i.eql?(item) }
             else
               result.push(item)
             end
@@ -298,12 +347,12 @@ module Aspera
         return data unless data.is_a?(Array)
         # by default, keep all data intact
         return data if @options[:fields].eql?(SpecialValues::DEF) && @options[:select].nil?
-        Aspera.assert_array_all(data, Hash){'filter or select'}
+        Aspera.assert_array_all(data, Hash) { 'filter or select' }
         filter_columns_on_select(data)
         return data if @options[:fields].eql?(SpecialValues::DEF)
         selected_fields = compute_fields(data, @options[:fields])
-        return data.map{ |i| i[selected_fields.first]} if selected_fields.length == 1
-        return data.map{ |i| i.slice(*selected_fields)}
+        return data.map { |i| i[selected_fields.first] } if selected_fields.length == 1
+        return data.map { |i| i.slice(*selected_fields) }
       end
 
       # filter the list of items on the select option
@@ -312,12 +361,12 @@ module Aspera
         case @options[:select]
         when Proc
           begin
-            data.select!{ |i| @options[:select].call(i)}
-          rescue Exception => e # rubocop:disable Lint/RescueException
+            data.select! { |i| @options[:select].call(i) }
+          rescue StandardError => e
             raise Cli::BadArgument, "Error in user-provided ruby lambda code during select: #{e.message}"
           end
         when Hash
-          @options[:select].each{ |k, v| data.select!{ |i| i[k].eql?(v)}}
+          @options[:select].each { |k, v| data.select! { |i| i[k].eql?(v) } }
         end
       end
 
@@ -337,7 +386,7 @@ module Aspera
         format_style = @options[:table_style].symbolize_keys
         string_list_separator = format_style.delete(:str_lst_sep) || STR_LST_SEP_VERT
         # convert data to string, and keep only display fields
-        object_array.each{ |i| self.class.replace_specific_for_terminal(i, string_list_separator)}
+        object_array.each { |i| self.class.replace_specific_for_terminal(i, string_list_separator) }
         # if table has only one element, and only one field, display the value
         if object_array.length == 1 && fields.length == 1
           Log.log.debug("single element, field: #{fields.first}")
@@ -353,10 +402,10 @@ module Aspera
         Log.dump(:object_array, object_array)
         Log.dump(:fields, fields)
         # convert data to string, and keep only display fields
-        final_table_rows = object_array.map{ |r| fields.map{ |c| r[c].to_s}}
+        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
+        final_table_rows.select! { |i| !(i.is_a?(Hash) && i.empty?) }
+        # fields: list of column names to display
         case @options[:format]
         when :table
           format_style[:border] = :unicode_round if Environment.terminal_supports_unicode?
@@ -392,19 +441,6 @@ module Aspera
         end
         nil
       end
-
-      # remove a fields from the list
-      FIELDS_LESS = '-'
-      # supported output formats
-      DISPLAY_FORMATS = %i[text nagios ruby json jsonpp yaml table csv image].freeze
-      # user output levels
-      DISPLAY_LEVELS = %i[info data error].freeze
-      # column names for single object display in table
-      SINGLE_OBJECT_COLUMN_NAMES = %i[field value].freeze
-      # Terminal: vertical separator for list of strings.
-      STR_LST_SEP_VERT = "\n"
-
-      private_constant :FIELDS_LESS, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :SINGLE_OBJECT_COLUMN_NAMES, :STR_LST_SEP_VERT
     end
   end
 end

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}"}
+                Log.log.info { "#{'HINT:'.bg_green.gray.blink.freeze} #{r}" }
               end
-              break
             end
           end
         end