aspera-cli 4.27.0 → 4.27.1

data/lib/aspera/cli/preset_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/cli/extended_value'
+require 'aspera/dot_container'
 require 'aspera/cli/version'
 require 'aspera/cli/info'
 require 'aspera/log'
@@ -17,10 +18,12 @@ module Aspera
     class PresetManager
       # Reserved keys in the YAML config file
       module Key
-        CONFIG   = 'config'
-        VERSION  = 'version'
-        DEFAULTS = 'default'
-        GLOBAL   = 'global_common_defaults'
+        CONFIG      = 'config'
+        VERSION     = 'version'
+        DEFAULTS    = 'default'
+        GLOBAL      = 'global_common_defaults'
+        # Prefix for comment/meta keys ignored during preset parsing (e.g. _comment)
+        META_PREFIX = '_'
       end
 
       GLOBAL_DEFAULT_KEYWORD = 'GLOBAL'
@@ -55,13 +58,13 @@ module Aspera
       # Read and validate the YAML config file.
       # Sets @config_presets and @checksum_on_disk.
       def read_config_file
-        Log.log.debug{"config file is: #{@config_file}".red}
+        Log.log.debug { "config file is: #{@config_file}".red }
         if File.exist?(@config_file)
-          Log.log.debug{"loading #{@config_file}"}
+          Log.log.debug { "loading #{@config_file}" }
           @config_presets   = Yaml.safe_load(File.read(@config_file))
           @checksum_on_disk = checksum
         else
-          Log.log.warn{"No config file found. New configuration file: #{@config_file}"}
+          Log.log.warn { "No config file found. New configuration file: #{@config_file}" }
           @config_presets = {Key::CONFIG => {Key::VERSION => 'new file'}}
           # @checksum_on_disk remains nil: will be saved on first write
         end
@@ -70,11 +73,11 @@ module Aspera
         Log.log.error('YAML error in config file')
         raise e
       rescue StandardError => e
-        Log.log.debug{"-> #{e.class.name} : #{e}"}
+        Log.log.debug { "-> #{e.class.name} : #{e}" }
         if File.exist?(@config_file)
           new_name = "#{@config_file}.pre#{Cli::VERSION}.manual_conversion_needed"
           File.rename(@config_file, new_name)
-          Log.log.warn{"Renamed config file to #{new_name}."}
+          Log.log.warn { "Renamed config file to #{new_name}." }
           Log.log.warn('Manual Conversion is required. Next time, a new empty file will be created.')
         end
         raise Cli::Error, e.to_s
@@ -83,13 +86,13 @@ module Aspera
       # Save to disk only if content changed since last load/save.
       # @return [Boolean] true if actually written
       def save_if_needed
-        Aspera.assert(!@config_presets.nil?, type: Cli::Error){'no configuration loaded'}
+        Aspera.assert(!@config_presets.nil?, type: Cli::Error) { 'no configuration loaded' }
         current = checksum
         return false if @checksum_on_disk.eql?(current)
         FileUtils.mkdir_p(File.dirname(@config_file))
         Environment.restrict_file_access(File.dirname(@config_file))
-        Log.log.info{"Saving config file: #{@config_file}"}
-        Environment.write_file_restricted(@config_file, force: true){@config_presets.to_yaml}
+        Log.log.info { "Saving config file: #{@config_file}" }
+        Environment.write_file_restricted(@config_file, force: true) { @config_presets.to_yaml }
         @checksum_on_disk = current
         true
       end
@@ -103,7 +106,7 @@ module Aspera
         Aspera.assert(!@config_presets.nil?, 'config_presets shall be defined')
         return unless @use_plugin_defaults
         return unless @config_presets.key?(Key::DEFAULTS)
