aspera-cli 4.10.0 → 4.11.0

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

data/lib/aspera/preview/generator.rb

@@ -27,14 +27,14 @@ module Aspera
       #   -> preview_format is one of Generator::PREVIEW_FORMATS
       # the conversion video->mp4 is implemented in methods: convert_video_to_mp4_using_<video_conversion>
       #  -> conversion method is one of Generator::VIDEO_CONVERSION_METHODS
-      def initialize(options,src,dst,main_temp_dir,api_mime_type)
+      def initialize(options, src, dst, main_temp_dir, api_mime_type)
         @options = options
         @source_file_path = src
         @destination_file_path = dst
-        @temp_folder = File.join(main_temp_dir,@source_file_path.split('/').last.gsub(/\s/, '_').gsub(/\W/, ''))
+        @temp_folder = File.join(main_temp_dir, @source_file_path.split('/').last.gsub(/\s/, '_').gsub(/\W/, ''))
         # extract preview format from extension of target file
-        @preview_format_symb = File.extname(@destination_file_path).gsub(/^\./,'').to_sym
-        @conversion_type = FileTypes.instance.conversion_type(@source_file_path,api_mime_type)
+        @preview_format_symb = File.extname(@destination_file_path).gsub(/^\./, '').to_sym
+        @conversion_type = FileTypes.instance.conversion_type(@source_file_path, api_mime_type)
       end
 
       # name of processing method in this object
@@ -49,7 +49,7 @@ module Aspera
             name = "#{name}_using_#{@options.video_png_conv}"
           end
         end
-        Log.log.debug("method: #{name}")
+        Log.log.debug{"method: #{name}"}
         return name.to_sym
       end
 
@@ -57,25 +57,25 @@ module Aspera
       # for instance, plaintext to mp4 is not supported
       def supported?
         return false if @conversion_type.nil?
-        return respond_to?(processing_method_symb,true)
+        return respond_to?(processing_method_symb, true)
       end
 
       # create preview as specified in constructor
       def generate
         raise 'could not detect type of file' if @conversion_type.nil?
         method_symb = processing_method_symb
-        Log.log.info("#{@source_file_path}->#{@destination_file_path} (#{method_symb})")
+        Log.log.info{"#{@source_file_path}->#{@destination_file_path} (#{method_symb})"}
         begin
           send(method_symb)
           # check that generated size does not exceed maximum
           result_size = File.size(@destination_file_path)
           if result_size > @options.max_size
-            Log.log.warn("preview size exceeds maximum #{result_size} > #{@options.max_size}")
+            Log.log.warn{"preview size exceeds maximum #{result_size} > #{@options.max_size}"}
           end
         rescue StandardError => e
-          Log.log.error("Ignoging: #{e.message}")
+          Log.log.error{"Ignoging: #{e.message}"}
           Log.log.debug(e.backtrace.join("\n").red)
-          FileUtils.cp(File.expand_path(@preview_format_symb.eql?(:mp4) ? 'video_error.png' : 'image_error.png',File.dirname(__FILE__)),@destination_file_path)
+          FileUtils.cp(File.expand_path(@preview_format_symb.eql?(:mp4) ? 'video_error.png' : 'image_error.png', File.dirname(__FILE__)), @destination_file_path)
         ensure
           FileUtils.rm_rf(@temp_folder)
         end
@@ -106,10 +106,10 @@ module Aspera
         last_keyframe = nil
         current_index = 1
         1.upto(p_keyframecount) do |i|
-          offset_seconds = get_offset(p_duration,p_start_offset,p_keyframecount,i)
+          offset_seconds = get_offset(p_duration, p_start_offset, p_keyframecount, i)
           Utils.video_dump_frame(@source_file_path, offset_seconds, @options.video_scale, this_tmpdir, current_index)
           Utils.video_dupe_frame(this_tmpdir, current_index, @options.blend_pauseframes)
-          Utils.video_blend_frames(this_tmpdir,last_keyframe, current_index) unless last_keyframe.nil?
+          Utils.video_blend_frames(this_tmpdir, last_keyframe, current_index) unless last_keyframe.nil?
           # go to last dupe frame
           last_keyframe = current_index + @options.blend_pauseframes
           # go after last dupe frame and keep space to blend
