aspera-cli 4.26.2 → 4.27.0

data/lib/aspera/link_header.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module Aspera
+  # Parse and represent an HTTP Link header as per RFC 8288.
+  # Inspired by the link_header gem, with the following fixes:
+  #   - rel lookup is case-insensitive (RFC 7230: parameter names are case-insensitive)
+  #   - uses StringScanner so commas inside <URI> are never mistaken for entry separators
+  #   - no external dependency
+  class LinkHeader
+    # A single link entry: one URI and its attribute pairs.
+    class Link
+      attr_reader :href, :attr_pairs
+
+      def initialize(href, attr_pairs)
+        @href = href
+        @attr_pairs = attr_pairs
+      end
+
+      # Retrieve an attribute value by name, case-insensitively.
+      def [](key)
+        pair = @attr_pairs.detect{ |k, _v| k.casecmp?(key)}
+        pair&.last
+      end
+    end
+
+    attr_reader :links
+
+    def initialize(links = [])
+      @links = links
+    end
+
+    # Return the href of the first link whose +rel+ attribute matches +rel+.
+    # Comparison is case-insensitive per RFC 7230 s.3.2 and RFC 8288 s.3.
+    # Returns nil if no link with that relation exists.
+    # @param rel [String]
+    # @return [String, nil]
+    def find_href(rel: 'next')
+      @links.detect{ |link| link['rel']&.casecmp?(rel)}&.href
+    end
+
+    class << self
+      # Parse a raw Link header value into a +LinkHeader+ instance.
+      # Uses StringScanner so that commas inside <URI> are not treated as separators.
+      # @param raw [String, nil]
+      # @return [LinkHeader]
+      def parse(raw)
+        return new unless raw && !raw.empty?
+
+        links = []
+        scanner = StringScanner.new(raw)
+
+        while scanner.scan(HREF_RE)
+          href  = scanner[1].strip
+          attrs = []
+          while scanner.scan(ATTR_RE)
+            key   = scanner[1]
+            # scanner[2] = full match (token or "quoted"), scanner[3] = content inside double-quotes
+            value = scanner[3] || scanner[2]
+            attrs << [key, value]
+            break unless scanner.scan(SEMI_RE)
+          end
+          links << Link.new(href, attrs)
+          break unless scanner.scan(COMMA_RE)
+        end
+
+        new(links)
+      end
+
+      private :new
+    end
+
+    # RFC 2616 token: any char except separators
+    TOKEN_RE  = /[^()<>@,;:\"\[\]?={}\s]+/  # RFC 2616 token
+    QUOTED_RE = /"((?:[^"\\]|\\.)*)"/       # double-quoted string with backslash escapes
+    HREF_RE   = /\s*<([^>]*)>\s*;?\s*/      # <URI> possibly followed by ;
+    ATTR_RE   = /(#{TOKEN_RE})\s*=\s*(#{TOKEN_RE}|#{QUOTED_RE})\s*/ # key=value or key="value"
+    SEMI_RE   = /;\s*/                       # parameter separator
+    COMMA_RE  = /,\s*/                       # link entry separator
+  end
+end

data/lib/aspera/log.rb

@@ -36,13 +36,16 @@ class Logger
   end
 
   class << self
-    # Define methods for a given log level
+    # Define logger methods for a given log level (e.g. `debug`, `debug?`, `debug!`)
+    # @param str_level [String] Log level name (e.g. "DEBUG", "TRACE1")
+    # @return [nil]
     def make_methods(str_level)
       int_level = ::Logger.const_get(str_level.upcase)
       method_base = str_level.downcase
       define_method(method_base, ->(message = nil, &block){add(int_level, message, &block)})
       define_method("#{method_base}?", ->{level <= int_level})
       define_method("#{method_base}!", ->{self.level = int_level})
+      nil
     end
   end
   # Declare methods for all levels
@@ -142,9 +145,13 @@ module Aspera
     attr_reader :logger_type, :logger
     attr_accessor :dump_format
 
+    # Set the program name used in log output
+    # @param value [String] Program name
+    # @return [nil]
     def program_name=(value)
       @program_name = value
       self.logger_type = @logger_type
+      nil
     end
 
     # Set log level of underlying logger given symbol level
@@ -154,15 +161,19 @@ module Aspera
       @logger.level = Logger::Severity.const_get(new_level.to_sym.upcase)
     end
 
+    # Set log formatter; accepts a symbol name, a Proc, or a Logger::Formatter instance
+    # @param formatter [String, Proc, Logger::Formatter] Formatter to use; one of: standard, default, caller
+    # @return [nil]
     def formatter=(formatter)
       if formatter.is_a?(String)
-        raise Error, "Unknown formatter #{formatter}, use one of: #{FORMATTERS.join(', ')}" unless FORMATTER_LAMBDAS.key?(formatter.to_sym)
+        Aspera.assert(FORMATTER_LAMBDAS.key?(formatter.to_sym), type: Error){"Unknown formatter #{formatter}, use one of: #{FORMATTERS.join(', ')}"}
         formatter = FORMATTER_LAMBDAS[formatter.to_sym]
       elsif !formatter.respond_to?(:call) && !formatter.is_a?(Logger::Formatter)
         raise Error, 'Formatter must be a String, a Logger::Formatter or a Proc'
       end
       # Update formatter with password hiding
       @logger.formatter = SecretHider.instance.log_formatter(formatter)
+      nil
     end
 
     def formatter
@@ -176,7 +187,9 @@ module Aspera
       Logger::SEVERITY_LABEL[@logger.level].downcase
     end
 
-    # Change underlying logger, but keep log level (default: INFO)
+    # Change underlying logger output destination, keeping current log level
+    # @param new_log_type [Symbol] Log destination; one of LOG_TYPES (:stderr, :stdout, :syslog)
+    # @return [nil]
     def logger_type=(new_log_type)
       # [Integer]
       current_severity_integer = @logger&.level || ENV['AS_LOG_LEVEL']&.to_i || Logger::Severity::INFO
@@ -203,6 +216,7 @@ module Aspera
       @logger_type = new_log_type
       # add secret hider to default logger
       self.formatter = @logger.formatter
+      nil
     end
 
     private

data/lib/aspera/markdown.rb

@@ -9,6 +9,71 @@ module Aspera
 
     class << self
       COL_WIDTH = 80
+
+      # Convert a Markdown heading text to a GitHub-flavoured anchor.
+      # Rules: downcase, keep letters/digits/spaces/hyphens, replace spaces with hyphens.
+      # Duplicate anchors are disambiguated by appending -1, -2, … (pass a seen Hash to track).
+      # @param text  [String]           raw heading text (without leading # and spaces)
+      # @param seen  [Hash{String=>Integer}, nil]  mutable counter; pass the same Hash across a document
+      # @return [String] anchor slug (without leading #)
+      def heading_to_anchor(text, seen: nil)
+        slug = text
+          .downcase
+          .gsub(/[`*_]/, '')           # strip inline code/bold/italic markers
+          .gsub(/&[a-z]+;/, '')        # strip HTML entities
+          .gsub(/[^\w\s-]/, '')        # keep word chars, spaces, hyphens
+          .gsub(/\s+/, '-')            # spaces → hyphens
+          .squeeze('-')                # collapse consecutive hyphens
+          .strip
+        if seen
+          count = seen[slug].to_i
+          seen[slug] = count + 1
+          slug = "#{slug}-#{count}" if count > 0
+        end
+        slug
+      end
+
+      # Extract the table of contents from a Markdown document.
+      # @param content [String]  full Markdown source
+      # @return [Array<Hash>]   array of { level, title, anchor }
+      HEADING_RE = /^(\#{1,6})\s+(.+)$/
+
+      def toc(content)
+        seen = {}
+        content.each_line.filter_map do |line|
+          m = line.match(HEADING_RE)
+          next unless m
+          title = m[2].strip
+          {level: m[1].length, title: title, anchor: heading_to_anchor(title, seen: seen)}
+        end
+      end
+
+      # Extract the content of a single section (heading + body until next heading of same/higher level).
+      # @param content   [String]  full Markdown source
+      # @param anchor    [String]  GitHub anchor slug (without #)
+      # @return [String, nil]  the section content, or nil if not found
+      def extract_section(content, anchor)
+        seen = {}
+        section_level = nil
+        result = []
+        content.each_line do |line|
+          m = line.match(HEADING_RE)
+          if m
+            slug = heading_to_anchor(m[2].strip, seen: seen)
+            if section_level.nil?
+              # not yet found: check if this heading matches
+              next unless slug == anchor
+              section_level = m[1].length
+            elsif m[1].length <= section_level
+              # already in section: stop at same/higher level heading
+              break
+            end
+          end
+          result << line if section_level
+        end
+        result.empty? ? nil : result.join
+      end
+
       # Generate markdown from the provided 2D table
       # @param table [Array<Array<String>>] 2D array of strings
       # @return [String] markdown table
@@ -26,28 +91,46 @@ module Aspera
       end
 
       # Generate markdown list from the provided list
+      # @param items [Array<String>] list of items
+      # @return [String] markdown unordered list
       def list(items)
         items.map{ |i| "- #{i}"}.join("\n")
       end
 
+      # Generate a markdown heading
+      # @param title [String] heading text
+      # @param level [Integer] heading level (1–6)
+      # @return [String] markdown heading
       def heading(title, level: 1)
         "#{'#' * level} #{title}\n\n"
       end
 
-      # type: NOTE CAUTION WARNING IMPORTANT TIP INFO
+      # Generate a GitHub-flavoured admonition block
+      # @param lines [Array<String>] lines of the admonition body
+      # @param type [String] admonition type: NOTE, CAUTION, WARNING, IMPORTANT, TIP, INFO
+      # @return [String] markdown admonition block
       def admonition(lines, type: 'INFO')
         "> [!#{type}]\n#{lines.map{ |l| "> #{l}"}.join("\n")}\n\n"
       end
 
+      # Generate a fenced code block
+      # @param lines [Array<String>] lines of code
+      # @param type [String] language identifier for syntax highlighting
+      # @return [String] markdown fenced code block
       def code(lines, type: 'shell')
         "```#{type}\n#{lines.join("\n")}\n```\n\n"
       end
 
-      # inline code
+      # Wrap text in inline code backticks
+      # @param text [String] text to wrap
+      # @return [String] inline code span
       def icode(text)
         "`#{text}`"
       end
 
+      # Wrap text in a markdown paragraph (trailing blank line)
+      # @param text [String] paragraph content
+      # @return [String] paragraph with trailing newlines
       def paragraph(text)
         "#{text}\n\n"
       end

data/lib/aspera/node_simulator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/assert'
 require 'aspera/ascp/installation'
 require 'aspera/agent/direct'
 require 'aspera/log'
@@ -128,6 +129,7 @@ module Aspera
 
     # Process event from management port
     def process_event(event)
+      # Code duplicated on purpose, as implementation goes, blocks will be replaced
       case event['Type']
       when 'NOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
       # rubocop:disable Lint/DuplicateBranch
@@ -174,7 +176,7 @@ module Aspera
     require 'time'
 
     def folder_to_structure(folder_path)
-      raise "Path does not exist or is not a directory: #{folder_path}" unless Dir.exist?(folder_path)
+      Aspera.assert(Dir.exist?(folder_path)){"Path does not exist or is not a directory: #{folder_path}"}
 
       # Build self structure
       folder_stat = File.stat(folder_path)

data/lib/aspera/oauth/base.rb

@@ -48,8 +48,8 @@ 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}
         return @api.create(@path_token, nil, query: creation_params, ret: :resp) if @use_query
@@ -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
@@ -106,7 +106,7 @@ module Aspera
                 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}"}
               end

data/lib/aspera/oauth/boot.rb

@@ -8,11 +8,11 @@ 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

data/lib/aspera/oauth/factory.rb

@@ -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}"}
         @token_type_classes[id] = creator_class
