aspera-cli 4.27.0 → 4.27.1

data/lib/aspera/preview/generator.rb

@@ -57,21 +57,21 @@ module Aspera
           end
         end
         @processing_method = @processing_method.to_sym
-        Log.log.debug{"method: #{@processing_method}"}
-        Aspera.assert(respond_to?(@processing_method, true)){"no processing known for #{conversion_type} -> #{@preview_format_sym}"}
+        Log.log.debug { "method: #{@processing_method}" }
+        Aspera.assert(respond_to?(@processing_method, true)) { "no processing known for #{conversion_type} -> #{@preview_format_sym}" }
         command = [:magick] + %w[identify -list font]
         magick_fonts = Utils.parse_magick_fonts(Utils.execute(*command, mode: :capture).first)
-        Aspera.assert(magick_fonts[:fonts].any?{ |f| f[:name].eql?(@options.thumb_text_font)}){"Missing font #{@options.thumb_text_font} in #{command}"}
+        Aspera.assert(magick_fonts[:fonts].any? { |f| f[:name].eql?(@options.thumb_text_font) }) { "Missing font #{@options.thumb_text_font} in #{command}" }
       end
 
       # Creates preview as specified in constructor.
       def generate
-        Log.log.debug{"#{@source}->#{@destination} (#{@processing_method})"}
+        Log.log.debug { "#{@source}->#{@destination} (#{@processing_method})" }
         begin
           send(@processing_method)
           # Check that generated size does not exceed maximum.
           result_size = File.size(@destination)
-          Log.log.warn{"preview size exceeds maximum allowed #{result_size} > #{@options.max_size}"} if result_size > @options.max_size
+          Log.log.warn { "preview size exceeds maximum allowed #{result_size} > #{@options.max_size}" } if result_size > @options.max_size
         ensure
           FileUtils.rm_rf(@temp_folder)
         end
@@ -99,7 +99,7 @@ module Aspera
       # @param index [Integer] Index of part (starts at 1).
       # @return [Float] Offset in seconds suitable for ffmpeg -ss option.
       def get_offset(duration, start_offset, total_count, index)
-        Aspera.assert_type(duration, Float){'duration'}
+        Aspera.assert_type(duration, Float) { 'duration' }
         return start_offset + ((index - 1) * (duration - start_offset) / total_count)
       end
 