@@ -117,41 +117,41 @@ module Aspera
         end
         Utils.ffmpeg(
           in_f: Utils.ffmpeg_fmt(this_tmpdir),
-          in_p: ['-framerate',@options.blend_fps],
+          in_p: ['-framerate', @options.blend_fps],
           out_f: @destination_file_path,
           out_p: [
-            '-filter:v',"scale='trunc(iw/2)*2:trunc(ih/2)*2'",
-            '-codec:v','libx264',
-            '-r',30,
-            '-pix_fmt','yuv420p'])
+            '-filter:v', "scale='trunc(iw/2)*2:trunc(ih/2)*2'",
+            '-codec:v', 'libx264',
+            '-r', 30,
+            '-pix_fmt', 'yuv420p'])
       end
 
       # generate n clips starting at offset
       def convert_video_to_mp4_using_clips
         p_duration = Utils.video_get_duration(@source_file_path)
-        filelist = File.join(this_tmpdir,'clip_files.txt')
+        filelist = File.join(this_tmpdir, 'clip_files.txt')
         File.open(filelist, 'w+') do |f|
           1.upto(@options.clips_count.to_i) do |i|
-            offset_seconds = get_offset(p_duration,@options.video_start_sec.to_i,@options.clips_count.to_i,i)
-            tmpfilename = format('clip%04d.mp4',i)
+            offset_seconds = get_offset(p_duration, @options.video_start_sec.to_i, @options.clips_count.to_i, i)
+            tmpfilename = format('clip%04d.mp4', i)
             Utils.ffmpeg(
               in_f: @source_file_path,
-              in_p: ['-ss',0.9 * offset_seconds],
-              out_f: File.join(this_tmpdir,tmpfilename),
+              in_p: ['-ss', offset_seconds * 0.9],
+              out_f: File.join(this_tmpdir, tmpfilename),
               out_p: [
-                '-ss',0.1 * offset_seconds,
-                '-t',@options.clips_length,
-                '-filter:v',"scale=#{@options.video_scale}",
-                '-codec:a','libmp3lame'])
+                '-ss', offset_seconds * 0.1,
+                '-t', @options.clips_length,
+                '-filter:v', "scale=#{@options.video_scale}",
+                '-codec:a', 'libmp3lame'])
             f.puts("file '#{tmpfilename}'")
           end
         end
         # concat clips
         Utils.ffmpeg(
           in_f: filelist,
-          in_p: ['-f','concat'],
+          in_p: ['-f', 'concat'],
           out_f: @destination_file_path,
-          out_p: ['-codec','copy'])
+          out_p: ['-codec', 'copy'])
       end
 
       # do a simple reencoding
@@ -160,20 +160,20 @@ module Aspera
           in_f: @source_file_path,
           out_f: @destination_file_path,
           out_p: [
-            '-t','60',
-            '-codec:v','libx264',
-            '-profile:v','high',
-            '-pix_fmt','yuv420p',
-            '-preset','slow',
-            '-b:v','500k',
-            '-maxrate','500k',
-            '-bufsize','1000k',
-            '-filter:v',"scale=#{@options.video_scale}",
-            '-threads','0',
-            '-codec:a','libmp3lame',
-            '-ac','2',
-            '-b:a','128k',
-            '-movflags','faststart'])
+            '-t', '60',
+            '-codec:v', 'libx264',
+            '-profile:v', 'high',
+            '-pix_fmt', 'yuv420p',
+            '-preset', 'slow',
+            '-b:v', '500k',
+            '-maxrate', '500k',
+            '-bufsize', '1000k',
+            '-filter:v', "scale=#{@options.video_scale}",
+            '-threads', '0',
+            '-codec:a', 'libmp3lame',
+            '-ac', '2',
+            '-b:a', '128k',
+            '-movflags', 'faststart'])
       end
 
       def convert_video_to_png_using_fixed
