aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/oauth/base.rb

@@ -48,10 +48,10 @@ module Aspera
       attr_reader :path_token
 
       # Helper method to create token as per RFC
-      # @return [HTTPResponse]
-      # @raise RestError if not 2XX code
+      # @return [Net::HTTPResponse] raw HTTP response with token
+      # @raise [RestCallError] if not 2XX code
       def create_token_call(creation_params)
-        Log.log.debug{'Generating a new token'.bg_green}
+        Log.log.debug { 'Generating a new token'.bg_green }
         return @api.create(@path_token, nil, query: creation_params, ret: :resp) if @use_query
         return @api.create(@path_token, creation_params, content_type: Mime::WWW, ret: :resp)
       end
@@ -73,8 +73,8 @@ module Aspera
       # get an OAuth v2 token (generated, cached, refreshed)
       # call token() to get a token.
       # if a token is expired (api returns 4xx), call again token(refresh: true)
-      # @param cache set to false to disable cache
-      # @param refresh set to true to force refresh or re-generation (if previous failed)
+      # @param cache   [Boolean] set to false to disable cache
+      # @param refresh [Boolean] set to true to force refresh or re-generation (if previous failed)
       def token(cache: true, refresh: false)
         # get token info from cache (or nil), decoded with date and expiration status
         token_info = Factory.instance.get_token_info(@token_cache_id) if cache
@@ -87,7 +87,7 @@ module Aspera
           # `direct` agent is equipped with refresh code
           # an API was already called, but failed, we need to regenerate or refresh
           if refresh || token_info[:expired]
-            Log.log.trace1{"refresh: #{refresh} expired: #{token_info[:expired]}"}
+            Log.log.trace1 { "refresh: #{refresh} expired: #{token_info[:expired]}" }
             refresh_token = nil
             if token_data.key?('refresh_token') && !token_data['refresh_token'].eql?('not_supported')
               # save possible refresh token, before deleting the cache
@@ -99,16 +99,15 @@ module Aspera
             # lets try the existing refresh token
             # NOTE: AoC admin token has no refresh, and lives by default 1800secs
             if !refresh_token.nil?
-              Log.log.debug{"refresh token=[#{refresh_token}]"}
               begin
                 http = create_token_call(base_params(add_secret: true).merge(grant_type: 'refresh_token', refresh_token: refresh_token))
                 # Save only if success
                 json_data = http.body
                 token_data = JSON.parse(json_data)
                 Factory.instance.persist_mgr.put(@token_cache_id, json_data)
-              rescue => e
+              rescue StandardError => e
                 # Refresh token can fail.
-                Log.log.warn{"Refresh failed: #{e}"}
+                Log.log.warn { "Refresh failed: #{e}" }
               end
             end
           end
@@ -122,7 +121,7 @@ module Aspera
           token_data = JSON.parse(json_data)
           Factory.instance.persist_mgr.put(@token_cache_id, json_data)
         end
-        Aspera.assert(token_data.key?(@token_field)){"API error: No such field in answer: #{@token_field}"} unless token_data.nil?
+        Aspera.assert(token_data.key?(@token_field)) { "API error: No such field in answer: #{@token_field}" } unless token_data.nil?
         # ok we shall have a token here
         return token_data[@token_field]
       end

data/lib/aspera/oauth/boot.rb

@@ -8,24 +8,24 @@ module Aspera
   module OAuth
     # Token provider bootstrapped from an existing cookie (e.g. AoC browser cookie).
     # Injects the bearer token and optional refresh token directly into the cache.
-    # Never generates a new token from scratch — raises if cache+refresh are both exhausted.
+    # Never generates a new token from scratch - raises if cache+refresh are both exhausted.
     class Boot < Base
       # @param cookie   [String, nil] Raw cookie string (--password), nil to rely on existing cache
       # @param username [String, nil] Expected subject; if provided, must match token's `sub` claim
-      # @param **base_params          Forwarded to Base (base_url:, params: {client_id:, scope:}, etc.)
+      # @param **base_params [Hash] Forwarded to Base (base_url:, params: {client_id:, scope:}, etc.)
       def initialize(cookie: nil, username: nil, **base_params)
         if cookie.nil?
           # No cookie: rely on existing cache, identified by username if provided
           Aspera.assert(username, 'Provide --password (cookie) on first use, or --username for cache lookup', type: ParameterError)
           super(**base_params, cache_ids: [username])
         else
