aspera-cli 4.26.2 → 4.27.1

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,29 +56,47 @@ 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
 
-        # @return Float in seconds
+        # 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(
             :ffprobe,
@@ -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(/^.*? = (.*);/)
-          raise Cli::Error, 'Problem when getting connect versions from internet' if found.nil?
+          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

@@ -57,15 +57,15 @@ module Aspera
         # Find installed products and provide paths for it.
         # @param scan_locations [Array] Array of Hash with keys: expected, app_root, sub_bin, ascp_path, name, version
         # @return [Array] of products found, with filled missing fields
-        # @raise Exception if no installed product found
+        # @raise [RuntimeError] if no installed product found
         def find(scan_locations)
           product_names = []
           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,17 +17,17 @@ 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
 
-        # @return the path to folder where SDK is or should be installed
+        # @return [String] the path to folder where SDK is or should be installed
         def sdk_directory
           Aspera.assert(!@sdk_dir.nil?, 'SDK path was not initialized')
           @sdk_dir
@@ -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
-      raise "DNS name not found: #{context_host}" if context_ip.nil?
+      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) {
@@ -63,7 +63,7 @@ END_OF_JAVASCRIPT
 
     attr_writer :proxy_user, :proxy_pass
 
-    # @param proxy_auto_config the proxy auto config script to be evaluated
+    # @param proxy_auto_config [String] the proxy auto config script to be evaluated
     def initialize(proxy_auto_config)
       # user provided javascript with FindProxyForURL function
       @proxy_auto_config = proxy_auto_config
@@ -73,18 +73,18 @@ 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
 
     # execute proxy auto config script for the given URL : https://en.wikipedia.org/wiki/Proxy_auto-config
-    # @return either nil, or a String formatted following PAC standard
+    # @return [String, nil] either nil, or a String formatted following PAC standard
     def find_proxy_for_url(service_url)
       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,20 +93,20 @@ 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
 
     # used to replace URI::Generic.find_proxy
-    # @return Array of URI, possibly empty
+    # @return [Array<URI>] list of URIs, possibly empty
     def get_proxies(service_url)
       # prepare result
       uri_list = []
       # 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!
@@ -114,7 +114,8 @@ END_OF_JAVASCRIPT
       proxy_list_str.split(';').each do |item|
         # strip and split by space
         parts = item.strip.split
-        case parts.shift
+        proxy_type = parts.shift
+        case proxy_type
         when 'DIRECT'
           Aspera.assert(parts.empty?, 'DIRECT has no param')
           Log.log.debug('ignoring proxy DIRECT')
@@ -131,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 #{parts.first}: 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