aspera-cli 4.24.2 → 4.25.0

data/lib/aspera/cli/formatter.rb

@@ -7,6 +7,8 @@ require 'aspera/secret_hider'
 require 'aspera/environment'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/markdown'
+require 'aspera/dot_container'
 require 'terminal-table'
 require 'tty-spinner'
 require 'yaml'
@@ -63,16 +65,32 @@ module Aspera
           end
         end
 
+        # Give Markdown String, or matched data, return formatted string for terminal
         # used by spec_doc
-        def keyword_highlight(value)
-          value.bold
+        # @param match [MatchData,String]
+        def markdown_text(match)
+          if match.is_a?(String)
+            match = Markdown::FORMATS.match(match)
+            Aspera.assert(match)
+          end
+          Aspera.assert_type(match, MatchData)
+          if match[:entity]
+            Aspera.assert_values(match[:entity], '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
 
-        # replace empty values with a readable version on terminal
-        def enhance_display_values_hash(input_hash)
-          stack = [input_hash]
-          until stack.empty?
-            current = stack.pop
+        # Replace special values with a readable version on terminal
+        def replace_specific_for_terminal(input_hash)
+          hash_to_process = [input_hash]
+          until hash_to_process.empty?
+            current = hash_to_process.pop
             current.each do |key, value|
               case value
               when NilClass
@@ -84,54 +102,24 @@ module Aspera
               when Array
                 if value.empty?
                   current[key] = special_format('empty list')
+                elsif value.all?(String)
+                  current[key] = value.join(',')
                 else
                   value.each do |item|
-                    stack.push(item) if item.is_a?(Hash)
+                    hash_to_process.push(item) if item.is_a?(Hash)
                   end
                 end
               when Hash
                 if value.empty?
                   current[key] = special_format('empty dict')
                 else
-                  stack.push(value)
+                  hash_to_process.push(value)
                 end
               end
             end
           end
         end
 
-        # Flatten a Hash into single level hash
-        def flatten_hash(input)
-          Aspera.assert_type(input, Hash)
-          return input if input.empty?
-          flat = {}
-          stack = [[nil, input]]
-          until stack.empty?
-            prefix, current = stack.pop
-            if current.respond_to?(:empty?) && current.empty?
-              flat[prefix] = current
-              next
-            end
-            case current
-            when Hash
-              current.reverse_each{ |k, v| stack.push([[prefix, k].compact.join('.'), v])}
-            when Array
-              if current.all?(String)
-                flat[prefix] = current.join("\n")
-              elsif current.all?{ |i| i.is_a?(Hash) && i.keys == ['name']}
-                flat[prefix] = current.map{ |i| i['name']}.join(', ')
-              elsif current.all?{ |i| i.is_a?(Hash) && i.keys.sort == %w[name value]}
-                stack.push([prefix, current.each_with_object({}){ |i, h| h[i['name']] = i['value']}])
-              else
-                current.each_with_index.reverse_each{ |v, k| stack.push([[prefix, k].compact.join('.'), v])}
-              end
-            else
-              flat[prefix] = current
-            end
-          end
-          flat
-        end
-
         def all_but(list)
           list = [list] unless list.is_a?(Array)
           return list.map{ |i| "#{FIELDS_LESS}#{i}"}.unshift(SpecialValues::ALL)
@@ -166,23 +154,23 @@ module Aspera
         else
           {}
         end
-        options.declare(:format, 'Output format', values: DISPLAY_FORMATS, handler: {o: self, m: :option_handler}, default: :table)
-        options.declare(:output, 'Destination for results', types: String, handler: {o: self, m: :option_handler})
-        options.declare(:display, 'Output only some information', values: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :info)
+        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(:display, 'Output only some information', allowed: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :info)
         options.declare(
           :fields, "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", handler: {o: self, m: :option_handler},
-          types: [String, Array, Regexp, Proc],
+          allowed: [String, Array, Regexp, Proc],
           default: SpecialValues::DEF
         )
-        options.declare(:select, 'Select only some items in lists: column, value', types: [Hash, Proc], handler: {o: self, m: :option_handler})
-        options.declare(:table_style, '(Table) Display style', types: [Hash], handler: {o: self, m: :option_handler}, default: default_table_style)
-        options.declare(:flat_hash, '(Table) Display deep values as additional keys', values: :bool, handler: {o: self, m: :option_handler}, default: true)
+        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: default_table_style)
+        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', values: %i[no yes single],
+          :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', values: :bool, handler: {o: self, m: :option_handler}, default: false)
-        options.declare(:image, 'Options for image display', types: Hash, handler: {o: self, m: :option_handler}, default: {})
+        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: {})
       end
 
       # method accessed by option manager
@@ -321,14 +309,13 @@ module Aspera
             if data.empty?
               display_message(:data, self.class.special_format('empty dict'))
             else
-              data = self.class.flatten_hash(data) if @options[:flat_hash]
+              data = DotContainer.new(data).to_dotted if @options[:flat_hash]
               display_table([data], compute_fields([data], fields), single: true)
             end
           when :object_list
             # :object_list is an Array of Hash, where key=column name
-            Aspera.assert_type(data, Array)
-            Aspera.assert(data.all?(Hash)){"expecting Array of Hash: #{data.inspect}"}
-            data = data.map{ |obj| self.class.flatten_hash(obj)} if @options[:flat_hash]
+            Aspera.assert_array_all(data, Hash){'result'}
+            data = data.map{ |obj| DotContainer.new(obj).to_dotted} if @options[:flat_hash]
             display_table(data, compute_fields(data, fields), single: type.eql?(:single_object))
           when :value_list
             # :value_list is a simple array of values, name of column provided in `name`