-        Aspera.assert_type(@config_presets[Key::DEFAULTS], Hash){'default section'}
+        Aspera.assert_type(@config_presets[Key::DEFAULTS], Hash) { 'default section' }
         return unless @config_presets[Key::DEFAULTS].key?(plugin_name_sym.to_s)
         default_name = @config_presets[Key::DEFAULTS][plugin_name_sym.to_s]
         unless @config_presets.key?(default_name)
@@ -115,7 +118,7 @@ module Aspera
           end
           raise Cli::Error, "No such preset: #{default_name}"
         end
-        Aspera.assert_type(@config_presets[default_name], Hash, type: Cli::Error){'preset type'}
+        Aspera.assert_type(@config_presets[default_name], Hash, type: Cli::Error) { 'preset type' }
         default_name
       end
 
@@ -124,38 +127,62 @@ module Aspera
       # @param config_name [String]
       # @param include_path [Array] guard against include loops
       def by_name(config_name, include_path = [])
-        Aspera.assert(!include_path.include?(config_name), type: Cli::Error){'loop in include'}
+        Aspera.assert(!include_path.include?(config_name), type: Cli::Error) { 'loop in include' }
         include_path = include_path.clone
         current = @config_presets
         config_name.split(PRESET_DIG_SEPARATOR).each do |name|
-          Aspera.assert_type(current, Hash, type: Cli::Error){"sub key: #{include_path}"}
+          Aspera.assert_type(current, Hash, type: Cli::Error) { "sub key: #{include_path}" }
           include_path.push(name)
           current = current[name]
-          Aspera.assert(!current.nil?, type: Cli::Error){"Unknown config preset: #{include_path}"}
+          Aspera.assert(!current.nil?, type: Cli::Error) { "Unknown config preset: #{include_path}" }
         end
         current = self.class.deep_clone(current) unless current.is_a?(String)
+        current.delete_if { |k, _| k.to_s.start_with?(Key::META_PREFIX) } if current.is_a?(Hash)
         ExtendedValue.instance.evaluate(current, context: 'preset')
       end
 
       # Set a single key in a preset hash (creates the preset if absent).
+      # If param_name contains dots, it is treated as a dot-path and deep-merged into the preset.
+      # If param_value is nil, the key is deleted instead.
       def set_key(preset, param_name, param_value)
-        Aspera.assert_type(param_name, String, Symbol){'parameter'}
+        Aspera.assert_type(param_name, String, Symbol) { 'parameter' }
         param_name = param_name.to_s
         selected = @config_presets[preset]
         if selected.nil?
-          Log.log.debug{"Unknown preset name: #{preset}, initializing"}
+          Log.log.debug { "Unknown preset name: #{preset}, initializing" }
           selected = @config_presets[preset] = {}
         end
-        Aspera.assert_type(selected, Hash){"#{preset}.#{param_name}"}
-        if selected.key?(param_name)
-          if selected[param_name].eql?(param_value)
-            Log.log.warn{"keeping same value for #{preset}: #{param_name}: #{param_value}"}
-            return
+        Aspera.assert_type(selected, Hash) { "#{preset}.#{param_name}" }
+        if param_name.include?(DotContainer::SEPARATOR)
+          keys = param_name.split(DotContainer::SEPARATOR)
+          # Navigate to the parent hash
+          parent = keys[0..-2].reduce(selected) do |h, k|
+            break nil unless h.is_a?(Hash)
+            h[k]
           end
-          Log.log.warn{"overwriting value for #{param_name}: #{selected[param_name]}"}
+          if param_value.nil?
+            parent&.delete(keys.last)
+            Log.log.info("Deleted: #{preset}: #{param_name}")
+          else
+            # dot-path: build nested hash and deep-merge into existing preset
+            nested = DotContainer.dotted_to_container(keys, param_value)
+            self.class.deep_merge!(selected, nested)
+            Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
+          end
+        elsif param_value.nil?
+          selected.delete(param_name)
+          Log.log.info("Deleted: #{preset}: #{param_name}")
+        else
+          if selected.key?(param_name)
+            if selected[param_name].eql?(param_value)
+              Log.log.warn { "keeping same value for #{preset}: #{param_name}: #{param_value}" }
+              return
+            end
+            Log.log.warn { "overwriting value for #{param_name}: #{selected[param_name]}" }
+          end
+          selected[param_name] = param_value
+          Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
         end
