aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/api/aoc.rb

@@ -25,23 +25,23 @@ module Aspera
 
       class AppInfo
         # @return [Aspera::Api::AoC] Rest Api object
-        attr_reader  :api
+        attr_reader :api
         # @return [Hash, nil] Package information, `"files"` or `"packages"`
-        attr_reader  :package
+        attr_reader :package
         # @return [Hash] Result of GET /nodes/:id
-        attr_reader  :node_info
+        attr_reader :node_info
         # @return [String] Workspace id
-        attr_reader  :workspace_id
+        attr_reader :workspace_id
         # @return [String] Workspace name
-        attr_reader  :workspace_name
+        attr_reader :workspace_name
         # @return [String, nil] "Share as" link name
         attr_accessor :opt_link_name
 
         # @param api [Api::Aoc] Rest Api object
         # @param package [Hash,nil] package information or nil
         # @param node_info [Hash] Result of GET /nodes/:id
-        # @param workspace_id [String]
-        # @param workspace_name [String]
+        # @param workspace_id   [String]     Workspace identifier
+        # @param workspace_name [String]     Workspace name
         def initialize(api, package, node_info, workspace_id, workspace_name)
           @api = api
           @package = package
@@ -65,11 +65,11 @@ module Aspera
       MAX_AOC_URL_REDIRECT = 10
       CLIENT_ID_PREFIX = 'aspera.'
       # Well-known AoC global client apps
-      GLOBAL_CLIENT_APPS = DataRepository::ELEMENTS.select{ |i| i.to_s.start_with?(CLIENT_ID_PREFIX)}.freeze
+      GLOBAL_CLIENT_APPS = DataRepository::ELEMENTS.select { |i| i.to_s.start_with?(CLIENT_ID_PREFIX) }.freeze
       # cookie prefix so that console can decode identity
       COOKIE_PREFIX_CONSOLE_AOC = 'aspera.aoc'
-      # path in URL of public links
-      PUBLIC_LINK_PATHS = %w[/packages/public/receive /packages/public/send /files/public /public/files /public/package /public/send].freeze
+      # path in URL of public links (warning if not in list)
+      PUBLIC_LINK_PATHS = %w[/packages/public/receive /packages/public/send /files/public /public/files /public/files/ /public/package /public/send /public/send/package].freeze
       JWT_AUDIENCE = 'https://api.asperafiles.com/api/v1/oauth2/token'
       OAUTH_API_SUBPATH = 'api/v1/oauth2'
       # minimum fields for user info if retrieval fails
@@ -123,9 +123,9 @@ module Aspera
         # split host of URL into organization and domain
         def split_org_domain(uri)
           Aspera.assert_type(uri, URI)
-          Aspera.assert(!uri.host.nil?){"No host found in URL. Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}"}
+          Aspera.assert(!uri.host.nil?) { "No host found in URL. Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}" }
           parts = uri.host.split('.', 2)
-          Aspera.assert(parts.length == 2){"expecting a public FQDN for #{PRODUCT_NAME}"}
+          Aspera.assert(parts.length == 2) { "expecting a public FQDN for #{PRODUCT_NAME}" }
           parts[0] = nil if parts[0].eql?('api')
           return %i{organization domain}.zip(parts).to_h
         end
@@ -146,14 +146,14 @@ module Aspera
           if (m = final_uri.path.match(%r{/oauth2/([^/]+)/login$}))
             org_domain[:organization] = m[1] if org_domain[:organization].nil?
           else
-            Log.log.debug{"path=#{final_uri.path} does not end with /login"}
+            Log.log.debug { "path=#{final_uri.path} does not end with /login" }
           end
           Aspera.assert(!final_uri.query.nil?, 'AoC shall redirect to login page with a query', type: Error)
           query = Rest.query_to_h(final_uri.query)
           Log.dump(:query, query, level: :trace1)
           # is that a public link ?
           if query.key?('token')
