aspera-cli 4.10.0 → 4.11.0

data/lib/aspera/ascmd.rb

@@ -20,32 +20,32 @@ module Aspera
     # @param [Symbol] one of OPERATIONS
     # @param [Array] parameters for "as" command
     # @return result of command, type depends on command (bool, array, hash)
-    def execute_single(action_sym,args=nil)
+    def execute_single(action_sym, args=nil)
       # concatenate arguments, enclose in double quotes, protect backslash and double quotes, add "as_" command and as_exit
       stdin_input = (args || []).map{|v| '"' + v.gsub(/["\\]/n) {|s| '\\' + s } + '"'}.unshift('as_' + action_sym.to_s).join(' ') + "\nas_exit\n"
       # execute, get binary output
-      bytebuffer = @command_executor.execute('ascmd',stdin_input).unpack('C*')
+      bytebuffer = @command_executor.execute('ascmd', stdin_input).unpack('C*')
       # get hash or table result
-      result = self.class.parse(bytebuffer,:result)
+      result = self.class.parse(bytebuffer, :result)
       raise 'ERROR: unparsed bytes remaining' unless bytebuffer.empty?
       # get and delete info,always present in results
       system_info = result[:info]
       result.delete(:info)
       # make single file result like a folder
-      if result.has_key?(:file);result[:dir] = [result[:file]];result.delete(:file);end
+      result[:dir] = [result.delete(:file)] if result.key?(:file)
       # add type field for stats
-      if result.has_key?(:dir)
+      if result.key?(:dir)
         result[:dir].each do |file|
-          if file.has_key?(:smode)
+          if file.key?(:smode)
             # Converts the first character of the file mode (see 'man ls') into a type.
-            file[:type] = case file[:smode][0,1];when 'd' then:directory;when '-' then:file;when 'l' then:link;else;:other;end
+            file[:type] = case file[:smode][0, 1]; when 'd' then:directory; when '-' then:file; when 'l' then:link; else; :other; end # rubocop:disable Style/Semicolon
           end
         end
       end
       # for info, second overrides first, so restore it
-      case result.keys.length;when 0 then result = system_info;when 1 then result = result[result.keys.first];else raise 'error';end
+      case result.keys.length; when 0 then result = system_info; when 1 then result = result[result.keys.first]; else raise 'error'; end
       # raise error as exception
-      raise Error.new(result[:errno],result[:errstr],action_sym,args) if
+      raise Error.new(result[:errno], result[:errstr], action_sym, args) if
         result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map{|i|i[:name]}.sort)
       return result
     end # execute_single
@@ -53,7 +53,8 @@ module Aspera
     # This exception is raised when +ascmd+ returns an error.
     class Error < StandardError
       attr_reader :errno, :errstr, :command, :args
-      def initialize(errno,errstr,cmd,args);super();@errno = errno;@errstr = errstr;@command = cmd;@args = args;end
+
+      def initialize(errno, errstr, cmd, args); super(); @errno = errno; @errstr = errstr; @command = cmd; @args = args; end # rubocop:disable Style/Semicolon
 
       def message; "ascmd: (#{errno}) #{errstr}"; end
 
@@ -64,46 +65,46 @@ module Aspera
     # key = name of type
     TYPES_DESCR = {
       result: {decode: :field_list,
-               fields: [{name: :file,is_a: :stat},{name: :dir,is_a: :stat,special: :substruct},{name: :size,is_a: :size},{name: :error,is_a: :error},
-                        {name: :info,is_a: :info},{name: :success,is_a: nil,special: :return_true},{name: :exit,is_a: nil},
-                        {name: :df,is_a: :mnt,special: :restart_on_first},{name: :md5sum,is_a: :md5sum}]},
+               fields: [{name: :file, is_a: :stat}, {name: :dir, is_a: :stat, special: :substruct}, {name: :size, is_a: :size}, {name: :error, is_a: :error},
+                        {name: :info, is_a: :info}, {name: :success, is_a: nil, special: :return_true}, {name: :exit, is_a: nil},
+                        {name: :df, is_a: :mnt, special: :restart_on_first}, {name: :md5sum, is_a: :md5sum}]},
       stat:   {decode: :field_list,
-               fields: [{name: :name,is_a: :zstr},{name: :size,is_a: :int64},{name: :mode,is_a: :int32,check: nil},{name: :zmode,is_a: :zstr},
-                        {name: :uid,is_a: :int32,check: nil},{name: :zuid,is_a: :zstr},{name: :gid,is_a: :int32,check: nil},{name: :zgid,is_a: :zstr},
-                        {name: :ctime,is_a: :epoch},{name: :zctime,is_a: :zstr},{name: :mtime,is_a: :epoch},{name: :zmtime,is_a: :zstr},
-                        {name: :atime,is_a: :epoch},{name: :zatime,is_a: :zstr},{name: :symlink,is_a: :zstr},{name: :errno,is_a: :int32},
-                        {name: :errstr,is_a: :zstr}]},
+               fields: [{name: :name, is_a: :zstr}, {name: :size, is_a: :int64}, {name: :mode, is_a: :int32, check: nil}, {name: :zmode, is_a: :zstr},
+                        {name: :uid, is_a: :int32, check: nil}, {name: :zuid, is_a: :zstr}, {name: :gid, is_a: :int32, check: nil}, {name: :zgid, is_a: :zstr},
+                        {name: :ctime, is_a: :epoch}, {name: :zctime, is_a: :zstr}, {name: :mtime, is_a: :epoch}, {name: :zmtime, is_a: :zstr},
+                        {name: :atime, is_a: :epoch}, {name: :zatime, is_a: :zstr}, {name: :symlink, is_a: :zstr}, {name: :errno, is_a: :int32},
+                        {name: :errstr, is_a: :zstr}]},
       info:   {decode: :field_list,
-               fields: [{name: :platform,is_a: :zstr},{name: :version,is_a: :zstr},{name: :lang,is_a: :zstr},{name: :territory,is_a: :zstr},
-                        {name: :codeset,is_a: :zstr},{name: :lc_ctype,is_a: :zstr},{name: :lc_numeric,is_a: :zstr},{name: :lc_time,is_a: :zstr},
-                        {name: :lc_all,is_a: :zstr},{name: :dev,is_a: :zstr,special: :multiple},{name: :browse_caps,is_a: :zstr},
-                        {name: :protocol,is_a: :zstr}]},
+               fields: [{name: :platform, is_a: :zstr}, {name: :version, is_a: :zstr}, {name: :lang, is_a: :zstr}, {name: :territory, is_a: :zstr},
+                        {name: :codeset, is_a: :zstr}, {name: :lc_ctype, is_a: :zstr}, {name: :lc_numeric, is_a: :zstr}, {name: :lc_time, is_a: :zstr},
+                        {name: :lc_all, is_a: :zstr}, {name: :dev, is_a: :zstr, special: :multiple}, {name: :browse_caps, is_a: :zstr},
+                        {name: :protocol, is_a: :zstr}]},
       size:   {decode: :field_list,
-               fields: [{name: :size,is_a: :int64},{name: :fcount,is_a: :int32},{name: :dcount,is_a: :int32},{name: :failed_fcount,is_a: :int32},
-                        {name: :failed_dcount,is_a: :int32}]},
+               fields: [{name: :size, is_a: :int64}, {name: :fcount, is_a: :int32}, {name: :dcount, is_a: :int32}, {name: :failed_fcount, is_a: :int32},
+                        {name: :failed_dcount, is_a: :int32}]},
       error:  {decode: :field_list,
-               fields: [{name: :errno,is_a: :int32},{name: :errstr,is_a: :zstr}]},
+               fields: [{name: :errno, is_a: :int32}, {name: :errstr, is_a: :zstr}]},
       mnt:    {decode: :field_list,
-               fields: [{name: :fs,is_a: :zstr},{name: :dir,is_a: :zstr},{name: :is_a,is_a: :zstr},{name: :total,is_a: :int64},
-                        {name: :used,is_a: :int64},{name: :free,is_a: :int64},{name: :fcount,is_a: :int64},{name: :errno,is_a: :int32},
-                        {name: :errstr,is_a: :zstr}]},
-      md5sum: {decode: :field_list,fields: [{name: :md5sum,is_a: :zstr}]},
-      int8:   {decode: :base,unpack: 'C',size: 1},
-      int32:  {decode: :base,unpack: 'L>',size: 4},
-      int64:  {decode: :base,unpack: 'Q>',size: 8},
-      epoch:  {decode: :base,unpack: 'Q>',size: 8},
-      zstr:   {decode: :base,unpack: 'Z*'},
+               fields: [{name: :fs, is_a: :zstr}, {name: :dir, is_a: :zstr}, {name: :is_a, is_a: :zstr}, {name: :total, is_a: :int64},
+                        {name: :used, is_a: :int64}, {name: :free, is_a: :int64}, {name: :fcount, is_a: :int64}, {name: :errno, is_a: :int32},
+                        {name: :errstr, is_a: :zstr}]},
+      md5sum: {decode: :field_list, fields: [{name: :md5sum, is_a: :zstr}]},
+      int8:   {decode: :base, unpack: 'C', size: 1},
+      int32:  {decode: :base, unpack: 'L>', size: 4},
+      int64:  {decode: :base, unpack: 'Q>', size: 8},
+      epoch:  {decode: :base, unpack: 'Q>', size: 8},
+      zstr:   {decode: :base, unpack: 'Z*'},
       blist:  {decode: :buffer_list}
     }.freeze
 
     # protocol enum start at one, but array index start at zero
     ENUM_START = 1
 