@@ -406,8 +393,7 @@ module Aspera
       def filter_list_on_fields(data)
         # by default, keep all data intact
         return data if @options[:fields].eql?(SpecialValues::DEF) && @options[:select].nil?
-        Aspera.assert_type(data, Array){'Filtering fields or select requires result is an Array of Hash'}
-        Aspera.assert(data.all?(Hash)){'Filtering fields or select requires result is an Array of Hash'}
+        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])
@@ -441,7 +427,7 @@ module Aspera
           return
         end
         filter_columns_on_select(object_array)
-        object_array.each{ |i| self.class.enhance_display_values_hash(i)}
+        object_array.each{ |i| self.class.replace_specific_for_terminal(i)}
         # if table has only one element, and only one field, display the value
         if object_array.length == 1 && fields.length == 1
           Log.log.debug("display_table: single element, field: #{fields.first}")

data/lib/aspera/cli/main.rb

@@ -214,6 +214,7 @@ 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::BadIdentifier => e;             exception_info = {e: e, t: 'Identifier'}
         rescue Cli::Error => e;                     exception_info = {e: e, t: 'Tool', usage: true}
         rescue Transfer::Error => e;                exception_info = {e: e, t: 'Transfer'}
@@ -228,6 +229,7 @@ module Aspera
         unless exception_info.nil?
           Log.log.warn(exception_info[:e].message) if Log.instance.logger_type.eql?(:syslog) && exception_info[:security]
           @context.formatter.display_message(:error, "#{Formatter::ERROR_FLASH} #{exception_info[:t]}: #{exception_info[:e].message}")
+          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)
@@ -287,7 +289,6 @@ module Aspera
         @context.options = Manager.new(Info::CMD_NAME, @argv)
         # Formatter adds options
         @context.formatter.declare_options(@context.options)
-        ExtendedValue.instance.default_decoder = @context.options.get_option(:struct_parser)
         # Compare $0 with expected name
         current_prog_name = File.basename($PROGRAM_NAME)
         @context.formatter.display_message(
@@ -349,28 +350,34 @@ module Aspera
       # Define header for manual
       def declare_global_options
         Log.log.debug('declare_global_options')
-        @context.options.declare(:help, 'Show this message', values: :none, short: 'h'){@option_help = true}
-        @context.options.declare(:bash_comp, 'Generate bash completion for command', values: :none){@bash_completion = true}
-        @context.options.declare(:show_config, 'Display parameters used for the provided action', values: :none){@option_show_config = true}
-        @context.options.declare(:version, 'Display version', values: :none, short: 'v'){@context.formatter.display_message(:data, Cli::VERSION); Process.exit(0)} # rubocop:disable Style/Semicolon
+        @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(
           :ui, 'Method to start browser',
-          values: USER_INTERFACES,
+          allowed: USER_INTERFACES,
           handler: {o: Environment.instance, m: :url_method}
         )
         @context.options.declare(
           :invalid_characters, 'Replacement character and invalid filename characters',
           handler: {o: Environment.instance, m: :file_illegal_characters}
         )
-        @context.options.declare(:log_level, 'Log level', values: Log::LEVELS, handler: {o: Log.instance, m: :level})
-        @context.options.declare(:log_format, 'Log formatter', types: [Proc, Logger::Formatter, String], handler: {o: Log.instance, m: :formatter})
-        @context.options.declare(:logger, 'Logging method', values: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
-        @context.options.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron', coerce: Integer, types: Integer)
-        @context.options.declare(:once_only, 'Process only new items (some commands)', values: :bool, default: false)
-        @context.options.declare(:log_secrets, 'Show passwords in logs', values: :bool, handler: {o: SecretHider.instance, m: :log_secrets})
-        @context.options.declare(:clean_temp, 'Cleanup temporary files on exit', values: :bool, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
+        @context.options.declare(:log_level, 'Log level', allowed: Log::LEVELS, handler: {o: Log.instance, m: :level})
+        @context.options.declare(:log_format, 'Log formatter', allowed: [Proc, Logger::Formatter, String], handler: {o: Log.instance, m: :formatter})
+        @context.options.declare(:logger, 'Logging method', allowed: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
+        @context.options.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron', allowed: Allowed::TYPES_INTEGER)
+        @context.options.declare(:once_only, 'Process only new items (some commands)', allowed: Allowed::TYPES_BOOLEAN, default: false)
+        @context.options.declare(:log_secrets, 'Show passwords in logs', allowed: Allowed::TYPES_BOOLEAN, handler: {o: SecretHider.instance, m: :log_secrets})
+        @context.options.declare(:clean_temp, 'Cleanup temporary files on exit', allowed: Allowed::TYPES_BOOLEAN, handler: {o: TempFileManager.instance, m: :cleanup_on_exit})
         @context.options.declare(:temp_folder, 'Temporary folder', handler: {o: TempFileManager.instance, m: :global_temp})
-        @context.options.declare(:pid_file, 'Write process identifier to file, delete on exit', types: String)
+        @context.options.declare(:pid_file, 'Write process identifier to file, delete on exit')
+        @context.options.declare(
+          :parser, 'Default parser for structured parameters and options',
+          handler: {o: ExtendedValue.instance, m: :default_decoder},
+          allowed: ExtendedValue::DEFAULT_DECODERS,
+          default: ExtendedValue::DEFAULT_DECODERS.first
+        )
         # Parse declared options
         @context.options.parse_options!
       end