@@ -127,10 +127,12 @@ module Aspera
           current_index = last_keyframe + 1 + @options.blend_transframes
         end
         Utils.ffmpeg(
-          in_f: Utils.ffmpeg_fmt(this_tmpdir),
-          in_p: ['-framerate', @options.blend_fps],
-          out_f: @destination,
-          out_p: [
+          in:  [
+            Utils.ffmpeg_fmt(this_tmpdir),
+            '-framerate', @options.blend_fps
+          ],
+          out: [
+            @destination,
             '-filter:v', "scale='trunc(iw/2)*2:trunc(ih/2)*2'",
             '-codec:v', 'libx264',
             '-r', frame_rate_hz,
@@ -149,13 +151,15 @@ module Aspera
             offset_seconds = get_offset(p_duration, @options.video_start_sec.to_i, @options.clips_count.to_i, i)
             tmp_file_name = format('clip%04d.mp4', i)
             Utils.ffmpeg(
-              in_f: @source,
-              in_p: ['-ss', offset_seconds * 0.9],
-              out_f: File.join(this_tmpdir, tmp_file_name),
-              out_p: [
+              in:  [
+                @source,
+                '-ss', offset_seconds * 0.9
+              ],
+              out: [
+                File.join(this_tmpdir, tmp_file_name),
                 '-ss', offset_seconds * 0.1,
                 '-t', @options.clips_length,
-                '-filter:v', "scale=#{@options.video_scale}",
+                '-filter:v', "scale='#{@options.video_scale}'",
                 '-codec:a', 'libmp3lame'
               ]
             )
@@ -164,10 +168,8 @@ module Aspera
         end
         # Concat clips.
         Utils.ffmpeg(
-          in_f: file_list_file,
-          in_p: ['-f', 'concat'],
-          out_f: @destination,
-          out_p: ['-codec', 'copy']
+          in:  [file_list_file, '-f', 'concat'],
+          out: [@destination, '-codec', 'copy']
         )
         File.delete(file_list_file)
       end
@@ -176,31 +178,32 @@ module Aspera
       # Performs a simple re-encoding with configurable ffmpeg options.
       def convert_video_to_mp4_using_reencode
         options = @options.reencode_ffmpeg
-        Aspera.assert_type(options, Hash){'reencode_ffmpeg'}
+        Aspera.assert_type(options, Hash) { 'reencode_ffmpeg' }
         options.each do |k, v|
-          Aspera.assert_values(k, FFMPEG_OPTIONS_LIST){'key'}
-          Aspera.assert_type(v, Array){k}
+          Aspera.assert_values(k, FFMPEG_OPTIONS_LIST) { 'key' }
+          Aspera.assert_type(v, Array) { k }
         end
+        codec = @options.video_codec || Utils.available_h264_encoder
+        in_opts = options['in'] || ['-ss', @options.video_start_sec.to_i * 0.9]
+        out_opts = options['out'] || [
+          '-t', 60,
+          '-codec:v', codec,
+          '-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'
+        ]
         Utils.ffmpeg(
-          in_f: @source,
-          in_p: options['in'] || ['-ss', @options.video_start_sec.to_i * 0.9],
-          out_f: @destination,
-          out_p: options['out'] || [
-            '-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'
-          ]
+          in:  [@source, *in_opts],
+          out: [@destination, *out_opts]
         )
       end
 
@@ -228,13 +231,13 @@ module Aspera
           p_max_duration = p_duration
         end
         Utils.ffmpeg(
-          in_f: @source,
-          in_p: [
+          in:  [
+            @source,
             '-ss', p_start_offset,
             '-t', p_max_duration
           ],
-          out_f: @destination,
-          out_p: [
+          out: [
+            @destination,
             '-vf', 'fps=5,scale=120:-1:flags=lanczos',
             '-plays', 0, # Loop forever (0 = infinite loop for APNG).
             '-f', 'apng'
@@ -265,7 +268,7 @@ module Aspera
           # soffice creates the file with the source name, so we need to rename it if needed.
           generated_pdf = File.join(File.dirname(tmp_pdf_file), "#{File.basename(@source, File.extname(@source))}.pdf")
           FileUtils.mv(generated_pdf, tmp_pdf_file) if generated_pdf != tmp_pdf_file
-        else Aspera.error_unexpected_value(@options.office_conversion){'office_conversion'}
+        else Aspera.error_unexpected_value(@options.office_conversion) { 'office_conversion' }
         end
         convert_pdf_to_png(tmp_pdf_file)
       end

data/lib/aspera/preview/options.rb

@@ -18,15 +18,16 @@ module Aspera
       # -x : keep aspect ratio, having value a multiple of x
       DESCRIPTIONS = [
         {name: :max_size,             default: 1 << 24,            description: 'maximum size (in bytes) of preview file'},
-        {name: :thumb_vid_scale,      default: "-1:'min(ih,100)'", description: 'png: video: size (ffmpeg scale argument)'},
+        {name: :thumb_vid_scale,      default: '-1:min(ih,100)',   description: 'png: video: size (ffmpeg scale argument)'},
         {name: :thumb_vid_fraction,   default: 0.1,                description: 'png: video: time percent position of snapshot'},
         {name: :thumb_img_size,       default: 800,                description: 'png: non-video: height (and width)'},
         {name: :thumb_text_font,      default: 'Courier',          description: 'png: plaintext: font for text rendering: `magick identify -list font`'},
         {name: :office_conversion,    default: :soffice,           description: 'office: method for office document conversion', values: OFFICE_CONVERSION_METHODS},
         {name: :video_conversion,     default: :reencode,          description: 'mp4: method for preview generation', values: VIDEO_CONVERSION_METHODS},
         {name: :video_png_conv,       default: :fixed,             description: 'mp4: method for thumbnail generation', values: VIDEO_THUMBNAIL_METHODS},
-        {name: :video_scale,          default: "'min(iw,360)':-2", description: 'mp4: all: video scale (ffmpeg scale argument)'},
+        {name: :video_scale,          default: 'min(iw,360):-2',   description: 'mp4: all: video scale (ffmpeg scale argument)'},
         {name: :video_start_sec,      default: 10,                 description: 'mp4: all: start offset (seconds) of video preview'},
+        {name: :video_codec,          default: nil,                description: 'mp4: reencode: video codec for ffmpeg (e.g. libx264, h264_videotoolbox, h264_nvenc), default: auto-detect'},
         {name: :reencode_ffmpeg,      default: {},                 description: 'mp4: reencode: options to ffmpeg, keys: `in`, `out`'},
         {name: :blend_keyframes,      default: 30,                 description: 'mp4: blend: # key frames'},
         {name: :blend_pauseframes,    default: 3,                  description: 'mp4: blend: # pause frames'},

data/lib/aspera/preview/terminal.rb

@@ -58,7 +58,7 @@ module Aspera
           pixel_colors = []
           @image.scale(*terminal_scaling(@image.rows, @image.columns)).each_pixel do |pixel, col, row|
             pixel_rgb = [pixel.red, pixel.green, pixel.blue]
-            pixel_rgb = pixel_rgb.map{ |color| color >> shift_for_8_bit} unless shift_for_8_bit.eql?(0)
+            pixel_rgb = pixel_rgb.map { |color| color >> shift_for_8_bit } unless shift_for_8_bit.eql?(0)
             # Initialize the destination 2D pixel matrix row by row.
             pixel_colors[row] ||= []
             pixel_colors[row][col] = pixel_rgb
@@ -87,7 +87,7 @@ module Aspera
           dst_w, dst_h = terminal_scaling(src_h, src_w)
           dst_w = [dst_w, 1].max
           dst_h = [dst_h, 1].max
-          pixel_colors = Array.new(dst_h){Array.new(dst_w)}
+          pixel_colors = Array.new(dst_h) { Array.new(dst_w) }
           x_ratio = src_w.to_f / dst_w
           y_ratio = src_h.to_f / dst_h
           dst_h.times do |dy|
@@ -98,7 +98,7 @@ module Aspera
               sx = src_w - 1 if sx >= src_w
               rgba = @png.get_pixel(sx, sy)
               # ChunkyPNG stores pixels as 0xRRGGBBAA; extract 8-bit RGB channels.
-              pixel_colors[dy][dx] = %i[r g b].map{ |i| ::ChunkyPNG::Color.send(i, rgba)}
+              pixel_colors[dy][dx] = %i[r g b].map { |i| ::ChunkyPNG::Color.send(i, rgba) }
             end
           end
           pixel_colors
@@ -178,7 +178,7 @@ module Aspera
             size:                blob.length
             # width:               image.columns,
             # height:              image.rows
-          }.map{ |k, v| "#{k}=#{v}"}.join(';')
+          }.map { |k, v| "#{k}=#{v}" }.join(';')
           # `\a` is BEL and `\e` is ESC.
           # See: https://github.com/ruby/ruby/blob/master/doc/syntax/literals.rdoc#label-Strings
           # Return the full escape sequence expected by iTerm2-compatible terminals.
@@ -190,7 +190,7 @@ module Aspera
         # @return [Boolean] `true` when the current terminal advertises iTerm2 image support
         def iterm_supported?
           TERM_ENV_VARS.each do |env_var|
-            return true if ITERM_NAMES.any?{ |term| ENV[env_var]&.include?(term)}
+            return true if ITERM_NAMES.any? { |term| ENV[env_var]&.include?(term) }
           end
           false
         end

data/lib/aspera/preview/utils.rb

@@ -20,11 +20,25 @@ module Aspera
         '-y', # overwrite output without asking
         '-loglevel', 'error' # show only errors and up
       ].freeze
-      private_constant :EXTERNAL_TOOLS, :TEMP_FORMAT, :FFMPEG_DEFAULT_PARAMS
+      # Preferred H.264 encoders in order: best quality/compatibility first.
+      H264_ENCODER_PREFERENCE = %w[libx264 libopenh264 h264_nvenc h264_amf h264_qsv h264_vaapi h264_v4l2m2m].freeze
+      private_constant :EXTERNAL_TOOLS, :TEMP_FORMAT, :FFMPEG_DEFAULT_PARAMS, :H264_ENCODER_PREFERENCE
 
       class << self
-        # Check that external tools can be executed
+        # Return the first H.264 encoder available in the local ffmpeg installation.
+        # Result is memoized after the first call.
+        # @return [String] encoder name (e.g. 'libx264', 'libopenh264')
+        # @raise [RuntimeError] if no supported H.264 encoder is found
+        def available_h264_encoder
+          return @available_h264_encoder if defined?(@available_h264_encoder)
+          stdout, = execute(:ffmpeg, '-encoders', mode: :capture, exception: false)
+          @available_h264_encoder = H264_ENCODER_PREFERENCE.find { |enc| stdout.include?(enc) } ||
+            raise("No supported H.264 encoder found in ffmpeg. Available: #{stdout.lines.grep(/h264/i).map(&:strip).join(', ')}")
+        end
+
+        # Check that external tools can be executed.
         # @param skip_types [Array<Symbol>] list of tools to skip
+        # @raise [RuntimeError] if a required tool binary is missing
         # @return [nil]
         def check_tools(skip_types = [])
           tools_to_check = EXTERNAL_TOOLS.dup
@@ -42,28 +56,46 @@ module Aspera
           end
         end
 
-        # Execute external command, verify it is in the supported list
+        # Execute external command, verify it is in the supported list.
+        # @param args [Array] command name followed by CLI arguments
+        # @param kwargs [Hash] execution options passed to {Environment.secure_execute}
+        # @raise [Aspera::AssertError] if the command is not in {EXTERNAL_TOOLS}
+        # @return [Array<String>] captured stdout and stderr lines depending on mode
         def execute(*args, **kwargs)
-          Aspera.assert_values(args.first, EXTERNAL_TOOLS){'command'}
+          Aspera.assert_values(args.first, EXTERNAL_TOOLS) { 'command' }
           Environment.secure_execute(*args, **kwargs)
         end
 
-        # Execute external command silently
+        # Execute external command, capturing and discarding output unless it fails.
+        # On failure, the captured stderr is included in the raised exception message.
+        # @param args [Array] command name followed by CLI arguments
         # @return [nil]
         def silent_execute(*args)
-          execute(*args, out: File::NULL, err: File::NULL)
+          execute(*args, mode: :capture)
           nil
         end
 
-        # Execute `ffmpeg`
+        # Execute `ffmpeg`, capturing output.
+        # On failure, the ffmpeg stderr is logged at debug level and re-raised.
+        # @param in [Array] input file path followed by input options
+        # @param out [Array] output file path followed by output options
+        # @param global [Array<String>] global options for ffmpeg
         # @return [nil]
-        def ffmpeg(gl_p: FFMPEG_DEFAULT_PARAMS, in_p: [], in_f:, out_p: [], out_f:)
-          Aspera.assert_type(gl_p, Array)
-          Aspera.assert_type(in_p, Array)
-          Aspera.assert_type(out_p, Array)
-          silent_execute(:ffmpeg, *gl_p, *in_p, '-i', in_f, *out_p, out_f)
+        def ffmpeg(in:, out:, global: FFMPEG_DEFAULT_PARAMS)
+          Aspera.assert_type(global, Array)
+          # NOTE: cannot use just "in", as it is a reserved word in ruby
+          in_args = binding.local_variable_get(:in).dup
+          out_args = out.dup
+          Aspera.assert_type(in_args, Array)
+          Aspera.assert_type(out_args, Array)
+          in_file = in_args.shift
+          out_file = out_args.shift
+          execute(:ffmpeg, *global, *in_args, '-i', in_file, *out_args, out_file, mode: :capture)
+          nil
         end
 
+        # Get duration of a video file using `ffprobe`.
+        # @param input_file [String] path to video file
         # @return [Float] duration in seconds
         def video_get_duration(input_file)
           return execute(
@@ -76,23 +108,39 @@ module Aspera
           ).first.to_f
         end
 
-        # File output format, including temp folder
+        # File output pattern for ffmpeg, including temp folder.
+        # @param temp_folder [String] path to temp folder
+        # @return [String] file path pattern
         def ffmpeg_fmt(temp_folder)
           return File.join(temp_folder, TEMP_FORMAT)
         end
 
+        # Get numbered temporary file path.
+        # @param temp_folder [String] path to temp folder
+        # @param file_number [Integer] frame index
+        # @return [String] file path
         def get_tmp_num_filepath(temp_folder, file_number)
-          # Format using {Kernel.format}
           return File.join(temp_folder, format(TEMP_FORMAT, file_number))
         end
 
+        # Duplicate a video frame by creating symlinks.
+        # @param temp_folder [String] path to temp folder
+        # @param index [Integer] frame index to duplicate
+        # @param count [Integer] number of duplicate frames to create
+        # @return [nil]
         def video_dupe_frame(temp_folder, index, count)
           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))
           end
+          nil
         end
 
+        # Blend transition frames between two keyframes using ImageMagick.
+        # @param temp_folder [String] path to temp folder
+        # @param index_begin [Integer] starting frame index
+        # @param index_end [Integer] ending frame index
+        # @return [nil]
         def video_blend_frames(temp_folder, index_begin, index_end)
           img1 = get_tmp_num_filepath(temp_folder, index_begin)
           img2 = get_tmp_num_filepath(temp_folder, index_end)
@@ -102,6 +150,7 @@ module Aspera
             filename = get_tmp_num_filepath(temp_folder, index_begin + i)
             silent_execute(:magick, 'composite', '-blend', percent, img2, img1, filename)
           end
+          nil
         end
 
         # Dump a frame from a video file
@@ -112,10 +161,8 @@ module Aspera
         # @return [nil]
         def video_dump_frame(input_file, offset_seconds, scale, output_file)
           ffmpeg(
-            in_f: input_file,
-            in_p: ['-ss', offset_seconds],
-            out_f: output_file,
-            out_p: ['-frames:v', 1, '-filter:v', "scale=#{scale}"]
+            in:  [input_file, '-ss', offset_seconds],
+            out: [output_file, '-frames:v', 1, '-filter:v', "scale='#{scale}'"]
           )
         end
 

data/lib/aspera/products/connect.rb

@@ -47,7 +47,7 @@ module Aspera
             app_root: File.join(Dir.home, '.aspera', 'connect'),
             run_root: File.join(Dir.home, '.aspera', 'connect')
           }]
-          end.map{ |i| i.merge({expected: APP_NAME})}
+          end.map { |i| i.merge({expected: APP_NAME}) }
         end
       end
 
@@ -65,7 +65,7 @@ module Aspera
           Log.dump(:javascript, connect_versions_javascript)
           # get javascript object only
           found = connect_versions_javascript.match(/^.*? = (.*);/)
-          Aspera.assert(!found.nil?, type: Cli::Error){'Problem when getting connect versions from internet'}
+          Aspera.assert(!found.nil?, type: Cli::Error) { 'Problem when getting connect versions from internet' }
           all_data = JSON.parse(found[1])
           @connect_versions = all_data['entries']
         end

data/lib/aspera/products/desktop.rb

@@ -19,7 +19,7 @@ module Aspera
             sub_bin:  File.join('Contents', 'Resources', 'transferd', 'bin')
           }]
           else []