-    private_constant :TYPES_DESCR,:ENUM_START
+    private_constant :TYPES_DESCR, :ENUM_START
 
     class << self
       # get description of structure's field, @param struct_name, @param typed_buffer provides field name
-      def field_description(struct_name,typed_buffer)
+      def field_description(struct_name, typed_buffer)
         result = TYPES_DESCR[struct_name][:fields][typed_buffer[:btype] - ENUM_START]
         raise "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" if result.nil?
         return result
@@ -112,54 +113,55 @@ module Aspera
       # decodes the provided buffer as provided type name
       # @return a decoded type.
       # :base : value, :buffer_list : an array of {btype,buffer}, :field_list : a hash, or array
-      def parse(buffer,type_name,indent_level=nil)
+      def parse(buffer, type_name, indent_level=nil)
         indent_level = (indent_level || -1) + 1
         type_descr = TYPES_DESCR[type_name]
         raise "Unexpected type #{type_name}" if type_descr.nil?
-        Log.log.debug("#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0,16]}...".red)
+        Log.log.debug{"#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0, 16]}...".red}
         result = nil
         case type_descr[:decode]
         when :base
           num_bytes = type_name.eql?(:zstr) ? buffer.length : type_descr[:size]
           raise 'ERROR:not enough bytes' if buffer.length < num_bytes