+        nil
       end
 
       # Create a token creator instance for the specified grant method

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:,
@@ -49,7 +49,7 @@ module Aspera
 
       def create_token
         require 'jwt'
-        seconds_since_epoch = Time.new.to_i
+        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

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',

data/lib/aspera/persistency_action_once.rb

@@ -14,13 +14,13 @@ module Aspera
     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(!data.nil?, 'data must not be nil')
@@ -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

@@ -19,7 +19,8 @@ module Aspera
     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}"}
       if @cache.key?(object_id)
@@ -59,7 +60,10 @@ module Aspera
       @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?
@@ -74,6 +78,9 @@ module Aspera
       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
@@ -84,7 +91,7 @@ module Aspera
 
     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,7 +78,7 @@ 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})"}
@@ -86,9 +86,9 @@ module Aspera
         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?
+        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.

data/lib/aspera/preview/utils.rb

@@ -64,7 +64,7 @@ module Aspera
           silent_execute(:ffmpeg, *gl_p, *in_p, '-i', in_f, *out_p, out_f)
         end
 
-        # @return Float in seconds
+        # @return [Float] duration in seconds
         def video_get_duration(input_file)
           return execute(
             :ffprobe,

data/lib/aspera/products/connect.rb

@@ -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/other.rb

@@ -57,7 +57,7 @@ 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|

data/lib/aspera/products/transferd.rb

@@ -27,7 +27,7 @@ module Aspera
           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

data/lib/aspera/proxy_auto_config.rb

@@ -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
@@ -79,7 +79,7 @@ END_OF_JAVASCRIPT
     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}"
@@ -99,7 +99,7 @@ END_OF_JAVASCRIPT
     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 = []
@@ -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')
@@ -136,7 +137,7 @@ END_OF_JAVASCRIPT
           rescue StandardError => 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}"}