-        selected[param_name] = param_value
-        Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
         nil
       end
 
@@ -192,7 +219,7 @@ module Aspera
       # @return [Hash, nil]
       def lookup_preset(url:, username:)
         url = canonical_url(url)
-        Log.log.debug{"Lookup preset for #{username}@#{url}"}
+        Log.log.debug { "Lookup preset for #{username}@#{url}" }
         @config_presets.each_value do |v|
           next unless v.is_a?(Hash)
           conf_url = v['url'].is_a?(String) ? canonical_url(v['url']) : nil
@@ -209,6 +236,21 @@ module Aspera
         def deep_clone(val)
           Marshal.load(Marshal.dump(val))
         end
+
+        # Recursively merge src into dst in place (dst wins on scalar conflicts).
+        # @param dst [Hash] destination (modified in place)
+        # @param src [Hash] source
+        # @return [Hash] dst
+        def deep_merge!(dst, src)
+          src.each do |k, v|
+            if dst.key?(k) && dst[k].is_a?(Hash) && v.is_a?(Hash)
+              deep_merge!(dst[k], v)
+            else
+              dst[k] = v
+            end
+          end
+          dst
+        end
       end
 
       private
@@ -221,11 +263,11 @@ module Aspera
       # Structural validation + compatibility fixes on @config_presets
       def validate_config_presets!
         Log.dump(:available_presets, @config_presets, level: :trace1)
-        Aspera.assert_type(@config_presets, Hash){'config file YAML'}
-        Aspera.assert(@config_presets.key?(Key::CONFIG)){"Cannot find key: #{Key::CONFIG}"}
+        Aspera.assert_type(@config_presets, Hash) { 'config file YAML' }
+        Aspera.assert(@config_presets.key?(Key::CONFIG)) { "Cannot find key: #{Key::CONFIG}" }
         version = @config_presets[Key::CONFIG][Key::VERSION]
-        Aspera.assert(!version.nil?, type: Cli::Error){'No version found in config section.'}
-        Log.log.debug{"conf version: #{version}"}
+        Aspera.assert(!version.nil?, type: Cli::Error) { 'No version found in config section.' }
+        Log.log.debug { "conf version: #{version}" }
         # Fix bug in 4.4 (creating key "true" in "default" preset)
         @config_presets[Key::DEFAULTS].delete(true) if @config_presets[Key::DEFAULTS].is_a?(Hash)
         # Stamp with current version

data/lib/aspera/cli/result.rb

@@ -56,7 +56,7 @@ module Aspera
             formatter.display_message(:data, formatter.special_format('null (no image)'))
             return
           end
-          Aspera.assert_type(@data, String){'image: URL or blob'}
+          Aspera.assert_type(@data, String) { 'image: URL or blob' }
           # Check if URL
           data =
             begin
@@ -83,7 +83,7 @@ module Aspera
             formatter.display_message(:data, Preview::Terminal.build(data, **formatter.image_options))
           end
         else
-          Aspera.error_unexpected_value(formatter.format_type){'format'}
+          Aspera.error_unexpected_value(formatter.format_type) { 'format' }
         end
       end
     end
@@ -130,7 +130,7 @@ module Aspera
       # Status result (success, complete, etc.)
       class Status < Result
         def initialize(data)
-          Aspera.assert_type(data, String){'status result data'}
+          Aspera.assert_type(data, String) { 'status result data' }
           super(data: data)
         end
 
@@ -157,7 +157,7 @@ module Aspera
       # Text result
       class Text < Result
         def initialize(data)
-          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError){'text result data'}
+          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError) { 'text result data' }
           super(data: data)
         end
 