-          byte_array = buffer.shift(num_bytes);byte_array = [byte_array] unless byte_array.is_a?(Array)
+          byte_array = buffer.shift(num_bytes)
+          byte_array = [byte_array] unless byte_array.is_a?(Array)
           result = byte_array.pack('C*').unpack1(type_descr[:unpack])
-          Log.log.debug("#{'   .' * indent_level}-> base:#{byte_array} -> #{result}")
+          Log.log.debug{"#{'   .' * indent_level}-> base:#{byte_array} -> #{result}"}
           result = Time.at(result) if type_name.eql?(:epoch)
         when :buffer_list
           result = []
-          while !buffer.empty?
-            btype = parse(buffer,:int8,indent_level)
-            length = parse(buffer,:int32,indent_level)
+          until buffer.empty?
+            btype = parse(buffer, :int8, indent_level)
+            length = parse(buffer, :int32, indent_level)
             raise 'ERROR:not enough bytes' if buffer.length < length
             value = buffer.shift(length)
-            result.push({btype: btype,buffer: value})
-            Log.log.debug("#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}")
+            result.push({btype: btype, buffer: value})
+            Log.log.debug{"#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}"}
           end
         when :field_list
           # by default the result is one struct
           result = {}
           # get individual binary fields
-          parse(buffer,:blist,indent_level).each do |typed_buffer|
+          parse(buffer, :blist, indent_level).each do |typed_buffer|
             # what type of field is it ?