-          cookies = cookie.split('; ').map{ |p| p.split('=', 2)}.to_h
+          cookies = cookie.split('; ').map { |p| p.split('=', 2) }.to_h
           Aspera.assert(cookies.key?('aoc.token'), '--password cookie does not contain aoc.token', type: ParameterError)
           token = cookies['aoc.token']
           decoded = Factory.instance.decode_token(token)
-          Aspera.assert_type(decoded, Hash){'Boot: token is not a decodable JWT'}
+          Aspera.assert_type(decoded, Hash) { 'Boot: token is not a decodable JWT' }
           sub = decoded['sub']
-          Aspera.assert(username.nil? || username.eql?(sub)){"Boot: --username #{username} does not match token subject #{sub}"}
+          Aspera.assert(username.nil? || username.eql?(sub)) { "Boot: --username #{username} does not match token subject #{sub}" }
           super(**base_params, cache_ids: [sub])
           token_data = {Factory::TOKEN_FIELD => token}
           token_data['refresh_token'] = cookies['aoc.refresh'] if cookies.key?('aoc.refresh')

data/lib/aspera/oauth/factory.rb

@@ -41,7 +41,7 @@ module Aspera
         # @param authorization [String] The authorization header value
         # @return [String] The bearer token without the scheme prefix
         def bearer_token(authorization)
-          Aspera.assert(bearer_auth?(authorization)){'not a bearer token, wrong prefix scheme'}
+          Aspera.assert(bearer_auth?(authorization)) { 'not a bearer token, wrong prefix scheme' }
           return authorization.delete_prefix(SPACE_BEARER_AUTH_SCHEME)
         end
 
@@ -108,7 +108,7 @@ module Aspera
       end
 
       # Delete all existing tokens in cache
-      # @return [void]
+      # @return [Array<String>] List of deleted file paths
       def flush_tokens
         persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN)
       end
@@ -119,7 +119,7 @@ module Aspera
         data = persist_mgr.current_items(PERSIST_CATEGORY_TOKEN)
         data.each.map do |k, v|
           info = {id: k}
-          info.merge!(JSON.parse(v)) rescue nil
+          begin; info.merge!(JSON.parse(v)); rescue StandardError; nil; end
           d = decode_token(info.delete(TOKEN_FIELD))
           info.merge(d) if d
           info
@@ -155,9 +155,10 @@ module Aspera
 
       # Register a bearer token decoder for inspecting token properties
       # @param method [Proc] The decoder lambda/proc to register
-      # @return [void]
+      # @return [nil]
       def register_decoder(method)
         @decoders.push(method)
+        nil
       end
 
       # Decode a token using all registered decoders
@@ -165,7 +166,7 @@ module Aspera
       # @return [Hash, nil] Decoded token data or nil if no decoder succeeded
       def decode_token(token)
         @decoders.each do |decoder|
-          result = decoder.call(token) rescue nil
+          result = begin; decoder.call(token); rescue StandardError; nil; end
           return result unless result.nil?
         end
         return
@@ -173,12 +174,13 @@ module Aspera
 
       # Register a token creation method
       # @param creator_class [Class] The token creator class to register
-      # @return [void]
+      # @return [nil]
       def register_token_creator(creator_class)
         Aspera.assert_type(creator_class, Class)
         id = Factory.class_to_id(creator_class)
-        Log.log.debug{"registering creator for #{id}"}
+        Log.log.debug { "registering creator for #{id}" }
         @token_type_classes[id] = creator_class
+        nil
       end
 
       # Create a token creator instance for the specified grant method
@@ -187,12 +189,12 @@ module Aspera
       def create(**parameters)
         Aspera.assert_type(parameters, Hash)
         id = parameters[:grant_method]
-        Aspera.assert(@token_type_classes.key?(id)){"token grant method unknown: '#{id}'"}
-        create_parameters = parameters.reject{ |k, _v| k.eql?(:grant_method)}
+        Aspera.assert(@token_type_classes.key?(id)) { "token grant method unknown: '#{id}'" }
+        create_parameters = parameters.reject { |k, _v| k.eql?(:grant_method) }
         @token_type_classes[id].new(**create_parameters)
       end
     end
     # JSON Web Signature (JWS) compact serialization: https://datatracker.ietf.org/doc/html/rfc7515
