aspera-cli 4.15.0 → 4.16.0

data/lib/aspera/preview/file_types.rb

@@ -2,6 +2,7 @@
 
 require 'aspera/log'
 require 'singleton'
+require 'mime/types'
 
 module Aspera
   module Preview
@@ -11,266 +12,41 @@ module Aspera
       # values for conversion_type : input format
       CONVERSION_TYPES = %i[image office pdf plaintext video].freeze
 
-      # define how files are processed based on mime type
+      # special cases for mime types
       # spellchecker:disable
       SUPPORTED_MIME_TYPES = {
-        'application/json'                                                          => :plaintext,
-        'application/mac-binhex40'                                                  => :office,
-        'application/msword'                                                        => :office,
-        'application/pdf'                                                           => :pdf,
-        'application/postscript'                                                    => :image,
-        'application/rtf'                                                           => :office,
-        'application/vnd.3gpp.pic-bw-small'                                         => :image,
-        'application/vnd.hp-hpgl'                                                   => :image,
-        'application/vnd.hp-pcl'                                                    => :image,
-        'application/vnd.lotus-wordpro'                                             => :office,
-        'application/vnd.mobius.msl'                                                => :image,
-        'application/vnd.mophun.certificate'                                        => :image,
-        'application/vnd.ms-excel'                                                  => :office,
-        'application/vnd.ms-excel.sheet.binary.macroenabled.12'                     => :office,
-        'application/vnd.ms-excel.sheet.macroenabled.12'                            => :office,
-        'application/vnd.ms-excel.template.macroenabled.12'                         => :office,
-        'application/vnd.ms-powerpoint'                                             => :office,
-        'application/vnd.ms-powerpoint.presentation.macroenabled.12'                => :office,
-        'application/vnd.ms-powerpoint.template.macroenabled.12'                    => :office,
-        'application/vnd.ms-word.document.macroenabled.12'                          => :office,
-        'application/vnd.ms-word.template.macroenabled.12'                          => :office,
-        'application/vnd.ms-works'                                                  => :office,
-        'application/vnd.oasis.opendocument.chart'                                  => :office,
-        'application/vnd.oasis.opendocument.formula'                                => :office,
-        'application/vnd.oasis.opendocument.graphics'                               => :office,
-        'application/vnd.oasis.opendocument.graphics-template'                      => :office,
-        'application/vnd.oasis.opendocument.presentation'                           => :office,
-        'application/vnd.oasis.opendocument.presentation-template'                  => :office,
-        'application/vnd.oasis.opendocument.spreadsheet'                            => :office,
-        'application/vnd.oasis.opendocument.spreadsheet-template'                   => :office,
-        'application/vnd.oasis.opendocument.text'                                   => :office,
-        'application/vnd.oasis.opendocument.text-template'                          => :office,
-        'application/vnd.openxmlformats-officedocument.presentationml.presentation' => :office,
-        'application/vnd.openxmlformats-officedocument.presentationml.slideshow'    => :office,
-        'application/vnd.openxmlformats-officedocument.presentationml.template'     => :office,
-        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'         => :office,
-        'application/vnd.openxmlformats-officedocument.spreadsheetml.template'      => :office,
-        'application/vnd.openxmlformats-officedocument.wordprocessingml.document'   => :office,
-        'application/vnd.openxmlformats-officedocument.wordprocessingml.template'   => :office,
-        'application/vnd.palm'                                                      => :office,
-        'application/vnd.sun.xml.calc'                                              => :office,
-        'application/vnd.sun.xml.calc.template'                                     => :office,
-        'application/vnd.sun.xml.draw'                                              => :office,
-        'application/vnd.sun.xml.draw.template'                                     => :office,
-        'application/vnd.sun.xml.impress'                                           => :office,
-        'application/vnd.sun.xml.impress.template'                                  => :office,
-        'application/vnd.sun.xml.math'                                              => :office,
-        'application/vnd.sun.xml.writer'                                            => :office,
-        'application/vnd.sun.xml.writer.template'                                   => :office,
-        'application/vnd.wordperfect'                                               => :office,
-        'application/x-abiword'                                                     => :office,
-        'application/x-director'                                                    => :image,
-        'application/x-font-type1'                                                  => :image,
-        'application/x-msmetafile'                                                  => :image,
-        'application/x-mspublisher'                                                 => :office,
-        'application/x-xfig'                                                        => :image,
-        'audio/ogg'                                                                 => :video,
-        'font/ttf'                                                                  => :image,
-        'image/bmp'                                                                 => :image,
-        'image/cgm'                                                                 => :image,
-        'image/gif'                                                                 => :image,
-        'image/jpeg'                                                                => :image,
-        'image/png'                                                                 => :image,
-        'image/sgi'                                                                 => :image,
-        'image/svg+xml'                                                             => :image,
-        'image/tiff'                                                                => :image,
-        'image/vnd.adobe.photoshop'                                                 => :image,
-        'image/vnd.djvu'                                                            => :image,
-        'image/vnd.dxf'                                                             => :office,
-        'image/vnd.fpx'                                                             => :image,
-        'image/vnd.ms-photo'                                                        => :image,
-        'image/vnd.wap.wbmp'                                                        => :image,
-        'image/webp'                                                                => :image,
-        'image/x-cmx'                                                               => :office,
-        'image/x-freehand'                                                          => :office,
-        'image/x-icon'                                                              => :image,
-        'image/x-mrsid-image'                                                       => :image,
-        'image/x-pcx'                                                               => :image,
-        'image/x-pict'                                                              => :office,
-        'image/x-portable-anymap'                                                   => :image,
-        'image/x-portable-bitmap'                                                   => :image,
-        'image/x-portable-graymap'                                                  => :image,
-        'image/x-portable-pixmap'                                                   => :image,
-        'image/x-rgb'                                                               => :image,
-        'image/x-tga'                                                               => :image,
-        'image/x-xbitmap'                                                           => :image,
-        'image/x-xpixmap'                                                           => :image,
-        'image/x-xwindowdump'                                                       => :image,
-        'text/csv'                                                                  => :office,
-        'text/html'                                                                 => :office,
-        'text/plain'                                                                => :plaintext,
-        'text/troff'                                                                => :image,
-        'video/h261'                                                                => :video,
-        'video/h263'                                                                => :video,
-        'video/h264'                                                                => :video,
-        'video/mp4'                                                                 => :video,
-        'video/mpeg'                                                                => :video,
-        'video/quicktime'                                                           => :video,
-        'video/x-flv'                                                               => :video,
-        'video/x-m4v'                                                               => :video,
-        'video/x-matroska'                                                          => :video,
-        'video/x-mng'                                                               => :image,
-        'video/x-ms-wmv'                                                            => :video,
-        'video/x-msvideo'                                                           => :video}.freeze
+        'application/json'                   => :plaintext,
+        'text/plain'                         => :plaintext,
+        'application/pdf'                    => :pdf,
+        'audio/ogg'                          => :video,
+        'application/mxf'                    => :video,
+        'application/mac-binhex40'           => :office,
+        'application/msword'                 => :office,
+        'application/rtf'                    => :office,
+        'application/x-abiword'              => :office,
+        'application/x-mspublisher'          => :office,
+        'image/vnd.dxf'                      => :office,
+        'image/x-cmx'                        => :office,
+        'image/x-freehand'                   => :office,
+        'image/x-pict'                       => :office,
+        'text/csv'                           => :office,
+        'text/html'                          => :office,
+        'application/dicom'                  => :image,
+        'application/postscript'             => :image,
+        'application/vnd.3gpp.pic-bw-small'  => :image,
+        'application/vnd.hp-hpgl'            => :image,
+        'application/vnd.hp-pcl'             => :image,
+        'application/vnd.mobius.msl'         => :image,
+        'application/vnd.mophun.certificate' => :image,
+        'application/x-director'             => :image,
+        'application/x-font-type1'           => :image,
+        'application/x-msmetafile'           => :image,
+        'application/x-xfig'                 => :image,
+        'font/ttf'                           => :image,
+        'text/troff'                         => :image,
+        'video/x-mng'                        => :image}.freeze
 