-            field_info = field_description(type_name,typed_buffer)
-            Log.log.debug("#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green)
+            field_info = field_description(type_name, typed_buffer)
+            Log.log.debug{"#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green}
             case field_info[:special]
             when nil
-              result[field_info[:name]] = parse(typed_buffer[:buffer],field_info[:is_a],indent_level)
+              result[field_info[:name]] = parse(typed_buffer[:buffer], field_info[:is_a], indent_level)
             when :return_true
               result[field_info[:name]] = true
             when :substruct
-              result[field_info[:name]] = parse(typed_buffer[:buffer],:blist,indent_level).map{|r|parse(r[:buffer],field_info[:is_a],indent_level)}
+              result[field_info[:name]] = parse(typed_buffer[:buffer], :blist, indent_level).map{|r|parse(r[:buffer], field_info[:is_a], indent_level)}
             when :multiple
               result[field_info[:name]] ||= []
-              result[field_info[:name]].push(parse(typed_buffer[:buffer],field_info[:is_a],indent_level))
+              result[field_info[:name]].push(parse(typed_buffer[:buffer], field_info[:is_a], indent_level))
             when :restart_on_first
               fl = result[field_info[:name]] = []
-              parse(typed_buffer[:buffer],:blist,indent_level).map do |tb|
+              parse(typed_buffer[:buffer], :blist, indent_level).map do |tb|
                 fl.push({}) if tb[:btype].eql?(ENUM_START)
-                fi = field_description(field_info[:is_a],tb)
-                fl.last[fi[:name]] = parse(tb[:buffer],fi[:is_a],indent_level)
+                fi = field_description(field_info[:is_a], tb)
+                fl.last[fi[:name]] = parse(tb[:buffer], fi[:is_a], indent_level)
               end
             end
           end

data/lib/aspera/ats_api.rb

@@ -4,7 +4,7 @@ require 'aspera/log'
 require 'aspera/rest'
 
 module Aspera
-  class AtsApi < Rest
+  class AtsApi < Aspera::Rest
     # currently supported clouds
     # Note to Aspera: shall be an API call
     CLOUD_NAME = {
@@ -19,7 +19,7 @@ module Aspera
     private_constant :CLOUD_NAME
 
     class << self
-      def base_url;'https://ats.aspera.io';end
+      def base_url; 'https://ats.aspera.io'; end
     end
 
     def initialize
@@ -28,14 +28,14 @@ module Aspera
       @all_servers_cache = nil
     end
 
-    def cloud_names;CLOUD_NAME;end
+    def cloud_names; CLOUD_NAME; end
 
     # all available ATS servers
     # NOTE to Aspera: an API shall be created to retrieve all servers at once
     def all_servers
       if @all_servers_cache.nil?
         @all_servers_cache = []
-        CLOUD_NAME.keys.each do |name|
+        CLOUD_NAME.each_key do |name|
           read("servers/#{name.to_s.upcase}")[:data].each do |i|
             @all_servers_cache.push(i)
           end

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -6,33 +6,36 @@ require 'aspera/cli/plugin'
 module Aspera
   module Cli
     # base class for applications supporting basic authentication
-    class BasicAuthPlugin < Plugin
+    class BasicAuthPlugin < Aspera::Cli::Plugin
       class << self
         def register_options(env)
-          env[:options].add_opt_simple(:url,'URL of application, e.g. https://org.asperafiles.com')
-          env[:options].add_opt_simple(:username,'username to log in')
-          env[:options].add_opt_simple(:password,"user's password")
+          env[:options].add_opt_simple(:url, 'URL of application, e.g. https://org.asperafiles.com')
+          env[:options].add_opt_simple(:username, 'username to log in')
+          env[:options].add_opt_simple(:password, "user's password")
           env[:options].parse_options!
         end
       end
 
       def initialize(env)
         super(env)
-        return if env[:skip_basic_auth_options]
-        self.class.register_options(env)
+        self.class.register_options(env) unless env[:skip_basic_auth_options]
       end
 
       # returns a Rest object with basic auth
-      def basic_auth_api(subpath=nil)
-        api_url = options.get_option(:url,is_type: :mandatory)
+      def basic_auth_params(subpath=nil)
+        api_url = options.get_option(:url, is_type: :mandatory)
         api_url = api_url + '/' + subpath unless subpath.nil?
-        return Rest.new({
+        return {
           base_url: api_url,
           auth:     {
             type:     :basic,
-            username: options.get_option(:username,is_type: :mandatory),
-            password: options.get_option(:password,is_type: :mandatory)
-          }})
+            username: options.get_option(:username, is_type: :mandatory),
+            password: options.get_option(:password, is_type: :mandatory)
+          }}
+      end
+
+      def basic_auth_api(subpath=nil)
+        return Rest.new(basic_auth_params(subpath))
       end
     end # BasicAuthPlugin
   end # Cli

data/lib/aspera/cli/extended_value.rb

@@ -54,7 +54,7 @@ module Aspera
             path:  lambda{|v|File.expand_path(v)},
             env:   lambda{|v|ENV[v]},
             uri:   lambda{|v|UriReader.read(v)},
-            stdin: lambda{|v|raise 'no value allowed for stdin' unless v.empty?;$stdin.read}
+            stdin: lambda{|v|raise 'no value allowed for stdin' unless v.empty?; $stdin.read} # rubocop:disable Style/Semicolon
           }
           # other handlers can be set using set_handler, e.g. preset is reader in config plugin
         }
