aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/api/node.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/link_header'
 require 'aspera/transfer/spec'
 require 'aspera/rest'
 require 'aspera/oauth'
@@ -42,14 +43,11 @@ module Aspera
         SEPARATOR = ':'
         NODE_PREFIX = 'node.'
       end
-      # Accepted types in `file_matcher`
-      MATCH_TYPES = [String, Proc, Regexp, NilClass].freeze
       # Delimiter in decoded node token
       SIGNATURE_DELIMITER = '==SIGNATURE=='
       # Default validity when generating a bearer token "manually"
       BEARER_TOKEN_VALIDITY_DEFAULT = 86400
-      private_constant :MATCH_TYPES,
-        :SIGNATURE_DELIMITER, :BEARER_TOKEN_VALIDITY_DEFAULT
+      private_constant :SIGNATURE_DELIMITER, :BEARER_TOKEN_VALIDITY_DEFAULT
       # Node API permissions: delete list mkdir preview read rename write
       ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
       # Special HTTP Headers
@@ -62,7 +60,7 @@ module Aspera
       HEADER_X_TOTAL_COUNT = 'X-Total-Count'
 
       # Register node special token decoder
-      OAuth::Factory.instance.register_decoder(lambda{ |token| Node.decode_bearer_token(token)})
+      OAuth::Factory.instance.register_decoder(lambda { |token| Node.decode_bearer_token(token) })
 
       # Class instance variable, access with accessors on class
       @api_options = {
@@ -78,12 +76,12 @@ module Aspera
         attr_reader :api_options
         attr_reader :use_dynamic_key
 
-        def api_options=(h)
-          Aspera.assert_type(h, Hash)
-          h.each do |k, v|
-            Aspera.assert(@api_options.key?(k.to_sym)){"unknown api option: #{k} (#{OPTIONS.join(', ')})"}
-            Aspera.assert_type(v, TrueClass, FalseClass){"api options value for #{k} should be boolean"}
-            @api_options[k.to_sym] = v
+        def api_options=(options_hash)
+          Aspera.assert_type(options_hash, Hash)
+          options_hash.each do |key, val|
+            Aspera.assert(@api_options.key?(key.to_sym)) { "unknown api option: #{key} (#{OPTIONS.join(', ')})" }
+            Aspera.assert_type(val, TrueClass, FalseClass) { "api options value for #{key} should be boolean" }
+            @api_options[key.to_sym] = val
           end
         end
 
@@ -105,48 +103,30 @@ module Aspera
         end
 
         # Adds fields `public_keys` in provided Hash, if dynamic key is set.
-        # @param h [Hash] Hash to add public key to
+        # @param parameters [Hash] Hash to add public key to
         # @return [Hash] Hash with public key added
-        def add_public_key(h)
+        def add_public_key(parameters)
           if @dynamic_key
             ssh_key = Net::SSH::Buffer.from(:key, @dynamic_key)
             # Get pub key in OpenSSH public key format (authorized_keys)
-            h['public_keys'] = [
+            parameters['public_keys'] = [
               ssh_key.read_string,
               Base64.strict_encode64(ssh_key.to_s)
             ].join(' ')
           end
-          return h
+          return parameters
         end
 
         # Adds fields `ssh_private_key` in provided Hash, if dynamic key is set.
-        # @param h [Hash] Hash to add private key to
-        def add_private_key(h)
-          h['ssh_private_key'] = @dynamic_key.to_pem if @dynamic_key
-          return h
-        end
-
-        # For access keys: provide expression to match entry in folder
-        # @param match_expression one of supported types
-        # @return lambda function
-        def file_matcher(match_expression)
-          case match_expression
-          when Proc then return match_expression
-          when Regexp then return ->(f){f['name'].match?(match_expression)}
-          when String
-            return ->(f){File.fnmatch(match_expression, f['name'], File::FNM_DOTMATCH)}
-          when NilClass then return ->(_){true}
-          else Aspera.error_unexpected_value(match_expression.class.name, type: ParameterError)
-          end
-        end
-
-        # @return [Proc] lambda from provided CLI options
-        def file_matcher_from_argument(options)
-          return file_matcher(options.get_next_argument('filter', validation: MATCH_TYPES, mandatory: false))
+        # @param parameters [Hash] Hash to add private key to
+        def add_private_key(parameters)
+          parameters['ssh_private_key'] = @dynamic_key.to_pem if @dynamic_key
+          return parameters
         end
 
         # Split path into folder + filename
-        # @return [Array] containing folder + inside folder/file
+        # @param path [String] file path to split
+        # @return [Array(String, String)] containing folder + inside folder/file
         def split_folder(path)
           folder = path.split(PATH_SEPARATOR)
           inside = folder.pop
@@ -160,11 +140,12 @@ module Aspera
         end
 
         # Decode node scope into access key and scope
-        # @return [Hash]
+        # @param scope [String] scope string to decode
+        # @return [Hash] decoded scope with access key and scope parts
         def decode_scope(scope)
           items = scope.split(Scope::SEPARATOR, 2)
-          Aspera.assert(items.length.eql?(2)){"invalid scope: #{scope}"}
-          Aspera.assert(items[0].start_with?(Scope::NODE_PREFIX)){"invalid scope: #{scope}"}
+          Aspera.assert(items.length.eql?(2)) { "invalid scope: #{scope}" }
+          Aspera.assert(items[0].start_with?(Scope::NODE_PREFIX)) { "invalid scope: #{scope}" }
           return {access_key: items[0].delete_prefix(Scope::NODE_PREFIX), scope: items[1]}
         end
 
@@ -240,7 +221,7 @@ module Aspera
         return tspec
       end
 
-      # @returns [Node, nil] a Node Api object or nil if no App defined
+      # @return [Node, nil] a Node Api object or nil if no App defined
       def node_id_to_node(node_id)
         if !@app_info.nil?
           return self if node_id.eql?(@app_info.node_info['id'])
@@ -250,10 +231,10 @@ module Aspera
             workspace_name: @app_info.workspace_name
           )
         end
-        Log.log.warn{"Cannot resolve link with node id #{node_id}, no resolver"}
+        Log.log.warn { "Cannot resolve link with node id #{node_id}, no resolver" }
         return
       rescue RestCallError => e
-        Log.log.warn{"Cannot resolve link with node id #{node_id}: #{e.message}"}
+        Log.log.warn { "Cannot resolve link with node id #{node_id}: #{e.message}" }
         return
       end
 
@@ -268,7 +249,7 @@ module Aspera
           entry['target_id'] = link_entry['target_id']
         end
         return true unless entry['target_node_id'].nil? || entry['target_id'].nil?
-        Log.log.warn{"Missing target information for link: #{entry['name']}"}
+        Log.log.warn { "Missing target information for link: #{entry['name']}" }
         return false
       end
 
@@ -320,8 +301,8 @@ module Aspera
           end
         rescue StandardError => e
           raise e if exception
-          Log.log.warn{"#{path || file_id}: #{e.class} #{e.message}"}
-          Log.log.debug{(['Backtrace:'] + e.backtrace).join("\n")}
+          Log.log.warn { "#{path || file_id}: #{e.class} #{e.message}" }
+          Log.log.debug { (['Backtrace:'] + e.backtrace).join("\n") }
         ensure
           RestParameters.instance.spinner_cb.call(folder_items.count, action: :success)
         end
@@ -338,14 +319,14 @@ module Aspera
       # @para query [Hash, nil] optional query for `read`
       def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/', query: nil)
         Aspera.assert(!top_file_path.nil?, 'top_file_path not set')
-        Log.log.debug{"process_folder_tree: node=#{@app_info ? @app_info.node_info['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}"}
+        Log.log.debug { "process_folder_tree: node=#{@app_info ? @app_info.node_info['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}" }
         # Start at top folder
         folders_to_explore = [{id: top_file_id, path: top_file_path}]
         Log.dump(:folders_to_explore, folders_to_explore)
         until folders_to_explore.empty?
           # Consume first in job list
           current_item = folders_to_explore.shift
-          Log.log.debug{"Exploring #{current_item[:path]}".bg_green}
+          Log.log.debug { "Exploring #{current_item[:path]}".bg_green }
           # Get folder content
           folder_contents = read_folder_content(current_item[:id], query, exception: false, path: current_item[:path])
           Log.dump(:folder_contents, folder_contents)
@@ -355,7 +336,7 @@ module Aspera
               next
             end
             current_path = File.join(current_item[:path], entry['name'])
-            Log.log.debug{"process_folder_tree: checking #{current_path}"}
+            Log.log.debug { "process_folder_tree: checking #{current_path}" }
             # Call block, continue only if method returns true
             next unless send(method_sym, entry, current_path, state)
             # Entry type is file, folder or link
@@ -390,8 +371,8 @@ module Aspera
         return NodeFileId.new(self, top_file_id) if path_elements.empty?
         resolve_state = {path: path_elements, consumed: [], result: nil, process_last_link: process_last_link}
         process_folder_tree(method_sym: :process_api_fid, state: resolve_state, top_file_id: top_file_id)
-        raise ParameterError, "Entry not found: #{resolve_state[:path].first} in /#{resolve_state[:consumed].join(PATH_SEPARATOR)}" if resolve_state[:result].nil?
-        Log.log.debug{"resolve_api_fid: #{path} -> #{resolve_state[:result].node_api.base_url} #{resolve_state[:result].file_id}"}
+        Aspera.assert(!resolve_state[:result].nil?, type: ParameterError) { "Entry not found: #{resolve_state[:path].first} in /#{resolve_state[:consumed].join(PATH_SEPARATOR)}" }
+        Log.log.debug { "resolve_api_fid: #{path} -> #{resolve_state[:result].node_api.base_url} #{resolve_state[:result].file_id}" }
         return resolve_state[:result]
       end
 
@@ -406,10 +387,10 @@ module Aspera
       def resolve_api_fid_paths(top_file_id, paths)
         Aspera.assert_type(paths, Array)
         Aspera.assert(paths.size.positive?, 'paths must not be empty')
-        split_sources = paths.map{ |p| Pathname(p['source']).each_filename.to_a}
+        split_sources = paths.map { |p| Pathname(p['source']).each_filename.to_a }
         root = []
         split_sources.map(&:size).min.times do |i|
-          parts = split_sources.map{ |s| s[i]}
+          parts = split_sources.map { |s| s[i] }
           break unless parts.uniq.size == 1
           root << parts.first
         end
@@ -437,7 +418,7 @@ module Aspera
               # Single source is 'folder' or 'link'
               # TODO: add this ? , 'destination'=>file_info['name']
               [{'source' => '.'}]
-            else Aspera.error_unexpected_value(file_info['type']){'source type'}
+            else Aspera.error_unexpected_value(file_info['type']) { 'source type' }
             end
         end
         [apifid, source_paths]
@@ -447,7 +428,7 @@ module Aspera
       # @param top_file_id [String] Search root
       # @param test_lambda [Proc] Test function
       def find_files(top_file_id, test_lambda)
-        Log.log.debug{"find_files: file id=#{top_file_id}"}
+        Log.log.debug { "find_files: file id=#{top_file_id}" }
         find_state = {found: [], test_lambda: test_lambda}
         process_folder_tree(method_sym: :process_find_files, state: find_state, top_file_id: top_file_id)
         return find_state[:found]
@@ -532,7 +513,7 @@ module Aspera
           # Get the transfer user from info on access key
           transfer_spec['remote_user'] = info['transfer_user'] if info['transfer_user']
           # Get settings from name.value array to hash key.value
-          settings = info['settings']&.to_h{ |i| [i['name'], i['value']]}
+          settings = info['settings']&.to_h { |i| [i['name'], i['value']] }
           # Check WSS ports
           Transfer::Spec::WSS_FIELDS.each do |i|
             transfer_spec[i] = settings[i] if settings.key?(i)
@@ -540,7 +521,7 @@ module Aspera
         else
           transfer_spec.merge!(transport_params)
         end
-        Aspera.assert_values(transfer_spec['remote_user'], [Transfer::Spec::ACCESS_KEY_TRANSFER_USER], type: :warn){'transfer user'}
+        Aspera.assert_values(transfer_spec['remote_user'], [Transfer::Spec::ACCESS_KEY_TRANSFER_USER], type: :warn) { 'transfer user' }
         return transfer_spec
       end
 
@@ -549,8 +530,8 @@ module Aspera
       # @param call_args [Hash]    additional arguments to pass to `Rest.call`
       # @return [Array] list of items returned by the API call
       def read_with_paging(subpath, query = nil, iteration: nil, **call_args)
-        Aspera.assert_type(iteration, Array, NilClass){'iteration'}
-        Aspera.assert_type(query, Hash, NilClass){'query'}
+        Aspera.assert_type(iteration, Array, NilClass) { 'iteration' }
+        Aspera.assert_type(query, Hash, NilClass) { 'query' }
         Aspera.assert(!call_args.key?(:query), ':query must not be in call_args (use query parameter)')
         query = {} if query.nil?
         query[:iteration_token] = iteration[0] unless iteration.nil? || iteration[0].nil?
@@ -560,7 +541,7 @@ module Aspera
         item_list = []
         loop do
           data, http = read(subpath, query, **call_args, ret: :both)
-          Aspera.assert_type(data, Array){"Expected data to be an Array, got: #{data.class}"}
+          Aspera.assert_type(data, Array) { "Expected data to be an Array, got: #{data.class}" }
           # no data
           break if data.empty?
           item_list.concat(data)
@@ -572,7 +553,7 @@ module Aspera
           # Update progress spinner
           RestParameters.instance.spinner_cb.call(item_list.length)
           # Parse Link header according to RFC 8288 to extract next iteration token
-          next_url = Rest.parse_link_header(http['Link'], rel: 'next')
+          next_url = LinkHeader.parse(http['Link']).find_href(rel: 'next')
           next_iteration_token = nil
           if next_url
             begin
@@ -580,7 +561,7 @@ module Aspera
               query_params = Rest.query_to_h(parsed_uri.query) if parsed_uri.query
               next_iteration_token = query_params['iteration_token'] if query_params
             rescue URI::InvalidURIError => e
-              Log.log.warn{"Invalid URI in Link header: #{next_url} - #{e.message}"}
+              Log.log.warn { "Invalid URI in Link header: #{next_url} - #{e.message}" }
             end
           end
           # Stop if no next token
@@ -619,8 +600,8 @@ module Aspera
           query['page'] += 1
         end
       rescue StandardError => e
-        Log.log.warn{"#{e.class} #{e.message}"}
-        Log.log.debug{(['Backtrace:'] + e.backtrace).join("\n")}
+        Log.log.warn { "#{e.class} #{e.message}" }
+        Log.log.debug { (['Backtrace:'] + e.backtrace).join("\n") }
       ensure
         RestParameters.instance.spinner_cb.call(items.count, action: :success)
         return items # rubocop:disable Lint/EnsureReturn
@@ -629,7 +610,7 @@ module Aspera
       private
 
       # Method called in loop for each entry for `resolve_api_fid`
-      # @return `true` to continue digging, `false` to stop processing: set state[:result] if found
+      # @return [Boolean] `true` to continue digging, `false` to stop processing: set state[:result] if found
       def process_api_fid(entry, path, state)
         # Stop digging here if not in right path
         return false unless entry['name'].eql?(state[:path].first)
@@ -641,7 +622,7 @@ module Aspera
           # File must be terminal
           raise "#{entry['name']} is a file, expecting folder to find: #{state[:path]}" unless path_fully_consumed
           # It's terminal, we found it
-          Log.log.debug{"process_api_fid: found #{path} -> #{entry['id']}"}
+          Log.log.debug { "process_api_fid: found #{path} -> #{entry['id']}" }
           state[:result] = NodeFileId.new(self, entry['id'])
           return false
         when 'folder'
@@ -656,7 +637,7 @@ module Aspera
               # We found it
               other_node = nil
               other_node = node_id_to_node(entry['target_node_id']) if entry_has_link_information(entry)
-              raise Error, 'Cannot resolve link' if other_node.nil?
+              Aspera.assert(!other_node.nil?, type: Error) { 'Cannot resolve link' }
               state[:result] = NodeFileId.new(other_node, entry['target_id'])
             else
               # We found it but we do not process the link
@@ -664,7 +645,7 @@ module Aspera
             end
             return false
           end
-        else Aspera.error_unexpected_value(entry['type'], type: :warn){'folder entry type'}
+        else Aspera.error_unexpected_value(entry['type'], type: :warn) { 'folder entry type' }
         end
         # Continue to dig folder
         return true

data/lib/aspera/api/queries/bss_subscription_account.graphql

@@ -0,0 +1,18 @@
+query ($organization_id: ID!) {
+  aoc (organization_id: $organization_id) {
+    bssSubscription {
+      aocVersion endDate startDate termMonths plan trial termType
+      aocOrganizations { id }
+      additionalStorageVolumeGb additionalEgressVolumeGb
+      term { startDate endDate transferVolumeGb egressVolumeGb storageVolumeGb transferVolumeOffsetGb }
+      paygoRate { transferRate storageRate currency }
+      aocPlanData {
+        tier trial
+        workspaces { max }
+        users { planAmount max }
+        samlIntegration activity sharedInboxes uniqueUrls support watermarking byok
+        automation { planAmount, max }
+      }
+    }
+  }
+}

data/lib/aspera/api/queries/bss_subscription_usage.graphql

@@ -0,0 +1,18 @@
+query ($organization_id: ID!, $startDate: Date!, $endDate: Date!, $aggregate: TransferUsageAggregateOption!) {
+  aoc (organization_id: $organization_id) {
+    bssSubscription {
+      aocOrganizations { id }
+      additionalStorageVolumeGb additionalEgressVolumeGb
+      aocPlanData { tier trial }
+      term { transferVolumeGb egressVolumeGb storageVolumeGb startDate endDate transferVolumeOffsetGb }
+      termMonths
+      transferUsages (startDate: $startDate, endDate: $endDate, aggregate: $aggregate) { mbTotal }
+      egressUsages (startDate: $startDate, endDate: $endDate, aggregate: $aggregate) { usageMb }
+    }
+    subscriptionEntitlements {
+      id
+      transferUsages (startDate: $startDate, endDate: $endDate, aggregate: $aggregate) { mbTotal }
+      egressUsages (startDate: $startDate, endDate: $endDate, aggregate: $aggregate) { usageMb }
+    }
+  }
+}

data/lib/aspera/ascmd.rb

@@ -28,18 +28,18 @@ module Aspera
     ENUM_START = 1
 
     # Description of result structures (see ascmdtypes.h).
-    # Base types are big endian
-    # key = name of type
-    # index in array `fields` is: the numerical type of TLV - `ENUM_START`. i.e. add `ENUM_START` to index, to get `T`
-    # decoding always start at `result`
-    # some fields have special handling indicated by `special`
-    # field_list, list_tlv_list, list_tlv_restart are composed with a list of TLV
-    # decode:
-    # - :base : value
-    # - :buffer_list : an array of {btype,buffer}
-    # - :field_list : a hash, or array
-    # :check: ???
-    # rubocop:disable Layout/FirstHashElementLineBreak
+    # Base types are big endian.
+    # Keys are type names; the index in each `fields` array equals (TLV numerical type - `ENUM_START`).
+    # Decoding always starts at `result`.
+    # Some fields have special handling indicated by `special`:
+    #   - `:field_list`       : a Hash or Array of child TLVs
+    #   - `:list_tlv_list`    : a list of TLV sub-lists (Array of Hash)
+    #   - `:list_tlv_restart` : same but restarted per entry
+    # `decode` values:
+    #   - `:base`        : a single scalar value (unpack with `unpack`)
+    #   - `:buffer_list` : an Array of `{btype, buffer}` entries
+    #   - `:field_list`  : a Hash or Array built from child TLVs
+    # rubocop:disable-next Layout/FirstHashElementLineBreak
     TYPES_DESCR = {
       result: {decode: :field_list,
                fields: [{name: :file, is_a: :stat}, {name: :dir, is_a: :stat, special: :list_tlv_list}, {name: :size, is_a: :size}, {name: :error, is_a: :error},
@@ -73,7 +73,6 @@ module Aspera
       zstr:   {decode: :base, unpack: 'Z*'},
       blist:  {decode: :buffer_list}
     }.freeze
-    # rubocop:enable Layout/FirstHashElementLineBreak
 
     private_constant :TYPES_DESCR, :ENUM_START, :OPS_ARGS
 
@@ -87,14 +86,14 @@ module Aspera
 
     # execute an "as" command on a remote server
     # Version 2 allows use of reverse proxy with multiple addresses.
-    # @param [Symbol] one of OPERATIONS
-    # @param [Array] parameters for "as" command
+    # @param action_sym [Symbol] one of OPERATIONS
+    # @param arguments  [Array]  parameters for "as" command
     # @return [Boolean,Array,Hash] result of command, type depends on command
-    def execute_single(action_sym, arguments, version: 1, host: nil)
+    def execute_single(action_sym, arguments, version: 2, host: nil)
       arguments = [] if arguments.nil?
-      Log.log.debug{"execute_single:#{action_sym}:#{arguments}"}
+      Log.log.debug { "execute_single:#{action_sym}:#{arguments}" }
       Aspera.assert_type(action_sym, Symbol)
-      Aspera.assert_array_all(arguments, String){'arguments'}
+      Aspera.assert_array_all(arguments, String) { 'arguments' }
       remote_cmd = 'ascmd'
       # lines of commands (String's)
       command_lines = []
@@ -118,7 +117,7 @@ module Aspera
         # enclose arguments in double quotes, protect backslash and double quotes
         # ascmd uses space as token separator, and optional quotes ('") or \ to escape
         args.each do |v|
-          command.push(%Q{"#{v.gsub(/["\\]/){ |s| "\\#{s}"}}"})
+          command.push(%Q{"#{v.gsub(/["\\]/) { |s| "\\#{s}" }}"})
         end
         command_lines.push(command.join(' '))
       end
@@ -126,7 +125,7 @@ module Aspera
       command_lines.push('')
       # execute the main command and then exit
       stdin_input = command_lines.join("\n")
-      Log.log.trace1{"execute_single:#{stdin_input}"}
+      Log.log.trace1 { "execute_single:#{stdin_input}" }
       # execute, get binary output
       byte_buffer = @command_executor.execute(remote_cmd, input: stdin_input).unpack('C*')
       Aspera.assert(!byte_buffer.empty?, 'empty answer from server')
@@ -155,7 +154,7 @@ module Aspera
       end
       # raise error as exception
       raise Error.new(result[:errno], result[:errstr], action_sym, arguments) if
-        result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map{ |i| i[:name]}.sort)
+        result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map { |i| i[:name] }.sort)
       return result
     end
 