-      # this is a way to add support for extensions that are otherwise not known by node api (mime type)
-      SUPPORTED_EXTENSIONS = {
-        'aai'          => :image,
-        'art'          => :image,
-        'arw'          => :image,
-        'avs'          => :image,
-        'bmp2'         => :image,
-        'bmp3'         => :image,
-        'bpg'          => :image,
-        'cals'         => :image,
-        'cdr'          => :office,
-        'cin'          => :image,
-        'clipboard'    => :image,
-        'cmyk'         => :image,
-        'cmyka'        => :image,
-        'cr2'          => :image,
-        'crw'          => :image,
-        'cur'          => :image,
-        'cut'          => :image,
-        'cwk'          => :office,
-        'dbf'          => :office,
-        'dcm'          => :image,
-        'dcx'          => :image,
-        'dds'          => :image,
-        'dib'          => :image,
-        'dif'          => :office,
-        'divx'         => :video,
-        'dng'          => :image,
-        'docx'         => :office,
-        'dpx'          => :image,
-        'epdf'         => :image,
-        'epi'          => :image,
-        'eps2'         => :image,
-        'eps3'         => :image,
-        'epsf'         => :image,
-        'epsi'         => :image,
-        'ept'          => :image,
-        'exr'          => :image,
-        'fax'          => :image,
-        'fb2'          => :office,
-        'fits'         => :image,
-        'fodg'         => :office,
-        'fodp'         => :office,
-        'fods'         => :office,
-        'fodt'         => :office,
-        'gplt'         => :image,
-        'gray'         => :image,
-        'hdr'          => :image,
-        'hpw'          => :office,
-        'hrz'          => :image,
-        'info'         => :image,
-        'inline'       => :image,
-        'j2c'          => :image,
-        'j2k'          => :image,
-        'jbig'         => :image,
-        'jng'          => :image,
-        'jp2'          => :image,
-        'jpt'          => :image,
-        'jxr'          => :image,
-        'key'          => :office,
-        'log'          => :plaintext,
-        'mat'          => :image,
-        'mcw'          => :office,
-        'met'          => :office,
-        'miff'         => :image,
-        'mml'          => :office,
-        'mono'         => :image,
-        'mpr'          => :image,
-        'mrsid'        => :image,
-        'mrw'          => :image,
-        'mtv'          => :image,
-        'mvg'          => :image,
-        'mw'           => :office,
-        'mwd'          => :office,
-        'mxf'          => :video,
-        'nef'          => :image,
-        'numbers'      => :office,
-        'orf'          => :image,
-        'otb'          => :image,
-        'p7'           => :image,
-        'pages'        => :office,
-        'palm'         => :image,
-        'pam'          => :image,
-        'pcd'          => :image,
-        'pcds'         => :image,
-        'pdf'          => :pdf,
-        'pef'          => :image,
-        'picon'        => :image,
-        'pict'         => :image,
-        'pix'          => :image,
-        'pm'           => :office,
-        'pm6'          => :office,
-        'pmd'          => :office,
-        'png00'        => :image,
-        'png24'        => :image,
-        'png32'        => :image,
-        'png48'        => :image,
-        'png64'        => :image,
-        'png8'         => :image,
-        'ps2'          => :image,
-        'ps3'          => :image,
-        'ptif'         => :image,
-        'pwp'          => :image,
-        'rad'          => :image,
-        'raf'          => :image,
-        'rfg'          => :image,
-        'rgba'         => :image,
-        'rla'          => :image,
-        'rle'          => :image,
-        'sct'          => :image,
-        'sfw'          => :image,
-        'sgf'          => :office,
-        'sgv'          => :office,
-        'slk'          => :office,
-        'sparse-color' => :image,
-        'sun'          => :image,
-        'svm'          => :office,
-        'sylk'         => :office,
-        'tim'          => :image,
-        'txt'          => :plaintext,
-        'uil'          => :image,
-        'uof'          => :office,
-        'uop'          => :office,
-        'uos'          => :office,
-        'uot'          => :office,
-        'uyvy'         => :image,
-        'vds'          => :office,
-        'vdx'          => :office,
-        'vicar'        => :image,
-        'viff'         => :image,
-        'vsdx'         => :office,
-        'webm'         => :video,
-        'wb2'          => :office,
-        'wk1'          => :office,
-        'wk3'          => :office,
-        'wn'           => :office,
-        'wpg'          => :image,
-        'wq1'          => :office,
-        'wq2'          => :office,
-        'x'            => :image,
-        'x3f'          => :image,
-        'xcf'          => :image,
-        'xlk'          => :office,
-        'xlsx'         => :office,
-        'xls'          => :office,
-        'ycbcr'        => :image,
-        'ycbcra'       => :image,
-        'yuv'          => :image,
-        'zabw'         => :office}.freeze
-      # spellchecker:enable
-
-      private_constant :SUPPORTED_MIME_TYPES, :SUPPORTED_EXTENSIONS
+      private_constant :SUPPORTED_MIME_TYPES
 
       # @attr use_mimemagic [bool] true to use mimemagic to determine real mime type based on file content
       attr_accessor :use_mimemagic