@@ -185,7 +185,7 @@ module Aspera
       # Image result (URL or blob)
       class Image < Result
         def initialize(data)
-          Aspera.assert_type(data, String, NilClass){'image result data'}
+          Aspera.assert_type(data, String, NilClass) { 'image result data' }
           super(data: data)
         end
 
@@ -199,7 +199,7 @@ module Aspera
       # Single object result (Hash)
       class SingleObject < Result
         def initialize(data, fields: nil)
-          Aspera.assert_type(data, Hash){'single object result data'}
+          Aspera.assert_type(data, Hash) { 'single object result data' }
           super(data: data, fields: fields)
         end
 
@@ -214,7 +214,7 @@ module Aspera
             # Create an Image result and format it
             Image.new(@data[fields.first]).format(formatter)
           when :table, :csv
-            Aspera.assert_type(@data, Hash){'result'}
+            Aspera.assert_type(@data, Hash) { 'result' }
             if @data.empty?
               formatter.display_message(:data, formatter.special_format('empty dict'))
             else
@@ -236,8 +236,8 @@ module Aspera
         # @param fields [Array<String>, Proc, nil] Fields to display in table/csv format
         # @param total [Integer, nil] Total number of items available (for pagination display)
         def initialize(data, fields: nil, total: nil)
-          Aspera.assert_array_all(data, Hash, type: ArgumentError){'object list result data'}
-          Aspera.assert_type(total, Integer, NilClass){'total'}
+          Aspera.assert_array_all(data, Hash, type: ArgumentError) { 'object list result data' }
+          Aspera.assert_type(total, Integer, NilClass) { 'total' }
           super(data: data, fields: fields)
           @total = total
         end
@@ -250,8 +250,8 @@ module Aspera
             Aspera.assert(@data.length == 1, 'image display requires a single result', type: Cli::BadArgument)
             SingleObject.new(@data.first).format(formatter)
           when :table, :csv
-            Aspera.assert_array_all(@data, Hash){'result'}
-            data = formatter.flat_hash? ? @data.map{ |obj| DotContainer.new(obj).to_dotted} : @data
+            Aspera.assert_array_all(@data, Hash) { 'result' }
+            data = formatter.flat_hash? ? @data.map { |obj| DotContainer.new(obj).to_dotted } : @data
             formatter.display_table(data, formatter.compute_fields(data, @fields), single: false)
           else
             super
@@ -264,8 +264,8 @@ module Aspera
         attr_reader :name
 
         def initialize(data, name: 'id')
-          Aspera.assert_type(data, Array){'value list result data'}
-          Aspera.assert_type(name, String){'value list name'}
+          Aspera.assert_type(data, Array) { 'value list result data' }
+          Aspera.assert_type(name, String) { 'value list name' }
           super(data: data)
           @name = name
         end
@@ -273,7 +273,7 @@ module Aspera
         def format(formatter)
           case formatter.format_type
           when :table, :csv
-            formatter.display_table(@data.map{ |i| {@name => i}}, [@name])
+            formatter.display_table(@data.map { |i| {@name => i} }, [@name])
           when :text
             formatter.display_message(:data, @data.join("\n"))
           when :ruby
@@ -314,6 +314,8 @@ module Aspera
               result = res if res.is_a?(Hash)
               # TODO: remove when faspio gw api fixes this
               result = res.first if res.is_a?(Array) && res.first.is_a?(Hash)
+              # Ensure the id_result key is always present even when the API response uses a different key name
+              result[id_result] = item unless result.key?(id_result)
               result['status'] = "#{command}#{'e' unless command.to_s.end_with?('e')}d".gsub(/yed$/, 'ied')
             rescue StandardError => e
               raise e if bfail
@@ -347,11 +349,11 @@ module Aspera
             unsupported_types = all_types - scalar_types
             return ValueList.new(data, name: 'list') if unsupported_types.empty?
 
