aspera-cli 4.10.0 → 4.12.0

data/lib/aspera/oauth.rb

@@ -24,8 +24,8 @@ module Aspera
     # OAuth methods supported by default
     STD_AUTH_TYPES = %i[web jwt].freeze
 
-    # remove 5 minutes to account for time offset (TODO: configurable?)
-    JWT_NOTBEFORE_OFFSET_SEC = 300
+    # remove 5 minutes to account for time offset between client and server (TODO: configurable?)
+    JWT_ACCEPTED_OFFSET_SEC = 300
     # one hour validity (TODO: configurable?)
     JWT_EXPIRY_OFFSET_SEC = 3600
     # tokens older than 30 minutes will be discarded from cache
@@ -35,7 +35,7 @@ module Aspera
     # a prefix for persistency of tokens (simplify garbage collect)
     PERSIST_CATEGORY_TOKEN = 'token'
 
-    private_constant :JWT_NOTBEFORE_OFFSET_SEC,:JWT_EXPIRY_OFFSET_SEC,:TOKEN_CACHE_EXPIRY_SEC,:PERSIST_CATEGORY_TOKEN,:TOKEN_EXPIRATION_GUARD_SEC
+    private_constant :JWT_ACCEPTED_OFFSET_SEC, :JWT_EXPIRY_OFFSET_SEC, :TOKEN_CACHE_EXPIRY_SEC, :PERSIST_CATEGORY_TOKEN, :TOKEN_EXPIRATION_GUARD_SEC
 
     # persistency manager
     @persist = nil
@@ -48,7 +48,7 @@ module Aspera
       def persist_mgr=(manager)
         @persist = manager
         # cleanup expired tokens
-        @persist.garbage_collect(PERSIST_CATEGORY_TOKEN,TOKEN_CACHE_EXPIRY_SEC)
+        @persist.garbage_collect(PERSIST_CATEGORY_TOKEN, TOKEN_CACHE_EXPIRY_SEC)
       end
 
       def persist_mgr
@@ -56,7 +56,7 @@ module Aspera
           Log.log.debug('Not using persistency') # (use Aspera::Oauth.persist_mgr=Aspera::PersistencyFolder.new)
           # create NULL persistency class
           @persist = Class.new do
-            def get(_x);nil;end;def delete(_x);nil;end;def put(_x,_y);nil;end;def garbage_collect(_x,_y);nil;end # rubocop:disable Layout/EmptyLineBetweenDefs
+            def get(_x); nil; end; def delete(_x); nil; end; def put(_x, _y); nil; end; def garbage_collect(_x, _y); nil; end # rubocop:disable Layout/EmptyLineBetweenDefs, Style/Semicolon, Layout/LineLength
           end.new
         end
         return @persist
@@ -64,7 +64,7 @@ module Aspera
 
       # delete all existing tokens
       def flush_tokens
-        persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN,nil)
+        persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN, nil)
       end
 
       # register a bearer token decoder, mainly to inspect expiry date
@@ -83,7 +83,7 @@ module Aspera
       end
 
       # register a token creation method
-      # @param id creation type from field :crtype in constructor
+      # @param id creation type from field :grant_method in constructor
       # @param lambda_create called to create token
       # @param id_create called to generate unique id for token, for cache
       def register_token_creator(id, lambda_create, id_create)
@@ -94,86 +94,87 @@ module Aspera
 
       # @return one of the registered creators for the given create type
       def token_creator(id)
-        raise "token creator type unknown: #{id}/#{id.class}" unless @create_handlers.has_key?(id)
+        raise "token grant method unknown: #{id}/#{id.class}" unless @create_handlers.key?(id)
         @create_handlers[id]
       end
 
-      # list of identifiers foundn in creation parameters that can be used to uniquely identify the token
+      # list of identifiers found in creation parameters that can be used to uniquely identify the token
       def id_creator(id)