@@ -169,20 +168,23 @@ module Aspera
     end
 
     class << self
-      # Get description of structure's field, @param struct_name, @param typed_buffer provides field name
+      # Get description of structure's field
+      # @param struct_name   [Symbol] name of the structure type
+      # @param typed_buffer  [Hash]   typed buffer providing the field name via `:btype`
+      # @return [Hash] field description
       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?
+        Aspera.assert(!result.nil?) { "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" }
         return result
       end
 
       # Decodes the provided buffer as provided type name
-      # @return a decoded type: single, Array, or Hash
+      # @return [Boolean, Array, Hash] a decoded type: single, Array, or Hash
       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.trace1{"#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0, 16]}...".red}
+        Aspera.assert(!type_descr.nil?) { "Unexpected type #{type_name}" }
+        Log.log.trace1 { "#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0, 16]}...".red }
         result = nil
         case type_descr[:decode]
         when :base
@@ -192,7 +194,7 @@ module Aspera
           byte_array = [byte_array] unless byte_array.is_a?(Array)
           result = byte_array.pack('C*').unpack1(type_descr[:unpack])
           result.force_encoding('UTF-8') if type_name.eql?(:zstr)
-          Log.log.trace1{"#{'   .' * indent_level}-> base:#{byte_array} -> #{result}"}
+          Log.log.trace1 { "#{'   .' * indent_level}-> base:#{byte_array} -> #{result}" }
           result = Time.at(result) if type_name.eql?(:epoch)
         when :buffer_list
           # return a list of type_buffer
@@ -203,7 +205,7 @@ module Aspera
             Aspera.assert(buffer.length >= length, 'not enough bytes')
             value = buffer.shift(length)
             result.push({btype: btype, buffer: value})
-            Log.log.trace1{"#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}"}
+            Log.log.trace1 { "#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}" }
           end
         when :field_list
           # by default the result is one struct
@@ -212,7 +214,7 @@ module Aspera
           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.trace1{"#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green}
+            Log.log.trace1 { "#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green }
             case field_info[:special]
             when nil # normal case
               result[field_info[:name]] = parse(typed_buffer[:buffer], field_info[:is_a], indent_level)
@@ -222,7 +224,7 @@ module Aspera
               result[field_info[:name]] ||= []
               result[field_info[:name]].push(parse(typed_buffer[:buffer], field_info[:is_a], indent_level))
             when :list_tlv_list # field is an array of values in a list of buffers
-              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 :list_tlv_restart # field is an array of values, but a new value is started on index 1
               fl = result[field_info[:name]] = []
               parse(typed_buffer[:buffer], :blist, indent_level).map do |tb|