-            Aspera.error_unexpected_value(unsupported_types){'list item types'}
+            Aspera.error_unexpected_value(unsupported_types) { 'list item types' }
           when String, Integer, Symbol
             Text.new(data)
           else
-            Aspera.error_unexpected_value(data.class.name){'result type'}
+            Aspera.error_unexpected_value(data.class.name) { 'result type' }
           end
         end
       end

data/lib/aspera/cli/runner.rb

@@ -126,18 +126,18 @@ module Aspera
         lock_port = @context.options.get_option(:lock_port)
         if !lock_port.nil?
           begin
-            Log.log.debug{"Opening lock port #{lock_port}"}
+            Log.log.debug { "Opening lock port #{lock_port}" }
             @tcp_server = TCPServer.new('127.0.0.1', lock_port)
           rescue StandardError => e
             execute_command = false
-            Log.log.warn{"Another instance is already running (#{e.message})."}
+            Log.log.warn { "Another instance is already running (#{e.message})." }
           end
         end
         pid_file = @context.options.get_option(:pid_file)
         if !pid_file.nil?
           File.write(pid_file, Process.pid)
-          Log.log.debug{"Wrote pid #{Process.pid} to #{pid_file}"}
-          at_exit{File.delete(pid_file)}
+          Log.log.debug { "Wrote pid #{Process.pid} to #{pid_file}" }
+          at_exit { File.delete(pid_file) }
         end
         begin
           result = command_plugin.execute_action if execute_command
@@ -174,25 +174,33 @@ 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}"} unless exception_info[:e].is_a?(Cli::SchemaRequest)
-          Log.log.debug{(['Backtrace:'] + exception_info[:e].backtrace).join("\n")} if exception_info[:debug]
+          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]
           Hints.hint_for(exception_info[:e], @context.formatter)
           if exception_info[:e].is_a?(Cli::SchemaRequest)
-            Log.log.info{"#{exception_info[:t]}: #{exception_info[:e].message}"}
+            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.'}
+              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))
+              reader = Schema::Registry.instance.reader(schema_path)
+              rows   = reader.to_rows.map do |row|
+                if row.key?('enum')
+                  row = row.dup
+                  row['type'] = 'enum'
+                  row['description'] = "#{row['description']}\nAllowed: #{row['enum'].join(', ')}"
+                end
+                row
+              end
+              @context.formatter.display_results(Result::ObjectList.new(rows, fields: %w[name type required description]))
             end
           end
         end
         # 2- processing of unprocessed arguments (skip when help was displayed: sub-commands are not consumed)
         unless @option_help
           @context.options&.final_errors&.each do |msg|
-            Log.log.error{"Argument: #{msg}"}
+            Log.log.error { "Argument: #{msg}" }
             exception_info = {e: Exception.new(msg), t: 'UnusedArg'} if exception_info.nil?
           end
         end
@@ -236,7 +244,7 @@ module Aspera
             when :type    then Log.instance.logger_type = v.to_sym
             when :format  then Log.instance.formatter = v
             when :secrets then SecretHider.instance.log_secrets = BoolValue.true?(v)
-            else Aspera.error_unexpected_value(k){'log sub-option (level, type, format, secrets)'}
+            else Aspera.error_unexpected_value(k) { 'log sub-option (level, type, format, secrets)' }
             end
           end
         when :get
@@ -259,9 +267,9 @@ module Aspera
         lines = [@context.options.help_text(banner: app_banner)]
         if plugin.nil?
           # Top-level: list all available plugins
-          plugin_names = Plugins::Factory.instance.plugin_list.reject{ |s| s.eql?(COMMAND_CONFIG)}.sort
+          plugin_names = Plugins::Factory.instance.plugin_list.reject { |s| s.eql?(COMMAND_CONFIG) }.sort
           lines << "\nPLUGINS"