@@ -279,8 +55,18 @@ module Aspera
         @use_mimemagic = false
       end
 
+      # @param mimetype [String] mime type
+      # @return file type, one of enum CONVERSION_TYPES
+      def mime_to_type(mimetype)
+        return SUPPORTED_MIME_TYPES[mimetype] if SUPPORTED_MIME_TYPES.key?(mimetype)
+        return :office if mimetype.start_with?('application/vnd.')
+        return :video if mimetype.start_with?('video/')
+        return :image if mimetype.start_with?('image/')
+        return nil
+      end
+
       # use mime magic to find mime type based on file content (magic numbers)
-      def mime_from_file(filepath)
+      def file_to_mime(filepath)
         # moved here, as `mimemagic` can cause installation issues
         require 'mimemagic'
         require 'mimemagic/version'
@@ -288,7 +74,7 @@ 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.key?(detected_mime)
+        if mime_to_type(detected_mime).nil?
           Log.log.debug{"no conversion for #{detected_mime}, trying extension"}
           detected_mime = MimeMagic.by_extension(File.extname(filepath)).to_s
         end
@@ -298,18 +84,18 @@ module Aspera
       end
 
       # @param filepath [String] full path to file
-      # @param mimetype [String] provided by node api
+      # @param mimetype [String] provided by node API
       # @return 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},m=#{mimetype},t=#{@use_mimemagic})"}
         # 1- get type from provided mime type, using local mapping