@@ -192,62 +192,62 @@ module Aspera
         Utils.ffmpeg(
           in_f: @source_file_path,
           in_p: [
-            '-ss',10, # seek to input position
-            '-t',20 # max seconds
+            '-ss', 10, # seek to input position
+            '-t', 20 # max seconds
           ],
           out_f: @destination_file_path,
           out_p: [
-            '-vf','fps=5,scale=120:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse',
-            '-loop',0,
-            '-f','gif'
+            '-vf', 'fps=5,scale=120:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse',
+            '-loop', 0,
+            '-f', 'gif'
           ])
       end
 
       def convert_office_to_png
-        tmp_pdf_file = File.join(this_tmpdir,File.basename(@source_file_path,File.extname(@source_file_path)) + '.pdf')
-        Utils.external_command(:unoconv,[
-          '-f','pdf',
-          '-o',tmp_pdf_file,
+        tmp_pdf_file = File.join(this_tmpdir, File.basename(@source_file_path, File.extname(@source_file_path)) + '.pdf')
+        Utils.external_command(:unoconv, [
+          '-f', 'pdf',
+          '-o', tmp_pdf_file,
           @source_file_path])
         convert_pdf_to_png(tmp_pdf_file)
       end
 
       def convert_pdf_to_png(source_file_path=nil)
         source_file_path ||= @source_file_path
-        Utils.external_command(:convert,[
-          '-size',"x#{@options.thumb_img_size}",
-          '-background','white',
+        Utils.external_command(:convert, [
+          '-size', "x#{@options.thumb_img_size}",
+          '-background', 'white',
           '-flatten',
           "#{source_file_path}[0]",
           @destination_file_path])
       end
 
       def convert_image_to_png
-        Utils.external_command(:convert,[
+        Utils.external_command(:convert, [
           '-auto-orient',
-          '-thumbnail',"#{@options.thumb_img_size}x#{@options.thumb_img_size}>",
-          '-quality',95,
+          '-thumbnail', "#{@options.thumb_img_size}x#{@options.thumb_img_size}>",
+          '-quality', 95,
           '+dither',
-          '-posterize',40,
+          '-posterize', 40,
           "#{@source_file_path}[0]",
           @destination_file_path])
-        Utils.external_command(:optipng,[@destination_file_path])
+        Utils.external_command(:optipng, [@destination_file_path])
       end
 
       # text to png
       def convert_plaintext_to_png
         # get 100 first lines of text file
         first_lines = File.open(@source_file_path){|f|Array.new(100){f.readline rescue ''}.join}
-        Utils.external_command(:convert,[
-          '-size',"#{@options.thumb_img_size}x#{@options.thumb_img_size}",
+        Utils.external_command(:convert, [
+          '-size', "#{@options.thumb_img_size}x#{@options.thumb_img_size}",
           'xc:white', # define canvas with background color (xc, or canvas) of preceding size
-          '-font',@options.thumb_text_font,
-          '-pointsize',12,
-          '-fill','black', # font color
-          '-annotate','+0+0',first_lines,
+          '-font', @options.thumb_text_font,
+          '-pointsize', 12,
+          '-fill', 'black', # font color
+          '-annotate', '+0+0', first_lines,
           '-trim', # avoid large blank regions
-          '-bordercolor','white',
-          '-border',8,
+          '-bordercolor', 'white',
+          '-border', 8,
           '+repage',
           @destination_file_path])
       end

data/lib/aspera/preview/utils.rb

@@ -16,7 +16,7 @@ module Aspera
       # external binaries used
       EXPERNAL_TOOLS = %i[ffmpeg ffprobe convert composite optipng unoconv].freeze
       TMPFMT = 'img%04d.jpg'
-      private_constant :BASH_SPECIAL_CHARACTERS,:BASH_EXIT_NOT_FOUND,:EXPERNAL_TOOLS,:TMPFMT
+      private_constant :BASH_SPECIAL_CHARACTERS, :BASH_EXIT_NOT_FOUND, :EXPERNAL_TOOLS, :TMPFMT
 
       class << self
         # returns string with single quotes suitable for bash if there is any bash metacharacter
@@ -27,22 +27,22 @@ module Aspera
 
         # check that external tools can be executed
         def check_tools(skip_types=[])
-          tools_to_check=EXPERNAL_TOOLS.dup
+          tools_to_check = EXPERNAL_TOOLS.dup
           tools_to_check.delete(:unoconv) if skip_types.include?(:office)
           # Check for binaries
           tools_to_check.each do |command_symb|
-            external_command(command_symb,['-h'])
+            external_command(command_symb, ['-h'])
           end
         end
 
         # execute external command
         # one could use "system", but we would need to redirect stdout/err
         # @return true if su
-        def external_command(command_symb,command_args)
+        def external_command(command_symb, command_args)
           raise "unexpected command #{command_symb}" unless EXPERNAL_TOOLS.include?(command_symb)
           # build command line, and quote special characters
           command = command_args.clone.unshift(command_symb).map{|i| shell_quote(i.to_s)}.join(' ')
-          Log.log.debug("cmd=#{command}".blue)
+          Log.log.debug{"cmd=#{command}".blue}
           # capture3: only in ruby2+
           if Open3.respond_to?(:capture3)
             stdout, stderr, exit_status = Open3.capture3(command)
@@ -55,10 +55,10 @@ module Aspera
             raise "Error: #{command_symb} is not in the PATH"
           end
           unless exit_status.success?
-            Log.log.error("commandline: #{command}")
-            Log.log.error("Error code: #{exit_status}")
-            Log.log.error("stdout: #{stdout}")
-            Log.log.error("stderr: #{stderr}")
+            Log.log.error{"commandline: #{command}"}
+            Log.log.error{"Error code: #{exit_status}"}
+            Log.log.error{"stdout: #{stdout}"}
+            Log.log.error{"stderr: #{stderr}"}
             raise "#{command_symb} error #{exit_status}"
           end
           return {status: exit_status, stdout: stdout}
@@ -66,60 +66,60 @@ module Aspera
 
         def ffmpeg(a)
           raise 'error: hash expected' unless a.is_a?(Hash)
-          #input_file,input_args,output_file,output_args
+          # input_file,input_args,output_file,output_args
           a[:gl_p] ||= [
             '-y', # overwrite output without asking
-            '-loglevel','error' # show only errors and up]
+            '-loglevel', 'error' # show only errors and up]
           ]
           a[:in_p] ||= []
           a[:out_p] ||= []
           raise "wrong params (#{a.keys.sort})" unless %i[gl_p in_f in_p out_f out_p].eql?(a.keys.sort)
-          external_command(:ffmpeg,[a[:gl_p],a[:in_p],'-i',a[:in_f],a[:out_p],a[:out_f]].flatten)
+          external_command(:ffmpeg, [a[:gl_p], a[:in_p], '-i', a[:in_f], a[:out_p], a[:out_f]].flatten)
         end
 
         # @return Float in seconds
         def video_get_duration(input_file)
-          result = external_command(:ffprobe,[
-            '-loglevel','error',
-            '-show_entries','format=duration',
-            '-print_format','default=noprint_wrappers=1:nokey=1',
+          result = external_command(:ffprobe, [
+            '-loglevel', 'error',
+            '-show_entries', 'format=duration',
+            '-print_format', 'default=noprint_wrappers=1:nokey=1',
             input_file])
           return result[:stdout].to_f
         end
 
         def ffmpeg_fmt(temp_folder)
-          return File.join(temp_folder,TMPFMT)
+          return File.join(temp_folder, TMPFMT)
         end
 
         def get_tmp_num_filepath(temp_folder, file_number)
-          return File.join(temp_folder,format(TMPFMT,file_number))
+          return File.join(temp_folder, format(TMPFMT, file_number))
         end
 
         def video_dupe_frame(temp_folder, index, count)
-          input_file = get_tmp_num_filepath(temp_folder,index)
+          input_file = get_tmp_num_filepath(temp_folder, index)
           1.upto(count) do |i|
-            FileUtils.ln_s(input_file,get_tmp_num_filepath(temp_folder,index + i))
+            FileUtils.ln_s(input_file, get_tmp_num_filepath(temp_folder, index + i))
           end
         end
 
         def video_blend_frames(temp_folder, index1, index2)
-          img1 = get_tmp_num_filepath(temp_folder,index1)
-          img2 = get_tmp_num_filepath(temp_folder,index2)
+          img1 = get_tmp_num_filepath(temp_folder, index1)
+          img2 = get_tmp_num_filepath(temp_folder, index2)
           count = index2 - index1 - 1
           1.upto(count) do |i|
-            percent = 100 * i / (count + 1)
+            percent = i * 100 / (count + 1)
             filename = get_tmp_num_filepath(temp_folder, index1 + i)
-            external_command(:composite,['-blend',percent,img2,img1,filename])
+            external_command(:composite, ['-blend', percent, img2, img1, filename])
           end
         end
 
         def video_dump_frame(input_file, offset_seconds, scale, output_file, index=nil)
-          output_file = get_tmp_num_filepath(output_file,index) unless index.nil?
+          output_file = get_tmp_num_filepath(output_file, index) unless index.nil?
           ffmpeg(
             in_f: input_file,
-            in_p: ['-ss',offset_seconds],
+            in_p: ['-ss', offset_seconds],
             out_f: output_file,
-            out_p: ['-frames:v',1,'-filter:v',"scale=#{scale}"])
+            out_p: ['-frames:v', 1, '-filter:v', "scale=#{scale}"])
           return output_file
         end
       end

data/lib/aspera/proxy_auto_config.js

@@ -207,65 +207,65 @@ function timeRange() {
 		var arg = arguments[i];
 		if (gmt) {
 			switch (i) {
-			case 0:
-				date1.setUTCHours(arg);
-				date2.setUTCHours(arg);
-				break;
-			case 1:
-				date1.setUTCMinutes(arg);
-				date2.setUTCMinutes(arg);
-				break;
-			case 2:
-				date1.setUTCSeconds(arg);
-				date2.setUTCSeconds(arg);
-				break;
-			}
-		} else {
-			switch (i) {
-			case 0:
-				date1.setHours(arg);
-				date2.setHours(arg);
-				break;
-			case 1:
-				date1.setMinutes(arg);
-				date2.setMinutes(arg);
-				break;
-			case 2:
-				date1.setSeconds(arg);
-				date2.setSeconds(arg);
-				break;
-			}
-		}
-	}
-	if (num != 1) {
-		date2.setMinutes(0);
-		date2.setSeconds(0);
-		date2.setMilliseconds(0);
-		for (i = 0; i < (num / 2); i++) {
-			var arg = arguments[(num / 2) + i];
-			if (gmt) {
-				switch (i) {
 				case 0:
+					date1.setUTCHours(arg);
 					date2.setUTCHours(arg);
 					break;
 				case 1:
+					date1.setUTCMinutes(arg);
 					date2.setUTCMinutes(arg);
 					break;
 				case 2:
+					date1.setUTCSeconds(arg);
 					date2.setUTCSeconds(arg);
 					break;
-				}
-			} else {
-				switch (i) {
+			}
+		} else {
+			switch (i) {
 				case 0:
+					date1.setHours(arg);
 					date2.setHours(arg);
 					break;
 				case 1:
+					date1.setMinutes(arg);
 					date2.setMinutes(arg);
 					break;
 				case 2:
+					date1.setSeconds(arg);
 					date2.setSeconds(arg);
 					break;
+			}
+		}
+	}
+	if (num != 1) {
+		date2.setMinutes(0);
+		date2.setSeconds(0);
+		date2.setMilliseconds(0);
+		for (i = 0; i < (num / 2); i++) {
+			var arg = arguments[(num / 2) + i];
+			if (gmt) {
+				switch (i) {
+					case 0:
+						date2.setUTCHours(arg);
+						break;
+					case 1:
+						date2.setUTCMinutes(arg);
+						break;
+					case 2:
+						date2.setUTCSeconds(arg);
+						break;
+				}
+			} else {
+				switch (i) {
+					case 0:
+						date2.setHours(arg);
+						break;
+					case 1:
+						date2.setMinutes(arg);
+						break;
+					case 2:
+						date2.setSeconds(arg);
+						break;
 				}
 			}
 		}

data/lib/aspera/proxy_auto_config.rb

@@ -22,9 +22,9 @@ module Aspera
   class ProxyAutoConfig
     # template file is read once, it contains functions that can be used in a proxy autoconf script
     # it is similar to mozilla ascii_pac_utils.inc
-    PAC_FUNCTIONS_FILE = __FILE__.gsub(/\.rb$/,'.js').freeze
+    PAC_FUNCTIONS_FILE = __FILE__.gsub(/\.rb$/, '.js').freeze
     PAC_MAIN_FUNCTION = 'FindProxyForURL'
-    private_constant :PAC_FUNCTIONS_FILE,:PAC_MAIN_FUNCTION
+    private_constant :PAC_FUNCTIONS_FILE, :PAC_MAIN_FUNCTION
 
     private
 
@@ -52,7 +52,7 @@ END_OF_JAVASCRIPT
 
     public
 
-    attr_writer :proxy_user,:proxy_pass
+    attr_writer :proxy_user, :proxy_pass
 
     # @param proxy_auto_config the proxy auto config script to be evaluated
     def initialize(proxy_auto_config)
@@ -60,7 +60,7 @@ END_OF_JAVASCRIPT
       @proxy_auto_config = proxy_auto_config
       # avoid multiple execution, this does not support load balancing
       @cache = {}
-      @proxy_user=@proxy_pass=@pac_functions = nil
+      @proxy_user = @proxy_pass = @pac_functions = nil
     end
 
     def register_uri_generic
@@ -74,8 +74,8 @@ END_OF_JAVASCRIPT
     def find_proxy_for_url(service_url)
       uri = URI.parse(service_url)
       simple_url = "#{uri.scheme}://#{uri.host}"
-      if !@cache.has_key?(simple_url)
-        Log.log.debug("PAC: starting javascript for #{service_url}")
+      if !@cache.key?(simple_url)
+        Log.log.debug{"PAC: starting javascript for #{service_url}"}
         # require at runtime, in case there is no js engine
         require 'execjs'
         # read template lib
@@ -84,7 +84,7 @@ END_OF_JAVASCRIPT
         js_to_execute = "#{pac_dns_functions(uri.host)}#{@pac_functions}#{@proxy_auto_config}"
         executable_js = ExecJS.compile(js_to_execute)
         @cache[simple_url] = executable_js.call(PAC_MAIN_FUNCTION, simple_url, uri.host)
-        Log.log.debug("PAC: result: #{@cache[simple_url]}")
+        Log.log.debug{"PAC: result: #{@cache[simple_url]}"}
       end
       return @cache[simple_url]
     end
@@ -97,11 +97,11 @@ END_OF_JAVASCRIPT
       # execute PAC script
       proxy_list_str = find_proxy_for_url(service_url)
       if !proxy_list_str.is_a?(String)
-        Log.log.warn("PAC: did not return a String, returned #{proxy_list_str.class}")
+        Log.log.warn{"PAC: did not return a String, returned #{proxy_list_str.class}"}
         return uri_list
       end
       proxy_list_str.strip!
-      proxy_list_str.gsub!(/\s+/,' ')
+      proxy_list_str.gsub!(/\s+/, ' ')
       proxy_list_str.split(';').each do |item|
         # strip and split by space
         parts = item.strip.split
@@ -115,21 +115,21 @@ END_OF_JAVASCRIPT
           begin
             # PAC proxy addresses are <host>:<port>
             if /:[0-9]+$/.match?(addr_port)
-              uri=URI.parse("proxy://#{addr_port}")
+              uri = URI.parse("proxy://#{addr_port}")
               # ruby v>2.6 allows
-              uri.user=@proxy_user
-              uri.password=@proxy_pass
+              uri.user = @proxy_user
+              uri.password = @proxy_pass
               uri_list.push(uri)
             else
-              Log.log.warn("PAC: PROXY must be <address>:<port>, ignoring #{addr_port}")
+              Log.log.warn{"PAC: PROXY must be <address>:<port>, ignoring #{addr_port}"}
             end
           rescue StandardError => e
-            Log.log.warn("PAC: cannot parse #{addr_port} #{e}")
+            Log.log.warn{"PAC: cannot parse #{addr_port} #{e}"}
           end
-        else Log.log.warn("PAC: ignoring proxy type #{parts.first}: not supported")
+        else Log.log.warn{"PAC: ignoring proxy type #{parts.first}: not supported"}
         end
       end
-      Log.log.debug("Proxies: #{uri_list}")
+      Log.log.debug{"Proxies: #{uri_list}"}
       return uri_list
     end
   end