-          col_w = plugin_names.map{ |n| n.to_s.length}.max + 2
+          col_w = plugin_names.map { |n| n.to_s.length }.max + 2
           plugin_names.each do |name|
             app = Plugins::Factory.instance.plugin_class(name).application_name
             lines << "    #{name.to_s.ljust(col_w)}  #{app}"
@@ -283,29 +291,42 @@ module Aspera
               end
             end
           end
+          if cmds.none?
+            leaf_spec = registry[path]
+            leaf_spec&.arguments&.each do |arg_spec|
+              argument = arg_spec.mandatory ? "<#{arg_spec.name}>" : "[#{arg_spec.name}]"
+              argument += '...' if arg_spec.multiple
+              label += " #{argument}"
+            end
+          end
           if cmds.any?
-            # Intermediate node: list subcommands
-            lines << "\nCOMMANDS: #{label}"
-            col_w = cmds.keys.map{ |k| k.to_s.length}.max + 2
+            # Intermediate node: show current command + description, then list subcommands
+            lines << "\nCOMMAND: #{label}"
+            node_spec = path.empty? ? nil : registry[path]
+            lines << "  #{node_spec.description}" if node_spec&.description
+            lines << "\n  SUBCOMMANDS:"
+            col_w = cmds.keys.map { |k| k.to_s.length }.max + 2
             cmds.each do |id, spec|
               lines << "    #{id.to_s.ljust(col_w)}  #{spec.description}"
             end
           else
-            # Leaf node: show description + arguments
+            # Leaf node: show description + arguments.
             spec = registry[path]
             lines << "\nCOMMAND: #{label}"
             lines << "    #{spec.description}" if spec&.description
             display_args = spec&.arguments || []
             # transfer_paths commands use --sources for the file list; default is positional args (@args)
             if spec&.transfer_paths
-              file_desc = spec.transfer_paths == :receive \
-                ? "Remote path(s) to download (default --sources=#{TransferAgent::FILE_LIST_FROM_ARGS}; see also --to-folder)" \
-                : "Source file(s) to upload (default --sources=#{TransferAgent::FILE_LIST_FROM_ARGS}; see also --src-type, --to-folder)"
+              file_desc = if spec.transfer_paths == :receive
+                "Remote path(s) to download (default --sources=#{TransferAgent::FILE_LIST_FROM_ARGS}; see also --to-folder)"
+              else
+                "Source file(s) to upload (default --sources=#{TransferAgent::FILE_LIST_FROM_ARGS}; see also --src-type, --to-folder)"
+              end
               display_args += [ArgumentSpec.new(name: :source_file, description: file_desc, mandatory: false, multiple: true)]
             end
             if display_args.any?
               lines << "\nARGUMENTS:"
-              col_w = display_args.map{ |a| a.name.to_s.length}.max + 2
+              col_w = display_args.map { |a| a.name.to_s.length }.max + 2
               display_args.each do |arg|
                 flag  = arg.mandatory ? arg.name.to_s : "[#{arg.name}]"
                 flag += '...' if arg.multiple
@@ -315,16 +336,31 @@ module Aspera
                 when nil         then ''
                 else arg.type.name
                 end
-                hint  = arg.type.eql?(Hash) && arg.schema ? "  (use 'help' as value to see schema)" : ''
+                hint  = Array(arg.type).include?(Hash) && arg.schema ? '  (schema shown below)' : ''
                 lines << "    #{flag.ljust(col_w)}  #{arg.description || types}#{hint}"
+                lines.concat(schema_help_lines(arg)) if Array(arg.type).include?(Hash) && arg.schema
               end
             end
-            lines << "\nTIP: use --query=help to list available query parameters" if spec&.query_schema || spec&.entity_execute&.[](:query_schema)
+            lines << "\nTIP: use --query=help to list available query parameters" if spec&.query_schema
           end
         end
         lines.join("\n")
       end
 