-    Factory.instance.register_decoder(lambda{ |token| parts = token.split('.'); Aspera.assert_values(parts.length, [3]){'JWS token parts'}; JSON.parse(Base64.decode64(parts[1]))}) # rubocop:disable Style/Semicolon
+    Factory.instance.register_decoder(lambda { |token| parts = token.split('.'); Aspera.assert_values(parts.length, [3]) { 'JWS token parts' }; JSON.parse(Base64.decode64(parts[1])) }) # rubocop:disable Style/Semicolon
   end
 end

data/lib/aspera/oauth/jwt.rb

@@ -26,9 +26,9 @@ module Aspera
       end
       DEFAULT_PRIV_KEY_LENGTH = 4096
       GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
-      # @param private_key_obj private key object
-      # @param payload payload to be included in the JWT
-      # @param headers headers to be included in the JWT
+      # @param private_key_obj [OpenSSL::PKey::RSA] private key object
+      # @param payload         [Hash] payload to be included in the JWT
+      # @param headers         [Hash] headers to be included in the JWT
       def initialize(
         private_key_obj:,
         payload:,
@@ -36,10 +36,10 @@ module Aspera
         cache_ids: [],
         **base_params
       )
-        Aspera.assert_type(private_key_obj, OpenSSL::PKey::RSA){'private_key_obj'}
-        Aspera.assert_type(payload, Hash){'payload'}
-        Aspera.assert_type(headers, Hash){'headers'}
-        Aspera.assert_type(cache_ids, Array){'cache ids'}
+        Aspera.assert_type(private_key_obj, OpenSSL::PKey::RSA) { 'private_key_obj' }
+        Aspera.assert_type(payload, Hash) { 'payload' }
+        Aspera.assert_type(headers, Hash) { 'headers' }
+        Aspera.assert_type(cache_ids, Array) { 'cache ids' }
         new_cache_ids = cache_ids.clone.push(payload[:sub])
         super(**base_params, cache_ids: new_cache_ids)
         @private_key_obj = private_key_obj
@@ -49,8 +49,8 @@ module Aspera
 
       def create_token
         require 'jwt'
-        seconds_since_epoch = Time.new.to_i
-        Log.log.debug{"seconds_since_epoch=#{seconds_since_epoch}"}
+        seconds_since_epoch = Time.now.to_i
+        Log.log.debug { "seconds_since_epoch=#{seconds_since_epoch}" }
         jwt_payload = {
           exp: seconds_since_epoch + OAuth::Factory.instance.parameters[:jwt_expiry_offset_sec], # expiration time
           nbf: seconds_since_epoch - OAuth::Factory.instance.parameters[:jwt_accepted_offset_sec], # not before
@@ -58,9 +58,7 @@ module Aspera
           jti: SecureRandom.uuid # JWT id
         }.merge(@additional_payload)
         Log.dump(:jwt_payload, jwt_payload)
-        Log.log.debug{"private=[#{@private_key_obj}]"}
         assertion = JWT.encode(jwt_payload, @private_key_obj, 'RS256', @headers)
-        Log.log.debug{"assertion=[#{assertion}]"}
         return create_token_call(base_params.merge(grant_type: GRANT_TYPE, assertion: assertion))
       end
     end

data/lib/aspera/oauth/web.rb

@@ -11,8 +11,8 @@ module Aspera
       class << self
         attr_accessor :additional_info
       end
-      # @param redirect_uri    url to receive the code after auth (to be exchanged for token)
-      # @param path_authorize  path to login page on web app
+      # @param redirect_uri   [String] url to receive the code after auth (to be exchanged for token)
+      # @param path_authorize [String] path to login page on web app
       def initialize(
         redirect_uri:,
         path_authorize: 'authorize',
@@ -22,9 +22,9 @@ module Aspera
         @redirect_uri = redirect_uri
         @path_authorize = path_authorize
         uri = URI.parse(@redirect_uri)
-        Aspera.assert_values(uri.scheme, %w[http https]){'redirect_uri scheme must be http or https'}
+        Aspera.assert_values(uri.scheme, %w[http https]) { 'redirect_uri scheme must be http or https' }
         Aspera.assert(!uri.port.nil?, 'redirect_uri must have a port')
-        # TODO: we could check that host is localhost or local address, as we are going to listen locally
+        Aspera.assert(%w[127.0.0.1 ::1 localhost].include?(uri.host)) { 'redirect_uri host must be localhost or loopback address' }
       end
 
       def create_token
@@ -35,14 +35,14 @@ module Aspera
           base_params.merge(response_type: 'code', redirect_uri: @redirect_uri, state: random_state)
         )
         # here, we need a human to authorize on a web page