-        conversion_type = SUPPORTED_MIME_TYPES[mimetype] if !mimetype.nil?
+        conversion_type = mime_to_type(mimetype) if !mimetype.nil?
         # 2- else, from computed mime type (if available)
         if conversion_type.nil? && @use_mimemagic
-          detected_mime = mime_from_file(filepath)
+          detected_mime = file_to_mime(filepath)
           if !detected_mime.nil?
-            conversion_type = SUPPORTED_MIME_TYPES[detected_mime]
+            conversion_type = mime_to_type(detected_mime)
             if !mimetype.nil?
               if mimetype.eql?(detected_mime)
                 Log.log.debug('matching mime type per magic number')
@@ -321,10 +107,10 @@ module Aspera
           end
         end
         # 3- else, from extensions, using local mapping
-        extension = File.extname(filepath.downcase)[1..-1]
-        conversion_type = SUPPORTED_EXTENSIONS[extension] if conversion_type.nil?
-        raise "no conversion type found for extension #{extension}" if conversion_type.nil?
-        Log.log.debug{"conversion_type(#{extension}): #{conversion_type.class.name} [#{conversion_type}]"}
+        mime_by_ext = MIME::Types.of(File.basename(filepath)).first
+        conversion_type = mime_to_type(mime_by_ext.to_s) if conversion_type.nil? && !mime_by_ext.nil?
+        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}]"}
         return conversion_type
       end
     end

data/lib/aspera/preview/generator.rb

@@ -8,6 +8,8 @@ require 'open3'
 require 'aspera/preview/options'
 require 'aspera/preview/utils'
 require 'aspera/preview/file_types'