+      # Render the structure of a Hash argument's JSON schema in command help.
+      # @param arg [ArgumentSpec]
+      # @return [Array<String>]
+      def schema_help_lines(arg)
+        builder = Schema::Documentation.new(TerminalFormatter, Schema::Registry.instance.reader(arg.schema)).build
+        rows = builder.rows.reject { |row| row['type'].eql?('&nbsp;') }.map do |row|
+          builder.columns.map { |column| row[column].to_s }
+        end
+        style = {}
+        style[:border] = :unicode_round if Environment.terminal_supports_unicode?
+        table = Terminal::Table.new(headings: builder.columns, rows: rows, style: style).to_s
+        ["\n    SCHEMA: #{arg.name}", table.lines.map { |line| "    #{line.chomp}" }.join("\n")]
+      end
+
       # 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
@@ -335,13 +371,13 @@ module Aspera
         @context.formatter = Formatter.new
         # Create command line manager with arguments
         @context.options = Parser.new(Info::CMD_NAME, @argv)
-        ExtendedValue.instance.on(EXTEND_ARGS){ |v| @context.options.args_as_extended(v)}
+        ExtendedValue.instance.on(EXTEND_ARGS) { |v| @context.options.args_as_extended(v) }
         # Formatter: declare metadata (class method), then bind to the instance
         Formatter.declare_options(@context.options)
         @context.formatter.bind_options(@context.options)
         # Compare $0 with expected name
         current_prog_name = File.basename($PROGRAM_NAME)
-        Aspera.assert(current_prog_name.eql?(Info::CMD_NAME), type: :warn){"Please use '#{Info::CMD_NAME}' instead of '#{current_prog_name}'"}
+        Aspera.assert(current_prog_name.eql?(Info::CMD_NAME), type: :warn) { "Please use '#{Info::CMD_NAME}' instead of '#{current_prog_name}'" }
         # Declare and parse global options
         declare_global_options
         # Bootstrap: populate context services (main_folder, persistency, presets, http_config,
@@ -351,7 +387,7 @@ module Aspera
         @bootstrapper = Bootstrapper.new(@context)
         @bootstrapper.run(
           gem_plugins_folder: Plugins::Config.gem_plugins_folder,
-          vault_value_cb:     ->(v){@context.config.vault_value(v)}
+          vault_value_cb:     ->(v) { @context.config.vault_value(v) }
         )
         # Do not display config commands if help is asked
         @context.man_header = false
@@ -381,7 +417,7 @@ module Aspera
           #{t}#{Info::CMD_NAME} -- a command line tool for Aspera Applications (v#{Cli::VERSION})
 
           SYNOPSIS
-          #{t}#{Info::CMD_NAME} COMMANDS [OPTIONS] [ARGS]
+          #{t}#{Info::CMD_NAME} [GLOBAL_OPTIONS] <command> [OPTIONS] [ARGS]
 
           DESCRIPTION
           #{t}Use Aspera application to perform operations on command line.
@@ -400,8 +436,8 @@ module Aspera
           OPTIONS
           #{t}Options begin with a '-' (minus), and value is provided on command line.
           #{t}Special values are supported beginning with special prefix @pfx:, where pfx is one of:
-          #{t}#{ExtendedValue.instance.modifiers.join(', ')}
-          #{t}Dates format is 'DD-MM-YY HH:MM:SS', or 'now' or '-<num>h'
+          #{t}#{ExtendedValue.instance.modifiers.reject(&:empty?).join(', ')}
+          #{t}Dates format is 'YYYY-MM-DD HH:MM:SS', or 'now' or '-<num>h'
 
           ARGS
           #{t}Some commands require mandatory arguments, e.g. a path.
@@ -412,12 +448,12 @@ module Aspera
       # @return [nil]
       def declare_global_options
         Log.log.debug('declare_global_options')
-        @context.options.declare(:help, description: 'Show this message', allowed: Allowed::TYPES_NONE, short: 'h') do
+        @context.options.declare(:help, description: 'Show this message', allowed: Type::NONE, short: 'h') do
           @option_help = true
           @context.options.help_requested = true
         end