-          end.map{ |i| i.merge({expected: APP_NAME})}
+          end.map { |i| i.merge({expected: APP_NAME}) }
         end
       end
     end

data/lib/aspera/products/other.rb

@@ -63,9 +63,9 @@ module Aspera
           found = scan_locations.select do |item|
             product_names.push(item[:expected]) unless product_names.include?(item[:expected])
             # skip if not main folder
-            Log.log.trace1{"Checking #{item[:app_root]}"}
+            Log.log.trace1 { "Checking #{item[:app_root]}" }
             next false unless Dir.exist?(item[:app_root])
-            Log.log.debug{"Found #{item[:expected]}"}
+            Log.log.debug { "Found #{item[:expected]}" }
             sub_bin = item[:sub_bin] || 'bin'
             item[:ascp_path] = File.join(item[:app_root], sub_bin, Environment.instance.exe_file('ascp'))
             # skip if no ascp

data/lib/aspera/products/transferd.rb

@@ -17,12 +17,12 @@ module Aspera
           [{
             app_root: sdk_directory,
             sub_bin:  ''
-          }].map{ |i| i.merge({expected: APP_NAME})}
+          }].map { |i| i.merge({expected: APP_NAME}) }
         end
 
         # location of SDK files
         def sdk_directory=(folder)