-        raise "id creator type unknown: #{id}/#{id.class}" unless @id_handlers.has_key?(id)
+        raise "id creator type unknown: #{id}/#{id.class}" unless @id_handlers.key?(id)
         @id_handlers[id]
       end
     end # self
 
     # JSON Web Signature (JWS) compact serialization: https://datatracker.ietf.org/doc/html/rfc7515
-    register_decoder lambda { |token| parts = token.split('.'); raise 'not aoc token' unless parts.length.eql?(3); JSON.parse(Base64.decode64(parts[1]))}
+    register_decoder lambda { |token| parts = token.split('.'); raise 'not aoc token' unless parts.length.eql?(3); JSON.parse(Base64.decode64(parts[1]))} # rubocop:disable Style/Semicolon, Layout/LineLength
 
     # generic token creation, parameters are provided in :generic
-    register_token_creator :generic,lambda { |oauth|
-      return oauth.create_token(oauth.sparams)
-    },lambda { |oauth|
+    register_token_creator :generic, lambda { |oauth|
+      return oauth.create_token(oauth.specific_parameters)
+    }, lambda { |oauth|
       return [
-        oauth.sparams[:grant_type]&.split(':')&.last,
-        oauth.sparams[:apikey],
-        oauth.sparams[:response_type]
+        oauth.specific_parameters[:grant_type]&.split(':')&.last,
+        oauth.specific_parameters[:apikey],
+        oauth.specific_parameters[:response_type]
       ]
     }
 
     # Authentication using Web browser
-    register_token_creator :web,lambda { |oauth|
+    register_token_creator :web, lambda { |oauth|
       random_state = SecureRandom.uuid # used to check later
-      login_page_url = Rest.build_uri("#{oauth.api[:base_url]}/#{oauth.sparams[:path_authorize]}",
-        oauth.optional_scope_client_id.merge(response_type: 'code', redirect_uri: oauth.sparams[:redirect_uri], state: random_state))
+      login_page_url = Rest.build_uri(
+        "#{oauth.api.params[:base_url]}/#{oauth.specific_parameters[:path_authorize]}",
+        oauth.optional_scope_client_id.merge(response_type: 'code', redirect_uri: oauth.specific_parameters[:redirect_uri], state: random_state))
       # here, we need a human to authorize on a web page
-      Log.log.info("login_page_url=#{login_page_url}".bg_red.gray)
+      Log.log.info{"login_page_url=#{login_page_url}".bg_red.gray}
       # start a web server to receive request code
-      webserver = WebAuth.new(oauth.sparams[:redirect_uri])
+      web_server = WebAuth.new(oauth.specific_parameters[:redirect_uri])
       # start browser on login page
       OpenApplication.instance.uri(login_page_url)
       # wait for code in request
-      received_params = webserver.received_request
+      received_params = web_server.received_request
       raise 'wrong received state' unless random_state.eql?(received_params['state'])
       # exchange code for token
       return oauth.create_token(oauth.optional_scope_client_id(add_secret: true).merge(
         grant_type:   'authorization_code',
         code:         received_params['code'],
-        redirect_uri: oauth.sparams[:redirect_uri]))
-    },lambda { |_oauth|
+        redirect_uri: oauth.specific_parameters[:redirect_uri]))
+    }, lambda { |_oauth|
       return []
     }
 
     # Authentication using private key