@@ -62,12 +62,12 @@ module Aspera
 
       public
 
-      def modifiers;@handlers.keys.map{|i|@handlers[i].keys}.flatten.map(&:to_s);end
+      def modifiers; @handlers.keys.map{|i|@handlers[i].keys}.flatten.map(&:to_s); end
 
       # add a new :reader or :decoder
       # decoder can be chained, reader is last one on right
-      def set_handler(name,type,method)
-        Log.log.debug("setting #{type} handler for #{name}")
+      def set_handler(name, type, method)
+        Log.log.debug{"setting #{type} handler for #{name}"}
         raise 'name must be Symbol' unless name.is_a?(Symbol)
         raise "type #{type} must be one of #{@handlers.keys}" unless @handlers.key?(type)
         @handlers[type][name] = method
@@ -84,7 +84,7 @@ module Aspera
           value = m[2]
         end
         # then read value
-        @handlers[:reader].each do |reader,method|
+        @handlers[:reader].each do |reader, method|
           if (m = value.match(/^@#{reader}:(.*)/))
             value = method.call(m[1])
             break

data/lib/aspera/cli/formater.rb

@@ -17,16 +17,16 @@ module Aspera
       DISPLAY_FORMATS = %i[text nagios ruby json jsonpp yaml table csv].freeze
       # user output levels
       DISPLAY_LEVELS = %i[info data error].freeze
-      CONF_OVERVIEW_KEYS=%w[config parameter value].freeze
+      CONF_OVERVIEW_KEYS = %w[config parameter value].freeze
 
-      private_constant :FIELDS_ALL,:FIELDS_DEFAULT,:DISPLAY_FORMATS,:DISPLAY_LEVELS,:CSV_RECORD_SEPARATOR,:CSV_FIELD_SEPARATOR,
+      private_constant :FIELDS_ALL, :FIELDS_DEFAULT, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR,
         :CONF_OVERVIEW_KEYS
 
       class << self
         # special for Aspera on Cloud display node
         # {"param" => [{"name"=>"foo","value"=>"bar"}]} will be expanded to {"param.foo" : "bar"}
         def flatten_name_value_list(hash)
-          hash.keys.each do |k|
+          hash.keys.each do |k| # rubocop:disable Style/HashEachMethods
             v = hash[k]
             next unless v.is_a?(Array) && v.map(&:class).uniq.eql?([Hash]) && v.map(&:keys).flatten.sort.uniq.eql?(%w[name value])
             v.each do |pair|
@@ -38,16 +38,16 @@ module Aspera
 
         def flatten_config_overview(conffile)
           r = []
-          conffile.each do |config,preset|
-            preset.each do |parameter,value|
-              r.push(CONF_OVERVIEW_KEYS.zip([config,parameter,value]).to_h)
+          conffile.each do |config, preset|
+            preset.each do |parameter, value|
+              r.push(CONF_OVERVIEW_KEYS.zip([config, parameter, value]).to_h)
             end
           end
           return r
         end
 
         def simple_hash?(h)
-          !(h.values.any?{|v|[Hash,Array].any?{|c|v.is_a?(c)}})
+          !(h.values.any?{|v|[Hash, Array].any?{|c|v.is_a?(c)}})
         end
 
         # recursive function to modify a hash
@@ -55,11 +55,11 @@ module Aspera
         # @param expand_last [bool] truer if last level is not
         # @param result [Hash] new hash flattened
         # @param prefix [String] true if last level is not
-        def flattened_object(source,result: {},prefix: '',expand_last: false)
-          Log.log.debug("(#{expand_last})[#{simple_hash?(source)}] -#{source.values}- \n-#{source}-")
-          source.each do |k,v|
+        def flattened_object(source, result: {}, prefix: '', expand_last: false)
+          Log.log.debug{"(#{expand_last})[#{simple_hash?(source)}] -#{source.values}- \n-#{source}-"}
+          source.each do |k, v|
             if v.is_a?(Hash) && !(expand_last && simple_hash?(v))
-              flattened_object(v,result: result,prefix: prefix + k.to_s + '.',expand_last: expand_last)
+              flattened_object(v, result: result, prefix: prefix + k.to_s + '.', expand_last: expand_last)
             else
               result[prefix + k.to_s] = v
             end
@@ -68,8 +68,8 @@ module Aspera
         end
       end
 
-      attr_accessor :option_flat_hash,:option_transpose_single,:option_format,:option_display,:option_fields,:option_table_style,
-        :option_select,:option_show_secrets
+      attr_accessor :option_flat_hash, :option_transpose_single, :option_format, :option_display, :option_fields, :option_table_style,
+        :option_select, :option_show_secrets
 
       # adds options but does not parse
       def initialize(opt_mgr)
@@ -81,29 +81,29 @@ module Aspera
         @option_flat_hash = true
         @option_transpose_single = true
         @option_show_secrets = false
-        opt_mgr.set_obj_attr(:format,self,:option_format)
-        opt_mgr.set_obj_attr(:display,self,:option_display)
-        opt_mgr.set_obj_attr(:fields,self,:option_fields)
-        opt_mgr.set_obj_attr(:select,self,:option_select)
-        opt_mgr.set_obj_attr(:table_style,self,:option_table_style)
-        opt_mgr.set_obj_attr(:flat_hash,self,:option_flat_hash)
-        opt_mgr.set_obj_attr(:transpose_single,self,:option_transpose_single)
-        opt_mgr.set_obj_attr(:show_secrets,self,:option_show_secrets)
-        opt_mgr.add_opt_list(:format,DISPLAY_FORMATS,'output format')
-        opt_mgr.add_opt_list(:display,DISPLAY_LEVELS,'output only some information')
-        opt_mgr.add_opt_simple(:fields,"comma separated list of fields, or #{FIELDS_ALL}, or #{FIELDS_DEFAULT}")
-        opt_mgr.add_opt_simple(:select,'select only some items in lists, extended value: hash (column, value)')
-        opt_mgr.add_opt_simple(:table_style,'table display style')
-        opt_mgr.add_opt_boolean(:flat_hash,'display hash values as additional keys')
-        opt_mgr.add_opt_boolean(:transpose_single,'single object fields output vertically')
-        opt_mgr.add_opt_boolean(:show_secrets,'show secrets on command output')
+        opt_mgr.set_obj_attr(:format, self, :option_format)
+        opt_mgr.set_obj_attr(:display, self, :option_display)
+        opt_mgr.set_obj_attr(:fields, self, :option_fields)
+        opt_mgr.set_obj_attr(:select, self, :option_select)
+        opt_mgr.set_obj_attr(:table_style, self, :option_table_style)
+        opt_mgr.set_obj_attr(:flat_hash, self, :option_flat_hash)
+        opt_mgr.set_obj_attr(:transpose_single, self, :option_transpose_single)
+        opt_mgr.set_obj_attr(:show_secrets, self, :option_show_secrets)
+        opt_mgr.add_opt_list(:format, DISPLAY_FORMATS, 'output format')
+        opt_mgr.add_opt_list(:display, DISPLAY_LEVELS, 'output only some information')
+        opt_mgr.add_opt_simple(:fields, "comma separated list of fields, or #{FIELDS_ALL}, or #{FIELDS_DEFAULT}")
+        opt_mgr.add_opt_simple(:select, 'select only some items in lists, extended value: hash (column, value)')
+        opt_mgr.add_opt_simple(:table_style, 'table display style')
+        opt_mgr.add_opt_boolean(:flat_hash, 'display hash values as additional keys')
+        opt_mgr.add_opt_boolean(:transpose_single, 'single object fields output vertically')
+        opt_mgr.add_opt_boolean(:show_secrets, 'show secrets on command output')
       end
 
       # main output method
       # data: for requested data, not displayed if level==error
       # info: additional info, displayed if level==info
       # error: always displayed on stderr
-      def display_message(message_level,message)
+      def display_message(message_level, message)
         case message_level
         when :data then $stdout.puts(message) unless @option_display.eql?(:error)
         when :info then $stdout.puts(message) if @option_display.eql?(:info)
@@ -113,10 +113,10 @@ module Aspera
       end
 
       def display_status(status)
-        display_message(:info,status)
+        display_message(:info, status)
       end
 
-      def result_default_fields(results,table_rows_hash_val)
+      def result_default_fields(results, table_rows_hash_val)
         unless results[:fields].nil?
           raise "internal error: [fields] must be Array, not #{results[:fields].class}" unless results[:fields].is_a?(Array)
           if results[:fields].first.eql?(:all_but) && !table_rows_hash_val.empty?
@@ -129,17 +129,17 @@ module Aspera
         return table_rows_hash_val.first.keys
       end
 
-      def result_all_fields(_results,table_rows_hash_val)
+      def result_all_fields(_results, table_rows_hash_val)
         raise 'internal error: must be array' unless table_rows_hash_val.is_a?(Array)
         # get the list of all column names used in all lines, not just frst one, as all lines may have different columns
-        return table_rows_hash_val.each_with_object({}){|v,m|v.keys.each{|c|m[c] = true};}.keys
+        return table_rows_hash_val.each_with_object({}){|v, m|v.each_key{|c|m[c] = true}; }.keys
       end
 
       # this method displays the results, especially the table format
       def display_results(results)
         raise "INTERNAL ERROR, result must be Hash (got: #{results.class}: #{results})" unless results.is_a?(Hash)
-        raise 'INTERNAL ERROR, result must have type' unless results.has_key?(:type)
-        raise 'INTERNAL ERROR, result must have data' unless results.has_key?(:data) || %i[empty nothing].include?(results[:type])
+        raise 'INTERNAL ERROR, result must have type' unless results.key?(:type)
+        raise 'INTERNAL ERROR, result must have data' unless results.key?(:data) || %i[empty nothing].include?(results[:type])
         res_data = results[:data]
         # for config overvuew, it is name and value
         is_config_overview = res_data.is_a?(Array) && !res_data.empty? && res_data.first.is_a?(Hash) && res_data.first.keys.sort.eql?(CONF_OVERVIEW_KEYS)
@@ -148,18 +148,18 @@ module Aspera
         user_asked_fields_list_str = @option_fields
         case @option_format
         when :text
-          display_message(:data,res_data.to_s)
+          display_message(:data, res_data.to_s)
         when :nagios
           Nagios.process(res_data)
         when :ruby
-          display_message(:data,PP.pp(res_data,+''))
+          display_message(:data, PP.pp(res_data, +''))
         when :json
-          display_message(:data,JSON.generate(res_data))
+          display_message(:data, JSON.generate(res_data))
         when :jsonpp
-          display_message(:data,JSON.pretty_generate(res_data))
+          display_message(:data, JSON.pretty_generate(res_data))
         when :yaml
-          display_message(:data,res_data.to_yaml)
-        when :table,:csv
+          display_message(:data, res_data.to_yaml)
+        when :table, :csv
           if !@option_transpose_single && results[:type].eql?(:single_object)
             results[:type] = :object_list
             res_data = [res_data]
@@ -171,17 +171,17 @@ module Aspera
             table_rows_hash_val = res_data
             final_table_columns = nil
             if @option_flat_hash
-              table_rows_hash_val.map!{|obj|self.class.flattened_object(obj,expand_last: results[:option_expand_last])}
+              table_rows_hash_val.map!{|obj|self.class.flattened_object(obj, expand_last: results[:option_expand_last])}
             end
             final_table_columns =
               case user_asked_fields_list_str
-              when FIELDS_DEFAULT then result_default_fields(results,table_rows_hash_val)
-              when FIELDS_ALL then     result_all_fields(results,table_rows_hash_val)
+              when FIELDS_DEFAULT then result_default_fields(results, table_rows_hash_val)
+              when FIELDS_ALL then     result_all_fields(results, table_rows_hash_val)
               else
                 if user_asked_fields_list_str.start_with?('+')
-                  result_default_fields(results,table_rows_hash_val).push(*user_asked_fields_list_str.gsub(/^\+/,'').split(','))
+                  result_default_fields(results, table_rows_hash_val).push(*user_asked_fields_list_str.gsub(/^\+/, '').split(','))
                 elsif user_asked_fields_list_str.start_with?('-')
-                  result_default_fields(results,table_rows_hash_val).reject{|i| user_asked_fields_list_str.gsub(/^-/,'').split(',').include?(i)}
+                  result_default_fields(results, table_rows_hash_val).reject{|i| user_asked_fields_list_str.gsub(/^-/, '').split(',').include?(i)}
                 else
                   user_asked_fields_list_str.split(',')
                 end
@@ -191,7 +191,7 @@ module Aspera
             raise "internal error: expecting Hash: got #{res_data.class}: #{res_data}" unless res_data.is_a?(Hash)
             final_table_columns = results[:columns] || %w[key value]
             if @option_flat_hash
-              res_data=self.class.flattened_object(res_data,expand_last: results[:option_expand_last])
+              res_data = self.class.flattened_object(res_data, expand_last: results[:option_expand_last])
               self.class.flatten_name_value_list(res_data)
             end
             asked_fields =
@@ -206,22 +206,22 @@ module Aspera
             final_table_columns = [results[:name]]
             table_rows_hash_val = res_data.map { |i| { results[:name] => i } }
           when :empty # no table
-            display_message(:info,'empty')
+            display_message(:info, 'empty')
             return
           when :nothing # no result expected
             Log.log.debug('no result expected')
             return
           when :status # no table
             # :status displays a simple message
-            display_message(:info,res_data)
+            display_message(:info, res_data)
             return
           when :text # no table
             # :status displays a simple message
-            display_message(:data,res_data)
+            display_message(:data, res_data)
             return
           when :other_struct # no table
             # :other_struct is any other type of structure
-            display_message(:data,PP.pp(res_data,+''))
+            display_message(:data, PP.pp(res_data, +''))
             return
           else
             raise "unknown data type: #{results[:type]}"
@@ -229,14 +229,14 @@ module Aspera
           # here we expect: table_rows_hash_val and final_table_columns
           raise 'no field specified' if final_table_columns.nil?
           if table_rows_hash_val.empty?
-            display_message(:info,'empty'.gray) unless @option_format.eql?(:csv)
+            display_message(:info, 'empty'.gray) unless @option_format.eql?(:csv)
             return
           end
           # convert to string with special function. here table_rows_hash_val is an array of hash
-          table_rows_hash_val = results[:textify].call(table_rows_hash_val) if results.has_key?(:textify)
+          table_rows_hash_val = results[:textify].call(table_rows_hash_val) if results.key?(:textify)
           unless @option_select.nil? || (@option_select.respond_to?(:empty?) && @option_select.empty?)
-            raise CliBadArgument,"expecting hash for select, have #{@option_select.class}: #{@option_select}" unless @option_select.is_a?(Hash)
-            @option_select.each{|k,v|table_rows_hash_val.select!{|i|i[k].eql?(v)}}
+            raise CliBadArgument, "expecting hash for select, have #{@option_select.class}: #{@option_select}" unless @option_select.is_a?(Hash)
+            @option_select.each{|k, v|table_rows_hash_val.select!{|i|i[k].eql?(v)}}
           end
           # convert data to string, and keep only display fields
           final_table_rows = table_rows_hash_val.map { |r| final_table_columns.map { |c| r[c].to_s } }
@@ -246,20 +246,20 @@ module Aspera
           when :table
             style = @option_table_style.chars
             # display the table !
-            #display_message(:data,Text::Table.new(
-            #head:  final_table_columns,
-            #rows:  final_table_rows,
-            #horizontal_boundary:    style[0],
-            #vertical_boundary:      style[1],
-            #boundary_intersection:  style[2]))
-            display_message(:data,Terminal::Table.new(
+            # display_message(:data,Text::Table.new(
+            # head:  final_table_columns,
+            # rows:  final_table_rows,
+            # horizontal_boundary:    style[0],
+            # vertical_boundary:      style[1],
+            # boundary_intersection:  style[2]))
+            display_message(:data, Terminal::Table.new(
               headings:  final_table_columns,
               rows:      final_table_rows,
               border_x:  style[0],
               border_y:  style[1],
               border_i:  style[2]))
           when :csv
-            display_message(:data,final_table_rows.map{|t| t.join(CSV_FIELD_SEPARATOR)}.join(CSV_RECORD_SEPARATOR))
+            display_message(:data, final_table_rows.map{|t| t.join(CSV_FIELD_SEPARATOR)}.join(CSV_RECORD_SEPARATOR))
           end
         end
       end

data/lib/aspera/cli/listener/line_dump.rb

@@ -8,7 +8,7 @@ module Aspera
     module Listener
       # listener for FASP transfers (debug)
       # FASP event listener display management events as JSON
-      class LineDump < Fasp::Listener
+      class LineDump < Aspera::Fasp::Listener
         def event_enhanced(data)
           $stdout.puts(JSON.generate(data))
           $stdout.flush

data/lib/aspera/cli/listener/logger.rb

@@ -7,7 +7,7 @@ module Aspera
   module Cli
     module Listener
       # listener for FASP transfers (debug)
-      class Logger < Fasp::Listener
+      class Logger < Aspera::Fasp::Listener
         def event_struct(data)
           Log.log.debug(data.to_s)
           Log.log.error((data['Description']).to_s) if data['Type'].eql?('FILEERROR')