-          Log.log.debug{"sdk_directory=#{folder}"}
+          Log.log.debug { "sdk_directory=#{folder}" }
           @sdk_dir = folder
           sdk_directory
         end
@@ -53,7 +53,7 @@ module Aspera
             end
           end
           Aspera.assert(!result.nil?, 'Port not found in daemon logs')
-          Log.log.debug{"Got port #{result} from log"}
+          Log.log.debug { "Got port #{result} from log" }
           return result
         end
       end

data/lib/aspera/proxy_auto_config.rb

@@ -16,7 +16,7 @@ module URI
       def register_proxy_finder
         Aspera.assert(block_given?, 'block required for register_proxy_finder')
         # overload the method in URI : call user's provided block and fallback to original method
-        define_method(:find_proxy){ |env_vars = ENV| yield(to_s) || find_proxy_orig(env_vars)}
+        define_method(:find_proxy) { |env_vars = ENV| yield(to_s) || find_proxy_orig(env_vars) }
       end
     end
   end
@@ -44,7 +44,7 @@ module Aspera
           context_ip = r_addr.to_s if r_addr.is_a?(Resolv::IPv4)
         end
       end
-      Aspera.assert(!context_ip.nil?){"DNS name not found: #{context_host}"}
+      Aspera.assert(!context_ip.nil?) { "DNS name not found: #{context_host}" }
       # NOTE: Javascript code here with string inclusions
       javascript = <<END_OF_JAVASCRIPT
       function dnsResolve(host) {
@@ -73,7 +73,7 @@ END_OF_JAVASCRIPT
     end
 
     def register_uri_generic
-      URI::Generic.register_proxy_finder{ |url_str| get_proxies(url_str).first}
+      URI::Generic.register_proxy_finder { |url_str| get_proxies(url_str).first }
       # allow chaining
       return self
     end
@@ -84,7 +84,7 @@ END_OF_JAVASCRIPT
       uri = URI.parse(service_url)
       simple_url = "#{uri.scheme}://#{uri.host}"
       if !@cache.key?(simple_url)
-        Log.log.debug{"PAC: starting javascript for #{service_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
@@ -93,7 +93,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
@@ -106,7 +106,7 @@ 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!
@@ -132,15 +132,15 @@ END_OF_JAVASCRIPT
               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 #{proxy_type}: not supported"}
+        else Log.log.warn { "PAC: ignoring proxy type #{proxy_type}: not supported" }
         end
       end
-      Log.log.debug{"Proxies: #{uri_list}"}
+      Log.log.debug { "Proxies: #{uri_list}" }
       return uri_list
     end
   end