+require 'aspera/log'
+require 'aspera/assert'
 
 module Aspera
   module Preview
@@ -52,7 +54,7 @@ module Aspera
         end
         @processing_method = @processing_method.to_sym
         Log.log.debug{"method: #{@processing_method}"}
-        raise "no processing know for #{conversion_type} -> #{@preview_format_sym}" unless respond_to?(@processing_method, true)
+        assert(respond_to?(@processing_method, true)){"no processing know for #{conversion_type} -> #{@preview_format_sym}"}
       end
 
       # create preview as specified in constructor
@@ -86,7 +88,7 @@ module Aspera
       # @param total_count of parts
       # @param index of part (start at 1)
       def get_offset(duration, start_offset, total_count, index)
-        raise 'duration must be Float' unless duration.is_a?(Float)
+        assert_type(duration, Float){'duration'}
         return start_offset + ((index - 1) * (duration - start_offset) / total_count)
       end
 
@@ -149,10 +151,10 @@ module Aspera
       # do a simple re-encoding
       def convert_video_to_mp4_using_reencode
         options = @options.reencode_ffmpeg
-        raise 'reencode_ffmpeg must be a Hash' unless options.is_a?(Hash)
+        assert_type(options, Hash){'reencode_ffmpeg'}
         options.each do |k, v|
-          raise "Key not supported: #{k}. Use keys: #{FFMPEG_OPTIONS_LIST.join(',')}" unless FFMPEG_OPTIONS_LIST.include?(k)
-          raise "Value for #{k} must be Array" unless v.is_a?(Array)
+          assert_values(k, FFMPEG_OPTIONS_LIST){'key'}
+          assert_type(v, Array){k}
         end
         Utils.ffmpeg(
           in_f: @source_file_path,

data/lib/aspera/preview/terminal.rb

@@ -2,7 +2,6 @@
 
 # cspell:words Magick MAGICKCORE ITERM mintty winsize termcap
 
-require 'rmagick' # https://rmagick.github.io/index.html
 require 'rainbow'
 require 'io/console'
 module Aspera
@@ -10,8 +9,6 @@ module Aspera
     # Display a picture in the terminal, either using coloured characters or iTerm2
     class Terminal
       # Rainbow only supports 8-bit colors
-      # quantum depth is 8 or 16, see: `convert xc: -format "%q" info:`
-      SHIFT_FOR_8_BIT = Magick::MAGICKCORE_QUANTUM_DEPTH - 8
       # env vars to detect terminal type
       TERM_ENV_VARS = %w[TERM_PROGRAM LC_TERMINAL].freeze
       # terminal names that support iTerm2 image display
@@ -19,7 +16,7 @@ module Aspera
       # TODO: retrieve terminal font ratio using some termcap ?
       # ratio = font height / font width
       DEFAULT_FONT_RATIO = 32.0 / 14.0
-      private_constant :SHIFT_FOR_8_BIT, :TERM_ENV_VARS, :ITERM_NAMES, :DEFAULT_FONT_RATIO
+      private_constant :TERM_ENV_VARS, :ITERM_NAMES, :DEFAULT_FONT_RATIO
       class << self
         # @return [String] the image as text, or the iTerm2 escape sequence
         # @param blob [String] the image as a binary string
@@ -29,6 +26,16 @@ module Aspera
         # @param font_ratio [Float] ratio = font height / font width
         def build(blob, reserve: 3, text: false, double: true, font_ratio: DEFAULT_FONT_RATIO)
           return iterm_display_image(blob) if iterm_supported? && !text
+          begin
+            # do not require statically, as the package is optional
+            require 'rmagick' # https://rmagick.github.io/index.html
+          rescue LoadError => e
+            Log.log.error('Install missing gem: gem install rmagick')
+            # fallback to iterm, if supported
+            return iterm_display_image(blob) if iterm_supported?
+            Log.log.error('Cant display picture.')
+            raise e
+          end
           image = Magick::ImageList.new.from_blob(blob)
           (term_rows, term_columns) = IO.console.winsize
           term_rows -= reserve
@@ -36,11 +43,13 @@ module Aspera
           fit_term_ratio = [term_rows / image.rows.to_f, term_columns / image.columns.to_f].min
           height_ratio = double ? 2.0 : 1.0
           image = image.scale((image.columns * fit_term_ratio * font_ratio).to_i, (image.rows * fit_term_ratio * height_ratio).to_i)
+          # quantum depth is 8 or 16, see: `convert xc: -format "%q" info:`
+          shift_for_8_bit = Magick::MAGICKCORE_QUANTUM_DEPTH - 8
           # get all pixel colors, adjusted for Rainbow
           pixel_colors = []
           image.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)
             # init 2-dim array
             pixel_colors[row] ||= []
             pixel_colors[row][col] = pixel_rgb