-        Log.log.debug{"login_page_url=#{login_page_url}"}
+        Log.log.debug { "login_page_url=#{login_page_url}" }
         # start a web server to receive request code
         web_server = WebAuth.new(@redirect_uri, self.class.additional_info)
         # start browser on login page
         Environment.instance.open_uri(login_page_url)
         # wait for code in request
         received_params = web_server.received_request
-        Aspera.assert(random_state.eql?(received_params['state'])){'wrong received state'}
+        Aspera.assert(random_state.eql?(received_params['state'])) { 'wrong received state' }
         # exchange code for token
         return create_token_call(base_params(add_secret: true).merge(
           grant_type:   'authorization_code',

data/lib/aspera/persistency_action_once.rb

@@ -8,21 +8,21 @@ module Aspera
   # Persist data on file system
   class PersistencyActionOnce
     DELETE_DEFAULT = lambda(&:empty?)
-    PARSE_DEFAULT = lambda{ |t| JSON.parse(t)}
-    FORMAT_DEFAULT = lambda{ |h| JSON.generate(h)}
-    MERGE_DEFAULT = lambda{ |current, file| current.concat(file).uniq rescue current}
+    PARSE_DEFAULT = lambda { |t| JSON.parse(t) }
+    FORMAT_DEFAULT = lambda { |h| JSON.generate(h) }
+    MERGE_DEFAULT = lambda { |current, file| current.concat(file).uniq rescue current }
     MANAGER_METHODS = %i[get put delete]
     private_constant :DELETE_DEFAULT, :PARSE_DEFAULT, :FORMAT_DEFAULT, :MERGE_DEFAULT, :MANAGER_METHODS
 
-    # @param :manager  Mandatory Database
-    # @param :data     Mandatory object to persist, must be same object from begin to end (assume array by default)
-    # @param :id       Mandatory identifiers
-    # @param :delete   Optional  delete persistency condition
-    # @param :parse    Optional  parse method (default to JSON)
-    # @param :format   Optional  dump method (default to JSON)
-    # @param :merge    Optional  merge data from file to current data
+    # @param manager [Object]  Mandatory Database (must respond to get/put/delete)
+    # @param data    [Object]  Mandatory object to persist, must be same object from begin to end (assume array by default)
+    # @param id      [String]  Mandatory identifier
+    # @param delete  [Proc]    Optional delete persistency condition
+    # @param parse   [Proc]    Optional parse method (default to JSON)
+    # @param format  [Proc]    Optional dump method (default to JSON)
+    # @param merge   [Proc]    Optional merge data from file to current data
     def initialize(manager:, data:, id:, delete: DELETE_DEFAULT, parse: PARSE_DEFAULT, format: FORMAT_DEFAULT, merge: MERGE_DEFAULT)
-      Aspera.assert(MANAGER_METHODS.all?{ |i| manager.respond_to?(i)}){"Manager must answer to #{MANAGER_METHODS}"}
+      Aspera.assert(MANAGER_METHODS.all? { |i| manager.respond_to?(i) }) { "Manager must answer to #{MANAGER_METHODS}" }
       Aspera.assert(!data.nil?, 'data must not be nil')
       Aspera.assert_type(id, String)
       Aspera.assert(!id.empty?, 'id must not be empty')
@@ -48,7 +48,7 @@ module Aspera
       end
     end
 
-    # @return internal persisted object, in order to modify its content
+    # @return [Array, Hash] internal persisted object, in order to modify its content
     def data
       return @persisted_object
     end

data/lib/aspera/persistency_folder.rb

@@ -15,18 +15,19 @@ module Aspera
     def initialize(folder)
       @cache = {}
       @folder = folder
-      Log.log.debug{"persistency folder: #{@folder}"}
+      Log.log.debug { "persistency folder: #{@folder}" }
     end
 
     # Get value of persisted item
-    # @return [String,nil] Value of persisted id
+    # @param object_id [String] Identifier of persisted item
+    # @return [String, nil] Persisted value, or nil if not found
     def get(object_id)
-      Log.log.debug{"persistency get: #{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)
@@ -42,7 +43,7 @@ module Aspera
     def put(object_id, value)
       Aspera.assert_type(value, String)
       persist_filepath = id_to_filepath(object_id)
-      Log.log.debug{"persistency saving: #{persist_filepath}"}
+      Log.log.debug { "persistency saving: #{persist_filepath}" }
       FileUtils.rm_f(persist_filepath)
       File.write(persist_filepath, value)
       Environment.restrict_file_access(persist_filepath)
@@ -54,37 +55,43 @@ module Aspera
     # @param object_id [String] Identifier of persisted item
     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}" }
       FileUtils.rm_f(persist_filepath)
       @cache.delete(object_id)
     end
 
-    # Delete persisted items
+    # Delete persisted items matching the given category, optionally older than a given age
+    # @param persist_category [String]       Prefix used to identify files belonging to the category
+    # @param max_age_seconds  [Integer, nil] If set, only delete files older than this many seconds
+    # @return [Array<String>] List of deleted file paths
     def garbage_collect(persist_category, max_age_seconds = nil)
       garbage_files = current_files(persist_category)
       if !max_age_seconds.nil?
         current_time = Time.now
-        garbage_files.select!{ |filepath| (current_time - File.stat(filepath).mtime).to_i > max_age_seconds}
+        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
       @cache.clear
       return garbage_files
     end
 
+    # List all persisted files matching the given category prefix
+    # @param persist_category [String] Prefix identifying the category
+    # @return [Array<String>] List of matching file paths
     def current_files(persist_category)
       Dir[File.join(@folder, "#{persist_category}*#{FILE_SUFFIX}")]
     end
 
     def current_items(persist_category)
-      current_files(persist_category).to_h{ |i| [File.basename(i, FILE_SUFFIX), File.read(i)]}
+      current_files(persist_category).to_h { |i| [File.basename(i, FILE_SUFFIX), File.read(i)] }
     end
 
     private
 
-    # @param object_id String or Array
+    # @param object_id [String, Array] identifier or list of identifiers
     def id_to_filepath(object_id)
       Aspera.assert_type(object_id, String)
       FileUtils.mkdir_p(@folder)

data/lib/aspera/preview/file_types.rb

@@ -78,18 +78,18 @@ module Aspera
 
       # @param filepath [String] Full path to file
       # @param mimetype [String] MIME typre provided by node API
-      # @return file type, one of enum CONVERSION_TYPES
+      # @return [Symbol] file type, one of enum CONVERSION_TYPES
       # @raise [RuntimeError] if no conversion type found
       def conversion_type(filepath, mimetype)
-        Log.log.debug{"conversion_type(#{filepath},mime=#{mimetype},magic=#{@use_mimemagic})"}
+        Log.log.debug { "conversion_type(#{filepath},mime=#{mimetype},magic=#{@use_mimemagic})" }
         # Default type or empty means no type
         mimetype = TYPE_NOT_FOUND if mimetype.nil? || (mimetype.is_a?(String) && mimetype.empty?)
         mimetype = Marcel::MimeType.for(Pathname.new(filepath), name: File.basename(filepath), declared_type: mimetype)
         mimetype = 'text/plain' if mimetype.eql?(TYPE_NOT_FOUND) && ascii_text_file?(filepath)
-        raise "no MIME type found for #{File.basename(filepath)}" if mimetype.eql?(TYPE_NOT_FOUND)
+        Aspera.assert(!mimetype.eql?(TYPE_NOT_FOUND)) { "no MIME type found for #{File.basename(filepath)}" }
         conversion_type = mime_to_type(mimetype)
-        raise "no conversion type found for #{File.basename(filepath)}" if conversion_type.nil?
-        Log.log.trace1{"conversion_type(#{File.basename(filepath)}): #{conversion_type.class.name} [#{conversion_type}]"}
+        Aspera.assert(!conversion_type.nil?) { "no conversion type found for #{File.basename(filepath)}" }
+        Log.log.trace1 { "conversion_type(#{File.basename(filepath)}): #{conversion_type.class.name} [#{conversion_type}]" }
         return conversion_type
       end
 

data/lib/aspera/preview/generator.rb

@@ -27,10 +27,10 @@ module Aspera
       # Node API MIME types are from: http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types.
       # The resulting preview file type is taken from destination file extension.
       # Conversion methods are provided by private methods: convert_<conversion_type>_to_<preview_format>.
-      #   -> conversion_type is one of FileTypes::CONVERSION_TYPES.
-      #   -> preview_format is one of Generator::PREVIEW_FORMATS.
+      #   conversion_type: one of FileTypes::CONVERSION_TYPES.
+      #   preview_format: 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.
+      #   conversion method: one of Generator::VIDEO_CONVERSION_METHODS.
       # @param src [String] Source file path.
       # @param dst [String] Destination file path.
       # @param options [Options] All conversion options.
@@ -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'},