-    register_token_creator :jwt,lambda { |oauth|
+    register_token_creator :jwt, lambda { |oauth|
       # https://tools.ietf.org/html/rfc7523
       # https://tools.ietf.org/html/rfc7519
       require 'jwt'
       seconds_since_epoch = Time.new.to_i
-      Log.log.info("seconds=#{seconds_since_epoch}")
-      raise 'missing JWT payload' unless oauth.sparams[:payload].is_a?(Hash)
+      Log.log.info{"seconds=#{seconds_since_epoch}"}
+      raise 'missing JWT payload' unless oauth.specific_parameters[:payload].is_a?(Hash)
       jwt_payload = {
         exp: seconds_since_epoch + JWT_EXPIRY_OFFSET_SEC, # expiration time
-        nbf: seconds_since_epoch - JWT_NOTBEFORE_OFFSET_SEC, # not before
-        iat: seconds_since_epoch, # issued at
+        nbf: seconds_since_epoch - JWT_ACCEPTED_OFFSET_SEC, # not before
+        iat: seconds_since_epoch - JWT_ACCEPTED_OFFSET_SEC + 1, # issued at (we tell a little in the past so that server always accepts)
         jti: SecureRandom.uuid # JWT id
-      }.merge(oauth.sparams[:payload])
-      Log.log.debug("JWT jwt_payload=[#{jwt_payload}]")
-      rsa_private = oauth.sparams[:private_key_obj] # type: OpenSSL::PKey::RSA
-      Log.log.debug("private=[#{rsa_private}]")
-      assertion = JWT.encode(jwt_payload, rsa_private, 'RS256', oauth.sparams[:headers] || {})
-      Log.log.debug("assertion=[#{assertion}]")
+      }.merge(oauth.specific_parameters[:payload])
+      Log.log.debug{"JWT jwt_payload=[#{jwt_payload}]"}
+      rsa_private = oauth.specific_parameters[:private_key_obj] # type: OpenSSL::PKey::RSA
+      Log.log.debug{"private=[#{rsa_private}]"}
+      assertion = JWT.encode(jwt_payload, rsa_private, 'RS256', oauth.specific_parameters[:headers] || {})
+      Log.log.debug{"assertion=[#{assertion}]"}
       return oauth.create_token(oauth.optional_scope_client_id.merge(grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer', assertion: assertion))
-    },lambda { |oauth|
-      return [oauth.sparams.dig(:payload,:sub)]
+    }, lambda { |oauth|
+      return [oauth.specific_parameters.dig(:payload, :sub)]
     }
 
-    attr_reader :gparams, :sparams, :api
+    attr_reader :generic_parameters, :specific_parameters, :api
 
     private
 
     # [M]=mandatory [D]=has default value [0]=accept nil
     # :base_url            [M]  URL of authentication API
     # :auth
-    # :crtype              [M]  :generic, :web, :jwt, custom
+    # :grant_method        [M]  :generic, :web, :jwt, custom
     # :client_id           [0]
     # :client_secret       [0]
     # :scope               [0]
@@ -186,50 +187,53 @@ module Aspera
     # :web:path_authorize  [D] for type :web
     # :generic             [M] for type :generic
     def initialize(a_params)
-      Log.log.debug("auth=#{a_params}")
+      Log.log.debug{"auth=#{a_params}"}
       # replace default values
-      @gparams = DEFAULT_CREATE_PARAMS.deep_merge(a_params)
+      @generic_parameters = DEFAULT_CREATE_PARAMS.deep_merge(a_params)
+      # legacy
+      @generic_parameters[:grant_method] ||= @generic_parameters.delete(:crtype) if @generic_parameters.key?(:crtype)
       # check that type is known
-      self.class.token_creator(@gparams[:crtype])
+      self.class.token_creator(@generic_parameters[:grant_method])
       # specific parameters for the creation type
-      @sparams=@gparams[@gparams[:crtype]]
-      if @gparams[:crtype].eql?(:web) && @sparams.has_key?(:redirect_uri)
-        uri = URI.parse(@sparams[:redirect_uri])
+      @specific_parameters = @generic_parameters[@generic_parameters[:grant_method]]
+      if @generic_parameters[:grant_method].eql?(:web) && @specific_parameters.key?(:redirect_uri)
+        uri = URI.parse(@specific_parameters[:redirect_uri])
         raise 'redirect_uri scheme must be http or https' unless %w[http https].include?(uri.scheme)
         raise 'redirect_uri must have a port' if uri.port.nil?
         # TODO: we could check that host is localhost or local address
       end
       rest_params = {
-        base_url:     @gparams[:base_url],
+        base_url:     @generic_parameters[:base_url],
         redirect_max: 2
       }
-      rest_params[:auth] = a_params[:auth] if a_params.has_key?(:auth)
+      rest_params[:auth] = a_params[:auth] if a_params.key?(:auth)
       @api = Rest.new(rest_params)
       # if needed use from api
-      @gparams.delete(:base_url)
-      @gparams.delete(:auth)
-      @gparams.delete(@gparams[:crtype])
-      Log.dump(:gparams,@gparams)
-      Log.dump(:sparams,@sparams)
+      @generic_parameters.delete(:base_url)
+      @generic_parameters.delete(:auth)
+      @generic_parameters.delete(@generic_parameters[:grant_method])
+      Log.dump(:generic_parameters, @generic_parameters)
+      Log.dump(:specific_parameters, @specific_parameters)
     end
 
     public
 
     # helper method to create token as per RFC
     def create_token(www_params)
+      Log.log.debug{'Generating a new token'.bg_green}
       return @api.call({
         operation:       'POST',
-        subpath:         @gparams[:path_token],
+        subpath:         @generic_parameters[:path_token],
         headers:         {'Accept' => 'application/json'},
         www_body_params: www_params})
     end
 
     # @return Hash with optional general parameters
     def optional_scope_client_id(add_secret: false)
-      call_params={}
-      call_params[:scope] = @gparams[:scope] unless @gparams[:scope].nil?
-      call_params[:client_id] = @gparams[:client_id] unless @gparams[:client_id].nil?
-      call_params[:client_secret] = @gparams[:client_secret] if add_secret && !@gparams[:client_id].nil?
+      call_params = {}
+      call_params[:scope] = @generic_parameters[:scope] unless @generic_parameters[:scope].nil?
+      call_params[:client_id] = @generic_parameters[:client_id] unless @generic_parameters[:client_id].nil?
+      call_params[:client_secret] = @generic_parameters[:client_secret] if add_secret && !@generic_parameters[:client_id].nil?
       return call_params
     end
 
@@ -240,21 +244,21 @@ module Aspera
       token_id = IdGenerator.from_list([
         PERSIST_CATEGORY_TOKEN,
         @api.params[:base_url],
-        @gparams[:crtype],
-        self.class.id_creator(@gparams[:crtype]).call(self), # array, so we flatten later
-        @gparams[:scope],
+        @generic_parameters[:grant_method],
+        self.class.id_creator(@generic_parameters[:grant_method]).call(self), # array, so we flatten later
+        @generic_parameters[:scope],
         @api.params.dig(%i[auth username])
       ].flatten)
 
       # get token_data from cache (or nil), token_data is what is returned by /token
       token_data = self.class.persist_mgr.get(token_id) if use_cache
       token_data = JSON.parse(token_data) unless token_data.nil?
-      # Optional optimization: check if node token is expired  basd on decoded content then force refresh if close enough
+      # Optional optimization: check if node token is expired based on decoded content then force refresh if close enough
       # might help in case the transfer agent cannot refresh himself
       # `direct` agent is equipped with refresh code
       if !use_refresh_token && !token_data.nil?
-        decoded_token = self.class.decode_token(token_data[@gparams[:token_field]])
-        Log.dump('decoded_token',decoded_token) unless decoded_token.nil?
+        decoded_token = self.class.decode_token(token_data[@generic_parameters[:token_field]])
+        Log.dump('decoded_token', decoded_token) unless decoded_token.nil?
         if decoded_token.is_a?(Hash)
           expires_at_sec =
             if    decoded_token['expires_at'].is_a?(String) then DateTime.parse(decoded_token['expires_at']).to_time
@@ -262,13 +266,13 @@ module Aspera
             end
           # force refresh if we see a token too close from expiration
           use_refresh_token = true if expires_at_sec.is_a?(Time) && (expires_at_sec - Time.now) < TOKEN_EXPIRATION_GUARD_SEC
-          Log.log.debug("Expiration: #{expires_at_sec} / #{use_refresh_token}")
+          Log.log.debug{"Expiration: #{expires_at_sec} / #{use_refresh_token}"}
         end
       end
 
       # an API was already called, but failed, we need to regenerate or refresh
       if use_refresh_token
-        if token_data.is_a?(Hash) && token_data.has_key?('refresh_token')
+        if token_data.is_a?(Hash) && token_data.key?('refresh_token')
           # save possible refresh token, before deleting the cache
           refresh_token = token_data['refresh_token']
         end
@@ -277,31 +281,31 @@ module Aspera
         token_data = nil
         # lets try the existing refresh token
         if !refresh_token.nil?
-          Log.log.info("refresh=[#{refresh_token}]".bg_green)
+          Log.log.info{"refresh=[#{refresh_token}]".bg_green}
           # try to refresh
           # note: AoC admin token has no refresh, and lives by default 1800secs
-          resp = create_token(optional_scope_client_id.merge(grant_type: 'refresh_token',refresh_token: refresh_token))
+          resp = create_token(optional_scope_client_id.merge(grant_type: 'refresh_token', refresh_token: refresh_token))
           if resp[:http].code.start_with?('2')
             # save only if success
             json_data = resp[:http].body
             token_data = JSON.parse(json_data)
-            self.class.persist_mgr.put(token_id,json_data)
+            self.class.persist_mgr.put(token_id, json_data)
           else
-            Log.log.debug("refresh failed: #{resp[:http].body}".bg_red)
+            Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
           end
         end
       end
 
       # no cache, nor refresh: generate a token
       if token_data.nil?
-        resp = self.class.token_creator(@gparams[:crtype]).call(self)
+        resp = self.class.token_creator(@generic_parameters[:grant_method]).call(self)
         json_data = resp[:http].body
         token_data = JSON.parse(json_data)
-        self.class.persist_mgr.put(token_id,json_data)
+        self.class.persist_mgr.put(token_id, json_data)
       end # if ! in_cache
-      raise "API error: No such field in answer: #{@gparams[:token_field]}" unless token_data.has_key?(@gparams[:token_field])
+      raise "API error: No such field in answer: #{@generic_parameters[:token_field]}" unless token_data.key?(@generic_parameters[:token_field])
       # ok we shall have a token here
-      return 'Bearer ' + token_data[@gparams[:token_field]]
+      return 'Bearer ' + token_data[@generic_parameters[:token_field]]
     end
   end # OAuth
 end # Aspera

data/lib/aspera/open_application.rb

@@ -12,30 +12,38 @@ module Aspera
   class OpenApplication
     include Singleton
     class << self
+      USER_INTERFACES = %i[text graphical].freeze
       # User Interfaces
-      def user_interfaces; %i[text graphical]; end
+      def user_interfaces; USER_INTERFACES; end
 
       def default_gui_mode
-        return :graphical if [Aspera::Environment::OS_WINDOWS,Aspera::Environment::OS_X].include?(Aspera::Environment.os)
+        return :graphical if [Aspera::Environment::OS_WINDOWS, Aspera::Environment::OS_X].include?(Aspera::Environment.os)
         # unix family
-        return :graphical if ENV.has_key?('DISPLAY') && !ENV['DISPLAY'].empty?
+        return :graphical if ENV.key?('DISPLAY') && !ENV['DISPLAY'].empty?
         return :text
       end
 
       # command must be non blocking
       def uri_graphical(uri)
         case Aspera::Environment.os
-        when Aspera::Environment::OS_X
-          return system('open',uri.to_s)
-        when Aspera::Environment::OS_WINDOWS
-          return system('start explorer "' + uri.to_s + '"')
-        when Aspera::Environment::OS_LINUX
-          return system("xdg-open '#{uri}'")
+        when Aspera::Environment::OS_X       then return system('open', uri.to_s)
+        when Aspera::Environment::OS_WINDOWS then return system('start', 'explorer', '"' + uri.to_s + '"')
+        when Aspera::Environment::OS_LINUX   then return system('xdg-open', uri.to_s)
         else
           raise "no graphical open method for #{Aspera::Environment.os}"
         end
       end
-    end
+
+      def editor(file_path)
+        if ENV.key?('EDITOR')
+          system(ENV['EDITOR'], file_path.to_s)
+        elsif Aspera::Environment.os.eql?(Aspera::Environment::OS_WINDOWS)
+          system('notepad.exe', '"' + file_path.to_s + '"')
+        else
+          uri_graphical(file_path.to_s)
+        end
+      end
+    end # self
 
     attr_accessor :url_method
 
@@ -56,7 +64,7 @@ module Aspera
           puts "USER ACTION: open this:\n" + the_url.to_s.red + "\n"
         end
       else
-        raise StandardError,"unsupported url open method: #{@url_method}"
+        raise StandardError, "unsupported url open method: #{@url_method}"
       end
     end
   end # OpenApplication

data/lib/aspera/persistency_action_once.rb

@@ -14,7 +14,7 @@ module Aspera
     # @param :format   Optional  dump method (default to JSON)
     # @param :merge    Optional  merge data from file to current data
     def initialize(options)
-      Log.log.debug("persistency: #{options}")
+      Log.log.debug{"persistency: #{options}"}
       raise 'options shall be Hash' unless options.is_a?(Hash)
       raise 'mandatory :manager' if options[:manager].nil?
       raise 'mandatory :data' if options[:data].nil?
@@ -27,16 +27,16 @@ module Aspera
       @delete_condition = options[:delete] || lambda{|d|d.empty?}
       @persist_format = options[:format] || lambda {|h| JSON.generate(h)}
       persist_parse = options[:parse] || lambda {|t| JSON.parse(t)}
-      persist_merge = options[:merge] || lambda {|current,file| current.concat(file).uniq rescue current}
+      persist_merge = options[:merge] || lambda {|current, file| current.concat(file).uniq rescue current}
       value = @manager.get(@object_id)
-      persist_merge.call(@persisted_object,persist_parse.call(value)) unless value.nil?
+      persist_merge.call(@persisted_object, persist_parse.call(value)) unless value.nil?
     end
 
     def save
       if @delete_condition.call(@persisted_object)
         @manager.delete(@object_id)
       else
-        @manager.put(@object_id,@persist_format.call(@persisted_object))
+        @manager.put(@object_id, @persist_format.call(@persisted_object))
       end
     end
 

data/lib/aspera/persistency_folder.rb

@@ -14,17 +14,17 @@ module Aspera
     def initialize(folder)
       @cache = {}
       @folder = folder
-      Log.log.debug("persistency folder: #{@folder}")
+      Log.log.debug{"persistency folder: #{@folder}"}
     end
 
     # @return String or nil string on existing persist, else nil
     def get(object_id)
-      Log.log.debug("persistency get: #{object_id}")
-      if @cache.has_key?(object_id)
+      Log.log.debug{"persistency get: #{object_id}"}
+      if @cache.key?(object_id)
         Log.log.debug('got from memory cache')
       else
         persist_filepath = id_to_filepath(object_id)
-        Log.log.debug("persistency = #{persist_filepath}")
+        Log.log.debug{"persistency = #{persist_filepath}"}
         if File.exist?(persist_filepath)
           Log.log.debug('got from file cache')
           @cache[object_id] = File.read(persist_filepath)
@@ -33,32 +33,32 @@ module Aspera
       return @cache[object_id]
     end
 
-    def put(object_id,value)
+    def put(object_id, value)
       raise 'value: only String supported' unless value.is_a?(String)
       persist_filepath = id_to_filepath(object_id)
-      Log.log.debug("persistency saving: #{persist_filepath}")
+      Log.log.debug{"persistency saving: #{persist_filepath}"}
       File.delete(persist_filepath) if File.exist?(persist_filepath)
-      File.write(persist_filepath,value)
+      File.write(persist_filepath, value)
       Environment.restrict_file_access(persist_filepath)
       @cache[object_id] = value
     end
 
     def delete(object_id)
       persist_filepath = id_to_filepath(object_id)
-      Log.log.debug("persistency deleting: #{persist_filepath}")
+      Log.log.debug{"persistency deleting: #{persist_filepath}"}
       File.delete(persist_filepath) if File.exist?(persist_filepath)
       @cache.delete(object_id)
     end
 
-    def garbage_collect(persist_category,max_age_seconds=nil)
-      garbage_files = Dir[File.join(@folder,persist_category + '*' + FILE_SUFFIX)]
+    def garbage_collect(persist_category, max_age_seconds=nil)
+      garbage_files = Dir[File.join(@folder, persist_category + '*' + FILE_SUFFIX)]
       if !max_age_seconds.nil?
         current_time = Time.now
         garbage_files.select! { |filepath| (current_time - File.stat(filepath).mtime).to_i > max_age_seconds}
       end
       garbage_files.each do |filepath|
         File.delete(filepath)
-        Log.log.debug("persistency deleted expired: #{filepath}")
+        Log.log.debug{"persistency deleted expired: #{filepath}"}
       end
       return garbage_files
     end
@@ -70,8 +70,8 @@ module Aspera
       raise 'object_id: only String supported' unless object_id.is_a?(String)
       FileUtils.mkdir_p(@folder)
       Environment.restrict_file_access(@folder)
-      return File.join(@folder,"#{object_id}#{FILE_SUFFIX}")
-      #.gsub(/[^a-z]+/,FILE_FIELD_SEPARATOR)
+      return File.join(@folder, "#{object_id}#{FILE_SUFFIX}")
+      # .gsub(/[^a-z]+/,FILE_FIELD_SEPARATOR)
     end
   end # PersistencyFolder
 end # Aspera

data/lib/aspera/preview/file_types.rb

@@ -286,20 +286,20 @@ module Aspera
         # check magic number inside file (empty string if not found)
         detected_mime = MimeMagic.by_magic(File.open(filepath)).to_s
         # check extension only
-        if !SUPPORTED_MIME_TYPES.has_key?(detected_mime)
-          Log.log.debug("no conversion for #{detected_mime}, trying extension")
+        if !SUPPORTED_MIME_TYPES.key?(detected_mime)
+          Log.log.debug{"no conversion for #{detected_mime}, trying extension"}
           detected_mime = MimeMagic.by_extension(File.extname(filepath)).to_s
         end
         detected_mime = nil if detected_mime.empty?
-        Log.log.debug("mimemagic: #{detected_mime.class.name} [#{detected_mime}]")
+        Log.log.debug{"mimemagic: #{detected_mime.class.name} [#{detected_mime}]"}
         return detected_mime
       end
 
       # return file type, one of enum CONVERSION_TYPES
       # @param filepath [String] full path to file
       # @param mimetype [String] provided by node api
-      def conversion_type(filepath,mimetype)
-        Log.log.debug("conversion_type(#{filepath},m=#{mimetype},t=#{@use_mimemagic})")
+      def conversion_type(filepath, mimetype)
+        Log.log.debug{"conversion_type(#{filepath},m=#{mimetype},t=#{@use_mimemagic})"}
         # 1- get type from provided mime type, using local mapping
         conv_type = SUPPORTED_MIME_TYPES[mimetype] if !mimetype.nil?
         # 2- else, from computed mime type (if available)
@@ -311,8 +311,8 @@ module Aspera
               if mimetype.eql?(detected_mime)
                 Log.log.debug('matching mime type per magic number')
               else
-                # note: detected can be nil
-                Log.log.debug("non matching mime types: node=[#{mimetype}], magic=[#{detected_mime}]")
+                # NOTE: detected can be nil
+                Log.log.debug{"non matching mime types: node=[#{mimetype}], magic=[#{detected_mime}]"}
               end
             end
           end
@@ -320,7 +320,7 @@ module Aspera
         # 3- else, from extensions, using local mapping
         extension = File.extname(filepath.downcase)[1..-1]
         conv_type = SUPPORTED_EXTENSIONS[extension] if conv_type.nil?
-        Log.log.debug("conversion_type(#{extension}): #{conv_type.class.name} [#{conv_type}]")
+        Log.log.debug{"conversion_type(#{extension}): #{conv_type.class.name} [#{conv_type}]"}
         return conv_type
       end
     end