-            Log.log.warn{"Unknown pub link path: #{final_uri.path}"} unless PUBLIC_LINK_PATHS.include?(final_uri.path)
+            Log.log.warn { "Unknown pub link path: #{final_uri.path}" } unless PUBLIC_LINK_PATHS.include?(final_uri.path)
             # ok we get it !
             return {
               instance_domain: org_domain[:domain],
@@ -198,7 +198,7 @@ module Aspera
         # @option return [Array<Hash>] :items The list of items
         # @option return [Integer] :total The total number of items
         def call_paging(query: {})
-          Aspera.assert_type(query, Hash){'query'}
+          Aspera.assert_type(query, Hash) { 'query' }
           Aspera.assert(block_given?, 'block required for call_paging')
           # set default large page if user does not specify own parameters. AoC Caps to 1000 anyway
           query['per_page'] = 1000 unless query.key?('per_page')
@@ -257,10 +257,10 @@ module Aspera
           when 'download' then %w[list preview read]
           when 'upload' then %w[mkdir write]
           when Array
-            Aspera.assert_array_all(levels, String){'access_levels'}
-            levels.each{ |level| Aspera.assert_values(level, Node::ACCESS_LEVELS){'access_level'}}
+            Aspera.assert_array_all(levels, String) { 'access_levels' }
+            levels.each { |level| Aspera.assert_values(level, Node::ACCESS_LEVELS) { 'access_level' } }
             levels
-          else Aspera.error_unexpected_value(levels){"access_levels must be a list of #{Node::ACCESS_LEVELS.join(', ')} or one of edit, preview, download, upload"}
+          else Aspera.error_unexpected_value(levels) { "access_levels must be a list of #{Node::ACCESS_LEVELS.join(', ')} or one of edit, preview, download, upload" }
           end
         end
       end
@@ -269,7 +269,6 @@ module Aspera
       attr_accessor :ws_ids
 
       # By default: no workspace
-      # @param
       def initialize(
         scope: nil,
         subpath: API_V1,
@@ -298,8 +297,7 @@ module Aspera
         # default values for client id
         client_id, client_secret = self.class.get_client_info if client_id.nil?
         # access key secrets are provided out of band to get node api access
-        # key: access key
-        # value: associated secret
+        # maps access key (String) to its associated secret (String)
         @secret_finder = secret_finder
         @cache_user_info = nil
         @cache_url_token_info = nil
@@ -354,7 +352,7 @@ module Aspera
         when :none
           auth_params.clear
           auth_params[:type] = :none
-        else Aspera.error_unexpected_value(auth_params[:grant_method]){'auth, use one of: web, jwt, boot'}
+        else Aspera.error_unexpected_value(auth_params[:grant_method]) { 'auth, use one of: web, jwt, boot' }
         end
         super(**base_args)
       end
@@ -371,7 +369,7 @@ module Aspera
 
       # @param expected [Array<String>] Link types
       def assert_public_link_types(expected)
-        Aspera.assert_values(public_link['purpose'], expected){'public link type'}
+        Aspera.assert_values(public_link['purpose'], expected) { 'public link type' }
       end
 
       def additional_persistence_ids
@@ -398,10 +396,10 @@ module Aspera
             read('self')
           rescue Aspera::RestCallError => e
             raise if exception || e.message.include?('invalid_grant')
-            Log.log.debug{"Ignoring error: (#{e.class}) #{e}"}
+            Log.log.debug { "Ignoring error: (#{e.class}) #{e}" }
             {}
           end
-        USER_INFO_FIELDS_MIN.each{ |f| @cache_user_info[f] = nil if @cache_user_info[f].nil?}
+        USER_INFO_FIELDS_MIN.each { |f| @cache_user_info[f] = nil if @cache_user_info[f].nil? }
         return @cache_user_info
       end
 
@@ -480,17 +478,17 @@ module Aspera
       # @param workspace_name [String,nil] workspace name
       # @param scope          [String,nil] e.g. Node::Scope::USER, or Node::Scope::ADMIN, or nil (requires secret)
       # @param package_info   [Hash,nil] created package information
-      # @returns [Node] a node API for access key
+      # @return [Node] a node API for access key
       def node_api_from(node_id:, workspace_id: nil, workspace_name: nil, scope: Node::Scope::USER, package_info: nil)
         Aspera.assert_type(node_id, String)
         node_info = read("nodes/#{node_id}")
         workspace_name = read("workspaces/#{workspace_id}")['name'] if workspace_name.nil? && !workspace_id.nil?
         app_info = AppInfo.new(self, package_info, node_info, workspace_id, workspace_name)
         node_params = {base_url: node_info['url']}
-        ak_secret = @secret_finder&.lookup_secret(url: node_info['url'], username: node_info['access_key'])
+        ak_secret = @secret_finder&.lookup(url: node_info['url'], username: node_info['access_key'])
         # If secret is available, or no scope, use basic auth
         if scope.nil? || ak_secret
-          Aspera.assert(ak_secret, type: Error){"Secret not found for access key #{node_info['access_key']}@#{node_info['url']}"}
+          Aspera.assert(ak_secret, type: Error) { "Secret not found for access key #{node_info['access_key']}@#{node_info['url']}" }
           node_params[:auth] = {
             type:     :basic,
             username: node_info['access_key'],
@@ -521,21 +519,21 @@ module Aspera
           Log.log.debug('no metadata in shared inbox')
           return
         end
-        Aspera.assert(pkg_data.key?('metadata')){"package requires metadata: #{meta_schema}"}
+        Aspera.assert(pkg_data.key?('metadata')) { "package requires metadata: #{meta_schema}" }
         pkg_meta = pkg_data['metadata']
-        Aspera.assert_type(pkg_meta, Array){'metadata'}
+        Aspera.assert_type(pkg_meta, Array) { 'metadata' }
         Log.dump(:metadata, pkg_meta)
         pkg_meta.each do |field|
-          Aspera.assert_type(field, Hash){'metadata field'}
+          Aspera.assert_type(field, Hash) { 'metadata field' }
           Aspera.assert(field.key?('name'), 'metadata field must have name')
           Aspera.assert(field.key?('values'), 'metadata field must have values')
-          Aspera.assert_type(field['values'], Array){'metadata field values'}
-          Aspera.assert(meta_schema.any?{ |i| i['name'].eql?(field['name'])}){"unknown metadata field: #{field['name']}"}
+          Aspera.assert_type(field['values'], Array) { 'metadata field values' }
+          Aspera.assert(meta_schema.any? { |i| i['name'].eql?(field['name']) }) { "unknown metadata field: #{field['name']}" }
         end
         meta_schema.each do |field|
-          provided = pkg_meta.select{ |i| i['name'].eql?(field['name'])}
-          Aspera.assert(provided.count <= 1, type: Error){"only one field with name #{field['name']} allowed"}
-          Aspera.assert(!provided.empty?, type: Error){"missing mandatory field: #{field['name']}"} if field['required']
+          provided = pkg_meta.select { |i| i['name'].eql?(field['name']) }
+          Aspera.assert(provided.count <= 1, type: Error) { "only one field with name #{field['name']} allowed" }
+          Aspera.assert(!provided.empty?, type: Error) { "missing mandatory field: #{field['name']}" } if field['required']
         end
       end
 
@@ -545,19 +543,19 @@ module Aspera
       # @param package_data    [Hash]   The whole package creation payload
       # @param rcpt_lst_field  [String] The field in structure, i.e. recipients or bcc_recipients
       # @param new_user_option [Hash]   Additional fields for contact creation
-      # @return nil, `package_data` is modified
+      # @return [nil] `package_data` is modified in place
       def resolve_package_recipients(package_data, rcpt_lst_field, new_user_option)
         return unless package_data.key?(rcpt_lst_field)
-        Aspera.assert_type(package_data[rcpt_lst_field], Array){rcpt_lst_field}
+        Aspera.assert_type(package_data[rcpt_lst_field], Array) { rcpt_lst_field }
         new_user_option = {'package_contact' => true} if new_user_option.nil?
-        Aspera.assert_type(new_user_option, Hash){'new_user_option'}
+        Aspera.assert_type(new_user_option, Hash) { 'new_user_option' }
         ws_id = package_data['workspace_id']
         # list with resolved elements
         resolved_list = []
         package_data[rcpt_lst_field].each do |short_recipient_info|
           case short_recipient_info
           when Hash # native API information, check keys
-            Aspera.assert(short_recipient_info.keys.sort.eql?(%w[id type])){"#{rcpt_lst_field} element shall have fields: id and type"}
+            Aspera.assert(short_recipient_info.keys.sort.eql?(%w[id type])) { "#{rcpt_lst_field} element shall have fields: id and type" }
           when String # CLI helper: need to resolve provided name to type/id
             # email: user, else dropbox
             entity_type = short_recipient_info.include?('@') ? 'contacts' : 'dropboxes'
@@ -565,7 +563,7 @@ module Aspera
               full_recipient_info = lookup_with_q(entity_type, value: short_recipient_info, query: {'workspace_id' => ws_id})
             rescue EntityNotFound
               # dropboxes cannot be created on the fly
-              Aspera.assert_values(entity_type, %w[contacts], type: Error){"No such shared inbox in workspace #{ws_id}"}
+              Aspera.assert_values(entity_type, %w[contacts], type: Error) { "No such shared inbox in workspace #{ws_id}" }
               # unknown user: create it as external user
               full_recipient_info = create('contacts', {
                 'current_workspace_id' => ws_id,
@@ -577,7 +575,7 @@ module Aspera
             else
               {'id' => full_recipient_info['source_id'], 'type' => full_recipient_info['source_type']}
             end
-          else Aspera.error_unexpected_value(short_recipient_info.class.name){"#{rcpt_lst_field} item must be a String (email, shared inbox) or Hash (id,type)"}
+          else Aspera.error_unexpected_value(short_recipient_info.class.name) { "#{rcpt_lst_field} item must be a String (email, shared inbox) or Hash (id,type)" }
           end
           # add original or resolved recipient info
           resolved_list.push(short_recipient_info)
@@ -609,7 +607,7 @@ module Aspera
       # @param package_data [Hash] package creation (with extensions...)
       # @param validate_meta [TrueClass,FalseClass] true to validate parameters locally
       # @param new_user_option [Hash,NilClass] options if an unknown user is specified
-      # @return transfer spec, node api and package information
+      # @return [Array] transfer spec, node api and package information
       def create_package_simple(package_data, validate_meta, new_user_option)
         update_package_metadata_for_api(package_data)
         # list of files to include in package, optional
@@ -671,7 +669,7 @@ module Aspera
         # Console cookie
         ################
         # we are sure that fields are not nil
-        cookie_elements = [app_info.app, current_user_info['name'] || 'public link', current_user_info['email'] || 'none'].map{ |e| Base64.strict_encode64(e)}
+        cookie_elements = [app_info.app, current_user_info['name'] || 'public link', current_user_info['email'] || 'none'].map { |e| Base64.strict_encode64(e) }
         cookie_elements.unshift(COOKIE_PREFIX_CONSOLE_AOC)
         transfer_spec['cookie'] = cookie_elements.join(':')
         # Application tags

data/lib/aspera/api/cos_node.rb

@@ -12,19 +12,20 @@ module Aspera
       IBM_CLOUD_TOKEN_URL = 'https://iam.cloud.ibm.com/identity'
       TOKEN_FIELD = 'delegated_refresh_token'
       FASP_INFO_KEYS = %w[ATSEndpoint AccessKey].freeze
+      SERVICE_CREDS_PARAMS = %w[apikey resource_instance_id endpoints]
       class << self
         def parameters_from_svc_credentials(service_credentials, bucket_region)
           # check necessary contents
-          Aspera.assert_type(service_credentials, Hash){'service_credentials'}
+          Aspera.assert_type(service_credentials, Hash) { 'service_credentials' }
           Log.dump(:service_credentials, service_credentials)
-          %w[apikey resource_instance_id endpoints].each do |field|
-            Aspera.assert(service_credentials.key?(field)){"service_credentials must have a field: #{field}"}
+          SERVICE_CREDS_PARAMS.each do |field|
+            Aspera.assert(service_credentials.key?(field)) { "service_credentials must have a field: #{field}" }
           end
           # read endpoints from service provided in service credentials
           endpoints = Aspera::Rest.new(base_url: service_credentials['endpoints']).read('')
           Log.dump(:endpoints, endpoints)
           endpoint = endpoints.dig('service-endpoints', 'regional', bucket_region, 'public', bucket_region)
-          raise "no such region: #{bucket_region}" if endpoint.nil?
+          Aspera.assert(!endpoint.nil?) { "no such region: #{bucket_region}" }
           return {
             instance_id: service_credentials['resource_instance_id'],
             api_key:     service_credentials['apikey'],
@@ -34,8 +35,8 @@ module Aspera
       end
 
       def initialize(instance_id:, api_key:, endpoint:, bucket:, auth_url: IBM_CLOUD_TOKEN_URL)
-        Aspera.assert_type(instance_id, String){'resource instance id (crn)'}
-        Aspera.assert_type(endpoint, String){'endpoint'}
+        Aspera.assert_type(instance_id, String) { 'resource instance id (crn)' }
+        Aspera.assert_type(endpoint, String) { 'endpoint' }
         endpoint = "https://#{endpoint}" unless endpoint.start_with?('http')
         @auth_url = auth_url
         @api_key = api_key
@@ -61,10 +62,10 @@ module Aspera
           ret:       :resp
         ).body
         ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
-        Log.dump(:ats_info, ats_info)
-        Aspera.assert_hash_all(ats_info, String, nil){'ats_info'}
+        Log.dump(:ats_info, ats_info.reject { |k, _| k == 'AccessKey' })
+        Aspera.assert_hash_all(ats_info, String, nil) { 'ats_info' }
         Aspera.assert((FASP_INFO_KEYS - ats_info.keys).empty?, 'ats_info missing required keys')
-        Aspera.assert_hash_all(ats_info['AccessKey'], String, String){'ats_info'}
+        Aspera.assert_hash_all(ats_info['AccessKey'], String, String) { 'ats_info' }
         @storage_credentials = {
           'type'  => 'token',
           'token' => {TOKEN_FIELD => nil}

data/lib/aspera/api/faspex.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/assert'
 require 'aspera/rest'
 require 'aspera/oauth/base'
 require 'aspera/rest_list'
@@ -11,9 +12,9 @@ module Aspera
     class << self
       attr_accessor :additional_info
     end
-    # @param context         The `context` query parameter in public link
-    # @param redirect_uri    URI of web UI login
-    # @param path_authorize  Path to provide passcode
+    # @param context        [String] The `context` query parameter in public link
+    # @param redirect_uri   [String] URI of web UI login
+    # @param path_authorize [String] Path to provide passcode
     def initialize(
       context:,
       redirect_uri:,
@@ -125,7 +126,7 @@ module Aspera
         mfa_code
       ]
       class << self
-        # @return true if the URL is a public link
+        # @return [Boolean] true if the URL is a public link
         def public_link?(url)
           url.include?('?context=')
         end
@@ -138,15 +139,15 @@ module Aspera
       end
       attr_reader :pub_link_context
 
-      # @param url             Faspex URL, can be a public link
-      # @param auth            Authentication method: :boot (token in header), :web (open browser), :jwt (client_id + private key), :public_link (context in URL)
-      # @param password        For :boot auth, the token copied directly from browser in developer mode
-      # @param client_id       For :web and :jwt auth, the client_id of web UI application
-      # @param client_secret   For :web auth, the client_secret of web UI application (not needed for :jwt)
-      # @param redirect_uri    For :web auth, the redirect_uri of web UI application (must be the same as in application configuration)
-      # @param username        For :jwt auth, the username of the user to impersonate
-      # @param private_key     For :jwt auth, the private key to sign JWT token
-      # @param passphrase      For :jwt auth, the passphrase of the private key
+      # @param url            [String] Faspex URL, can be a public link
+      # @param auth           [Symbol] Authentication method: :boot (token in header), :web (open browser), :jwt (client_id + private key), :public_link (context in URL)
+      # @param password       [String, nil] For :boot auth, the token copied directly from browser in developer mode
+      # @param client_id      [String, nil] For :web and :jwt auth, the client_id of web UI application
+      # @param client_secret  [String, nil] For :web auth, the client_secret of web UI application (not needed for :jwt)
+      # @param redirect_uri   [String, nil] For :web auth, the redirect_uri of web UI application (must be the same as in application configuration)
+      # @param username       [String, nil] For :jwt auth, the username of the user to impersonate
+      # @param private_key    [String, nil] For :jwt auth, the private key to sign JWT token
+      # @param passphrase     [String, nil] For :jwt auth, the passphrase of the private key
       def initialize(
         url:,
         auth:,
@@ -169,7 +170,7 @@ module Aspera
             Log.dump(:final_url, final_url, level: :trace1)
             # Get context from query
             encoded_context = Rest.query_to_h(URI.parse(final_url).query)['context']
-            raise ParameterError, 'Bad faspex5 public link, missing context in query' if encoded_context.nil?
+            Aspera.assert(!encoded_context.nil?, type: ParameterError) { 'Bad faspex5 public link, missing context in query' }
             # public link information (contains passcode and allowed usage)
             @pub_link_context = JSON.parse(Base64.decode64(encoded_context))
             Log.dump(:pub_link_context, @pub_link_context, level: :trace1)
@@ -237,7 +238,7 @@ module Aspera
                 headers:         {typ: 'JWT'}
               }
             }
-          else Aspera.error_unexpected_value(auth, type: ParameterError){'auth'}
+          else Aspera.error_unexpected_value(auth, type: ParameterError) { 'auth' }
           end
         )
       end

data/lib/aspera/api/httpgw.rb

@@ -60,7 +60,7 @@ module Aspera
 
       # send data on http gw web socket
       def ws_send(ws_type:, data:)
-        Log.log.trace1{"#{LOG_WS_SEND}sending: #{ws_type} (#{data&.length || 0} bytes)"}
+        Log.log.trace1 { "#{LOG_WS_SEND}sending: #{ws_type} (#{data&.length || 0} bytes)" }
         @shared_info[:count][:sent_general] += 1 if ws_type.eql?(:binary)
         frame_generator = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: ws_type, version: @ws_handshake.version)
         @ws_io.write(frame_generator.to_s)
@@ -72,16 +72,16 @@ module Aspera
                 @shared_info[:read_exception].nil? &&
                 (((@shared_info[:count][:sent_general] - @shared_info[:count][:received_general]) > 1) ||
                   ((@shared_info[:count][:received_v2_delimiter] - @shared_info[:count][:sent_v2_delimiter]) > 1))
-              Log.log.trace1{"#{LOG_WS_SEND}#{'timeout'.blue}: #{@shared_info[:count]}"} if !@shared_info[:cond_var].wait(@shared_info[:mutex], 2.0)
+              Log.log.trace1 { "#{LOG_WS_SEND}#{'timeout'.blue}: #{@shared_info[:count]}" } if !@shared_info[:cond_var].wait(@shared_info[:mutex], 2.0)
             end
           end
         end
         raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
-        Log.log.trace2{"#{LOG_WS_SEND}counts: #{@shared_info[:count]}"}
+        Log.log.trace2 { "#{LOG_WS_SEND}counts: #{@shared_info[:count]}" }
       end
 
       # Check header ourself and give precise error message, as websocket will only throw error without details
-      # @param [String] Response Header
+      # @param header [String] Response Header
       # @return [String] Response Header
       def validated_ws_response_header(header)
         first_line = header.split("\r\n").first
@@ -91,7 +91,7 @@ module Aspera
 
       # message processing for read thread
       def process_received_message(message)
-        Log.log.debug{"#{LOG_WS_RECV}message: [#{message}] (#{message.class})"}
+        Log.log.debug { "#{LOG_WS_RECV}message: [#{message}] (#{message.class})" }
         if message.eql?(MSG_RECV_DATA_RECEIVED_SIGNAL)
           @shared_info[:mutex].synchronize do
             @shared_info[:count][:received_general] += 1
@@ -119,21 +119,21 @@ module Aspera
 
       # main function of read thread
       def process_read_thread
-        Log.log.debug{"#{LOG_WS_RECV}read thread started"}
+        Log.log.debug { "#{LOG_WS_RECV}read thread started" }
         frame_parser = ::WebSocket::Frame::Incoming::Client.new(version: @ws_handshake.version)
         until @ws_io.eof?
           begin
             # ready byte by byte until frame is ready
             # blocking read
             byte = @ws_io.read(1)
-            Log.log.trace2{"#{LOG_WS_RECV}read: #{byte} (#{byte.class}) eof=#{@ws_io.eof?}"}
+            Log.log.trace2 { "#{LOG_WS_RECV}read: #{byte} (#{byte.class}) eof=#{@ws_io.eof?}" }
             frame_parser << byte
             frame_ok = frame_parser.next
             next if frame_ok.nil?
             process_received_message(frame_ok.data.to_s)
-            Log.log.trace2{"#{LOG_WS_RECV}counts: #{@shared_info[:count]}"}
+            Log.log.trace2 { "#{LOG_WS_RECV}counts: #{@shared_info[:count]}" }
           rescue => e
-            Log.log.debug{"#{LOG_WS_RECV}Exception: #{e}"}
+            Log.log.debug { "#{LOG_WS_RECV}Exception: #{e}" }
             @shared_info[:mutex].synchronize do
               @shared_info[:read_exception] = e
               @shared_info[:cond_var].signal
@@ -144,7 +144,7 @@ module Aspera
         Log.log.debug do
           "#{LOG_WS_RECV}exception: #{@shared_info[:read_exception]},cls=#{@shared_info[:read_exception].class})"
         end unless @shared_info[:read_exception].nil?
-        Log.log.debug{"#{LOG_WS_RECV}read thread stopped (ws eof=#{@ws_io.eof?})"}
+        Log.log.debug { "#{LOG_WS_RECV}read thread stopped (ws eof=#{@ws_io.eof?})" }
       end
 
       def upload(transfer_spec)
@@ -170,7 +170,7 @@ module Aspera
         # Get whole HTTP response header, Check and process
         # no need to check `finished?` or result of `<<` (true), as we give the whole header at once
         @ws_handshake << validated_ws_response_header(@ws_io.readuntil("\r\n\r\n"))
-        Log.log.debug{"#{LOG_WS_SEND}handshake success"}
+        Log.log.debug { "#{LOG_WS_SEND}handshake success" }
         # data shared between main thread and read thread
         @shared_info = {
           read_exception: nil, # error message if any in callback
@@ -184,7 +184,7 @@ module Aspera
           cond_var:       ConditionVariable.new
         }
         # start read thread after handshake
-        @ws_read_thread = Thread.new{process_read_thread}
+        @ws_read_thread = Thread.new { process_read_thread }
         @notify_cb&.call(:session_start, session_id: session_id)
         @notify_cb&.call(:session_size, session_id: session_id, info: total_bytes_to_transfer)
         sleep(1)
@@ -210,7 +210,7 @@ module Aspera
             fileIndex:    file_index
           }
           file = file_to_send[:file]
-          file = File.open(file) unless file.is_a?(Transfer::FauxFile)
+          file = File.open(file) unless file.is_a?(Transfer::FauxFile) # rubocop:disable Style/FileOpen
           begin
             until file.eof?
               slice_bin_data = file.read(@upload_chunk_size)
@@ -224,7 +224,7 @@ module Aspera
                   # send once, before data, at beginning
                   ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(0)
                   ws_send(ws_type: :binary, data: slice_bin_data)
-                  Log.log.trace1{"#{LOG_WS_SEND}buffer: file: #{file_index}, slice: #{slice_info[:slice]}/#{last_slice}"}
+                  Log.log.trace1 { "#{LOG_WS_SEND}buffer: file: #{file_index}, slice: #{slice_info[:slice]}/#{last_slice}" }
                   # send once, after data, at end
                   ws_snd_json(MSG_SEND_SLICE_UPLOAD, slice_info) if slice_info[:slice].eql?(last_slice)
                 end
@@ -232,7 +232,7 @@ module Aspera
                 raise @shared_info[:read_exception] unless @shared_info[:read_exception].nil?
                 raise e
               rescue Net::ReadTimeout => e
-                Log.log.warn{'A timeout condition using HTTPGW may signal a permission problem on destination. Check ascp logs on httpgw.'}
+                Log.log.warn { 'A timeout condition using HTTPGW may signal a permission problem on destination. Check ascp logs on httpgw.' }
                 raise e
               end
               session_sent_bytes += slice_bin_data.length
@@ -250,7 +250,7 @@ module Aspera
         ws_send(ws_type: :close, data: nil)
         Log.log.debug("Finished upload, waiting for end of #{THR_RECV} thread.")
         @ws_read_thread.join
-        Log.log.debug{'Read thread joined'}
+        Log.log.debug { 'Read thread joined' }
       ensure
         # session no more used
         @ws_io = nil
@@ -284,14 +284,14 @@ module Aspera
             File.basename(default_file_name)
           end
         file_path = File.join(transfer_spec['destination_root'], file_name)
-        call(operation: 'GET', subpath: "download/#{transfer_uuid}", save_to_file: file_path)
+        call(operation: 'GET', subpath: "download/#{transfer_uuid}", save_to: file_path)
       end
 
       def info
         return @api_info
       end
 
-      # @return the base url of the gateway
+      # @return [String] the base url of the gateway
       def base_url
         return @gw_root_url
       end
@@ -308,7 +308,7 @@ module Aspera
         Log.dump(:gw_url, url)
         # add scheme if missing
         url = "https://#{url}" unless url.match?(%r{^[a-z]{1,6}://})
-        raise Error, 'GW URL shall be with scheme https' unless url.start_with?('https://')
+        Aspera.assert(url.start_with?('https://'), type: Error) { 'GW URL shall be with scheme https' }
         # remove trailing slash and version (o=only once) if present
         # TODO: issue warning ?
         url = url.chomp('/').gsub(%r{/#{API_V1}$}o, '')
@@ -326,8 +326,8 @@ module Aspera
         # web socket endpoint: by default use v2 (newer gateways), without base64 encoding
         # is the latest supported? else revert to old api
         if !@upload_version.eql?(API_V1)
-          if !@api_info['endpoints'].any?{ |i| i.include?(@upload_version)}
-            Log.log.warn{"API version #{@upload_version} not supported, reverting to #{API_V1}"}
+          if !@api_info['endpoints'].any? { |i| i.include?(@upload_version) }
+            Log.log.warn { "API version #{@upload_version} not supported, reverting to #{API_V1}" }
             @upload_version = API_V1
           end
         end
@@ -386,7 +386,7 @@ module Aspera
                     size: file_size
                   })
                 else
-                  Log.log.warn{"Ignoring non file/directory: #{entry_path}"}
+                  Log.log.warn { "Ignoring non file/directory: #{entry_path}" }
                 end
               end
             end
@@ -394,7 +394,7 @@ module Aspera
             raise "File not found: #{source_path}"
           end
         end
-        transfer_spec['paths'] = files_to_send.map{ |i| {'source' => i[:name]}}
+        transfer_spec['paths'] = files_to_send.map { |i| {'source' => i[:name]} }
         files_to_send.push(total_bytes_to_transfer)
         return files_to_send
       end