data/lib/aspera/preview/utils.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 # cspell:ignore ffprobe optipng unoconv
+require 'aspera/log'
+require 'aspera/assert'
 require 'English'
 require 'tmpdir'
 require 'fileutils'
-require 'aspera/log'
 require 'open3'
 
 module Aspera
@@ -31,7 +32,7 @@ module Aspera
           tools_to_check.delete(:unoconv) if skip_types.include?(:office)
           # Check for binaries
           tools_to_check.each do |command_sym|
-            external_command(command_sym, ['-h'], log_error: false)
+            external_command(command_sym, ['-h'], check_code: false)
           rescue Errno::ENOENT => e
             raise "missing #{command_sym} binary: #{e}"
           rescue
@@ -42,13 +43,13 @@ module Aspera
         # execute external command
         # one could use "system", but we would need to redirect stdout/err
         # @return true if su
-        def external_command(command_sym, command_args, log_error: true)
-          raise "unexpected command #{command_sym}" unless EXTERNAL_TOOLS.include?(command_sym)
+        def external_command(command_sym, command_args, check_code: true)
+          assert_values(command_sym, EXTERNAL_TOOLS){'command'}
           # build command line, and quote special characters
           command_line = command_args.clone.unshift(command_sym).map{|i| shell_quote(i.to_s)}.join(' ')
           Log.log.debug{"cmd=#{command_line}".blue}
           stdout, stderr, status = Open3.capture3(command_line)
-          if log_error && !status.success?
+          if check_code && !status.success?
             Log.log.error{"status: #{status}"}
             Log.log.error{"stdout: #{stdout}"}
             Log.log.error{"stderr: #{stderr}"}
@@ -58,7 +59,7 @@ module Aspera
         end
 
         def ffmpeg(a)
-          raise 'error: hash expected' unless a.is_a?(Hash)
+          assert_type(a, Hash)
           # input_file,input_args,output_file,output_args
           a[:gl_p] ||= [
             '-y', # overwrite output without asking
@@ -66,7 +67,7 @@ module Aspera
           ]
           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)
+          assert(%i[gl_p in_f in_p out_f out_p].eql?(a.keys.sort)){"wrong params (#{a.keys.sort})"}
           external_command(:ffmpeg, [a[:gl_p], a[:in_p], '-i', a[:in_f], a[:out_p], a[:out_f]].flatten)
         end
 

data/lib/aspera/proxy_auto_config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/log'
+require 'aspera/assert'
 require 'uri'
 require 'resolv'
 
@@ -9,7 +11,7 @@ module URI
     alias_method :find_proxy_orig, :find_proxy
     class << self
       def register_proxy_finder
-        raise 'mandatory block missing' unless Kernel.block_given?
+        assert(block_given?)
         # 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)}
       end
@@ -107,11 +109,12 @@ END_OF_JAVASCRIPT
         parts = item.strip.split
         case parts.shift
         when 'DIRECT'
-          raise 'DIRECT has no param' unless parts.empty?
+          assert(parts.empty?){'DIRECT has no param'}
           Log.log.debug('ignoring proxy DIRECT')
         when 'PROXY'
           addr_port = parts.shift
-          raise 'PROXY shall have one param' unless addr_port.is_a?(String) && parts.empty?
+          assert_type(addr_port, String)
+          assert(parts.empty?){'PROXY shall have one param'}
           begin
             # PAC proxy addresses are <host>:<port>
             if /:[0-9]+$/.match?(addr_port)