-        @context.options.declare(:show_config, description: 'Display parameters used for the provided action', allowed: Allowed::TYPES_NONE){@option_show_config = true}
-        @context.options.declare(:version, description: '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(:show_config, description: 'Display parameters used for the provided action', allowed: Type::NONE) { @option_show_config = true }
+        @context.options.declare(:version, description: 'Display version', allowed: Type::NONE, short: 'v') { @context.formatter.display_message(:data, Cli::VERSION); Process.exit(0) } # rubocop:disable Style/Semicolon
         @context.options.declare(
           :ui, description: 'Method to start browser',
           allowed: USER_INTERFACES,
@@ -431,10 +467,10 @@ module Aspera
         @context.options.declare(:log_format, description: 'Log formatter', allowed: [Proc, Logger::Formatter, String], handler: {o: Log.instance, m: :formatter})
         @context.options.declare(:logger, description: 'Logging method', allowed: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
         @context.options.declare(:log, description: 'Logging options (dot-notation: level, type, format, secrets)', handler: {o: self, m: :option_log}, schema: Schema::Registry::LOG_OPTIONS)
-        @context.options.declare(:lock_port, description: 'Prevent dual execution of a command, e.g. in cron', allowed: Allowed::TYPES_INTEGER)
-        @context.options.declare(:once_only, description: 'Process only new items (some commands)', allowed: Allowed::TYPES_BOOLEAN, default: false)
-        @context.options.declare(:log_secrets, description: 'Show passwords in logs', allowed: Allowed::TYPES_BOOLEAN, handler: {o: SecretHider.instance, m: :log_secrets})
-        @context.options.declare(:clean_temp, description: 'Cleanup temporary files on exit', allowed: Allowed::TYPES_BOOLEAN, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
+        @context.options.declare(:lock_port, description: 'Prevent dual execution of a command, e.g. in cron', allowed: Type::INTEGER)
+        @context.options.declare(:once_only, description: 'Process only new items (some commands)', allowed: Type::BOOLEAN, default: false)
+        @context.options.declare(:log_secrets, description: 'Show passwords in logs', allowed: Type::BOOLEAN, handler: {o: SecretHider.instance, m: :log_secrets})
+        @context.options.declare(:clean_temp, description: 'Cleanup temporary files on exit', allowed: Type::BOOLEAN, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
         @context.options.declare(:temp_folder, description: 'Temporary folder', handler: {o: TempFileManager.instance, m: :global_temp})
         @context.options.declare(:pid_file, description: 'Write process identifier to file, delete on exit')
         @context.options.declare(
@@ -452,10 +488,10 @@ module Aspera
       # @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})"}
+        Log.log.debug { "get_plugin_instance_with_options(#{plugin_name_sym})" }
         # Load default preset options for this plugin from config file
         default_config_name = @context.presets.plugin_default_name(plugin_name_sym)
-        Log.log.debug{"add_plugin_default_preset:#{plugin_name_sym}:#{default_config_name}"}
+        Log.log.debug { "add_plugin_default_preset:#{plugin_name_sym}:#{default_config_name}" }
         @context.options.add_option_preset(@context.presets.by_name(default_config_name), 'default_plugin', override: false) unless default_config_name.nil?
         command_plugin = Plugins::Factory.instance.create(plugin_name_sym, context: @context)
         return command_plugin

data/lib/aspera/cli/secret_finder.rb

@@ -29,7 +29,7 @@ module Aspera
         if secret.eql?(PRESET_MAGIC)
           conf = @presets.lookup_preset(url: url, username: username)
           if conf.is_a?(Hash)
-            Log.log.debug{"Found preset #{conf} with URL and username"}
+            Log.log.debug { "Found preset #{conf} with URL and username" }
             secret = conf['password']
           end
         end