aspera-cli 4.24.2 → 4.25.0.pre2

data/lib/aspera/sync/database.rb

@@ -8,7 +8,7 @@ else
   require 'sqlite3'
 end
 
-# A wrapper class that provides common API for Ruby and JRuby
+# A wrapper class that provides common API for sqlite in both Ruby and JRuby
 class SqLite3Wrapper
   def initialize(db_path)
     @db_path = db_path
@@ -52,6 +52,7 @@ end
 
 module Aspera
   module Sync
+    # Access `async` sqlite database
     class Database
       def initialize(db_path)
         @db = SqLite3Wrapper.new(db_path)

data/lib/aspera/sync/operations.rb

@@ -23,21 +23,23 @@ module Aspera
       # Default direction for sync
       DEFAULT_DIRECTION = DIRECTIONS.first
 
+      SCP_REMOTE_REGEX = /\A(?:(?:(?<user>[^@:\s]+)@)?(?<host>[^:\s]+):)?(?<path>.+)\z/
+
       class << self
         # Set `remote_dir` in sync parameters based on transfer spec
-        # @param params         [Hash]   Sync parameters, in `conf` or `args` format.
+        # @param sync_info      [Hash]   Sync parameters, in `conf` or `args` format.
         # @param remote_dir_key [String] Key to update in above hash
         # @param transfer_spec  [Hash]   Transfer spec
-        def update_remote_dir(params, remote_dir_key, transfer_spec)
+        def update_remote_dir(sync_info, remote_dir_key, transfer_spec)
           if transfer_spec.dig(*%w[tags aspera node file_id])
             # in AoC, use gen4
-            params[remote_dir_key] = '/'
+            sync_info[remote_dir_key] = '/'
           elsif transfer_spec['cookie']&.start_with?('aspera.shares2')
             # TODO : something more generic, independent of Shares
             # in Shares, the actual folder on remote end is not always the same as the name of the share
             remote_key = transfer_spec['direction'].eql?('send') ? 'destination' : 'source'
             actual_remote = transfer_spec['paths']&.first&.[](remote_key)
-            params[remote_dir_key] = actual_remote if actual_remote
+            sync_info[remote_dir_key] = actual_remote if actual_remote
           end
           nil
         end
@@ -70,36 +72,36 @@ module Aspera
         end
 
         # Get symbol of sync direction, defaulting to :push
-        # @param params [Hash] Sync parameters, old or new format
+        # @param sync_info [Hash] Sync parameters, `conf` or `args` format
         # @return [Symbol] direction symbol, one of :push, :pull, :bidi
-        def direction_sym(params)
-          (params['direction'] || DEFAULT_DIRECTION).to_sym
+        def direction_sym(sync_info)
+          (sync_info['direction'] || DEFAULT_DIRECTION).to_sym
         end
 
         # Start the sync process
-        # @param params [Hash] Sync parameters, old or new format
-        # @param opt_ts [Hash] Optional transfer spec
-        # @param &block [nil, Proc] block to generate transfer spec, takes: direction (one of DIRECTIONS), local_dir, remote_dir
-        def start(params, opt_ts = nil)
-          Log.dump(:sync_params_initial, params)
-          Aspera.assert_type(params, Hash)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+        # @param sync_info [Hash] Sync parameters, old or new format
+        # @param opt_ts    [Hash] Optional transfer spec
+        # @param &block    [nil, Proc] block to generate transfer spec, takes: `direction` (one of DIRECTIONS), `local_dir`, `remote_dir`
+        def start(sync_info, opt_ts = nil)
+          Log.dump(:sync_params_initial, sync_info)
+          Aspera.assert_type(sync_info, Hash)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
           env_args = {
             args: [],
             env:  {}
           }
-          if params.key?('local')
-            # "conf" format
-            Aspera.assert_type(params['local'], Hash){'local'}
-            remote = params['remote']
+          if sync_info.key?('local')
+            # `conf` format
+            Aspera.assert_type(sync_info['local'], Hash){'local'}
+            remote = sync_info['remote']
             Aspera.assert_type(remote, Hash){'remote'}
             Aspera.assert_type(remote['path'], String){'remote path'}
             # get transfer spec if possible, and feed back to new structure
             if block_given?
-              transfer_spec = yield(direction_sym(params), params['local']['path'], remote['path'])
+              transfer_spec = yield(direction_sym(sync_info), sync_info['local']['path'], remote['path'])
               Log.dump(:auth_ts, transfer_spec)
               transfer_spec.deep_merge!(opt_ts) unless opt_ts.nil?
-              tspec_to_sync_info(transfer_spec, params, CONF_SCHEMA)
+              tspec_to_sync_info(transfer_spec, sync_info, CONF_SCHEMA)
               update_remote_dir(remote, 'path', transfer_spec)
             end
             remote['connect_mode'] ||= transfer_spec['wss_enabled'] ? 'ws' : 'ssh'
@@ -109,18 +111,18 @@ module Aspera
               remote['private_key_paths'].concat(add_certificates)
             end
             # '--exclusive-mgmt-port=12345', '--arg-err-path=-',
-            env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(params))}"]
-            Log.dump(:sync_conf, params)
+            env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(sync_info))}"]
+            Log.dump(:sync_conf, sync_info)
             agent = Agent::Direct.new
             agent.start_and_monitor_process(session: {}, name: :async, **env_args)
           else
-            # "args" format
+            # `args` format
             raise StandardError, "Only 'sessions', and optionally 'instance' keys are allowed" unless
-              params.keys.push('instance').uniq.sort.eql?(CMDLINE_PARAMS_KEYS)
-            Aspera.assert_type(params['sessions'], Array)
-            Aspera.assert_type(params['sessions'].first, Hash)
+              sync_info.keys.push('instance').uniq.sort.eql?(CMDLINE_PARAMS_KEYS)
+            Aspera.assert_type(sync_info['sessions'], Array)
+            Aspera.assert_type(sync_info['sessions'].first, Hash)
             if block_given?
-              params['sessions'].each do |session|
+              sync_info['sessions'].each do |session|
                 Aspera.assert_type(session['local_dir'], String){'local_dir'}
                 Aspera.assert_type(session['remote_dir'], String){'remote_dir'}
                 transfer_spec = yield(direction_sym(session), session['local_dir'], session['remote_dir'])
@@ -131,20 +133,20 @@ module Aspera
                 update_remote_dir(session, 'remote_dir', transfer_spec)
               end
             end
-            if params.key?('instance')
-              Aspera.assert_type(params['instance'], Hash)
-              instance_builder = CommandLineBuilder.new(params['instance'], ARGS_INSTANCE_SCHEMA, CommandLineConverter)
+            if sync_info.key?('instance')
+              Aspera.assert_type(sync_info['instance'], Hash)
+              instance_builder = CommandLineBuilder.new(sync_info['instance'], ARGS_INSTANCE_SCHEMA, CommandLineConverter)
               instance_builder.process_params
               instance_builder.add_env_args(env_args)
             end
-            params['sessions'].each do |session_params|
+            sync_info['sessions'].each do |session_params|
               Aspera.assert_type(session_params, Hash)
               Aspera.assert(session_params.key?('name')){'session must contain at least: name'}
               session_builder = CommandLineBuilder.new(session_params, ARGS_SESSION_SCHEMA, CommandLineConverter)
               session_builder.process_params
               session_builder.add_env_args(env_args)
             end
-            Environment.secure_execute(exec: Ascp::Installation.instance.path(:async), **env_args)
+            Environment.secure_execute(Ascp::Installation.instance.path(:async), *env_args[:args], env: env_args[:env])
           end
           return
         end
@@ -168,24 +170,24 @@ module Aspera
         end
 
         # Run `asyncadmin` to get status of sync session
-        # @param params [Hash] sync parameters in conf or args format
+        # @param sync_info [Hash] sync parameters in conf or args format
         # @return [Hash] parsed output of asyncadmin
-        def admin_status(params)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
-          arguments = ['--quiet']
-          if params.key?('local')
-            # "conf" format
-            arguments.push("--name=#{params['name']}")
-            if params.key?('local_db_dir')
-              arguments.push("--local-db-dir=#{params['local_db_dir']}")
-            elsif params.dig('local', 'path')
-              arguments.push("--local-dir=#{params.dig('local', 'path')}")
+        def admin_status(sync_info)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          arguments = [ASYNC_ADMIN_EXECUTABLE, '--quiet']
+          if sync_info.key?('local')
+            # `conf` format
+            arguments.push("--name=#{sync_info['name']}")
+            if sync_info.key?('local_db_dir')
+              arguments.push("--local-db-dir=#{sync_info['local_db_dir']}")
+            elsif sync_info.dig('local', 'path')
+              arguments.push("--local-dir=#{sync_info.dig('local', 'path')}")
             else
               raise Error, 'Missing either local_db_dir or local.path'
             end
           else
-            # "args" format
-            session = params['sessions'].first
+            # `args` format
+            session = sync_info['sessions'].first
             arguments.push("--name=#{session['name']}")
             if session.key?('local_db_dir')
               arguments.push("--local-db-dir=#{session['local_db_dir']}")
@@ -195,27 +197,27 @@ module Aspera
               raise Error, 'Missing either local_db_dir or local_dir'
             end
           end
-          stdout = Environment.secure_capture(exec: ASYNC_ADMIN_EXECUTABLE, args: arguments)
+          stdout = Environment.secure_execute(*arguments, mode: :capture)
           return parse_status(stdout)
         end
 
-        # Find the local database folder based on params
-        # @param params [Hash] sync parameters in conf or args format
-        # @return [String, nil] path to "local DB dir", i.e. folder that contains folders that contain snap.db
-        def local_db_folder(params)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
-          if params.key?('local')
-            # "conf" format
-            if params.key?('local_db_dir')
-              return params['local_db_dir']
-            elsif (local_path = params.dig('local', 'path'))
+        # Find the local database folder based on sync_info
+        # @param sync_info [Hash] sync parameters in conf or args format
+        # @return [String, nil] Path to "local DB dir", i.e. folder that contains folders that contain `snap.db`
+        def local_db_folder(sync_info)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          if sync_info.key?('local')
+            # `conf` format
+            if sync_info.key?('local_db_dir')
+              return sync_info['local_db_dir']
+            elsif (local_path = sync_info.dig('local', 'path'))
               return local_path
             elsif exception
               raise Error, 'Missing either local_db_dir or local.path'
             end
           else
-            # "args" format
-            session = params['sessions'].first
+            # `args` format
+            session = sync_info['sessions'].first
             if session.key?('local_db_dir')
               return session['local_db_dir']
             elsif session.key?('local_dir')
@@ -227,19 +229,19 @@ module Aspera
           nil
         end
 
-        def session_name(params)
-          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
-          if params.key?('local')
-            # "conf" format
-            return params['name']
+        def session_name(sync_info)
+          Aspera.assert(PARAM_KEYS.any?{ |k| sync_info.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          if sync_info.key?('local')
+            # `conf` format
+            return sync_info['name']
           else
-            # "args" format
-            return params['sessions'].first['name']
+            # `args` format
+            return sync_info['sessions'].first['name']
           end
         end
 
-        def session_db_file(params)
-          db_file = File.join(local_db_folder(params), PRIVATE_FOLDER, session_name(params), ASYNC_DB)
+        def session_db_file(sync_info)
+          db_file = File.join(local_db_folder(sync_info), PRIVATE_FOLDER, session_name(sync_info), ASYNC_DB)
           Aspera.assert(File.exist?(db_file)){"Database file #{db_file} does not exist"}
           db_file
         end
@@ -274,16 +276,70 @@ module Aspera
             end
           end
         end
+
+        # Search given option in JSON Schema tree
+        # @param schema [Hash]   JSON Schema tree (root or sub-tree)
+        # @param path   [Array]  Path to subtree
+        # @param option [String] Option to search
+        # @return [Array,nil] with path/schema for that option
+        def find_option(schema, path, option)
+          if %w[x-cli-option x-cli-short].any?{ |i| schema[i].eql?(option)}
+            Log.log.debug('Special') if schema['x-cli-special']
+            return [path, schema]
+          end
+          if schema['type'].eql?('object')
+            schema['properties']&.each do |name, props|
+              res = find_option(props, path + [name], option)
+              return res unless res.nil?
+            end
+          end
+          return
+        end
+
+        # Translate `async` native command line arguments to `conf` JSON
+        def args_to_conf(args)
+          result = {}
+          while args.any?
+            option = args.shift
+            if option =~ /^(--[^=]+)=(.*)$/
+              option = ::Regexp.last_match(1) # "--toto"
+              args.unshift(::Regexp.last_match(2))
+            end
+            if option.eql?('--preserve-time') || option.eql?('-t')
+              args.unshift('--preserve-creation-time') if Environment.instance.os.eql?(Environment::OS_WINDOWS)
+              option = '--preserve-modification-time'
+            end
+            if option.eql?('--remote') || option.eql?('-r')
+              value = args.first
+              if (m = SCP_REMOTE_REGEX.match(value))
+                if m[:host]
+                  args.shift
+                  args.unshift("--host=#{m[:host]}")
+                  args.unshift("--user=#{m[:user]}") if m[:user]
+                  args.unshift(m[:path])
+                end
+              end
+            end
+            path, props = find_option(CONF_SCHEMA, [], option)
+            raise "Option not found: #{option}" if path.nil?
+            last_key = path.pop
+            # navigate in the current result to insert the value
+            current = result
+            path.each do |key|
+              current[key] ||= {}
+              current = current[key]
+            end
+            current[last_key] = props['x-cli-switch'] ? true : args.shift
+          end
+          return result
+        end
       end
       # Private stuff:
       # Read JSON schema and mapping to command line options
-      ARGS_INSTANCE_SCHEMA = CommandLineBuilder.read_schema(__FILE__, 'args')
+      ARGS_INSTANCE_SCHEMA = CommandLineBuilder.read_schema(__dir__, 'args')
       ARGS_SESSION_SCHEMA = ARGS_INSTANCE_SCHEMA['properties']['sessions']['items']
       ARGS_INSTANCE_SCHEMA['properties'].delete('sessions')
-      CONF_SCHEMA = CommandLineBuilder.read_schema(__FILE__, 'conf')
-      CommandLineBuilder.validate_schema(ARGS_INSTANCE_SCHEMA)
-      CommandLineBuilder.validate_schema(ARGS_SESSION_SCHEMA)
-      CommandLineBuilder.validate_schema(CONF_SCHEMA)
+      CONF_SCHEMA = CommandLineBuilder.read_schema(__dir__, 'conf')
       CMDLINE_PARAMS_KEYS = %w[instance sessions].freeze
       ASYNC_ADMIN_EXECUTABLE = 'asyncadmin'
       PRIVATE_FOLDER = '.private-asp'

data/lib/aspera/transfer/parameters.rb

@@ -63,8 +63,7 @@ module Aspera
         @job_spec = job_spec
         Aspera.assert_type(@job_spec, Hash)
         @ascp_args = ascp_args.nil? ? [] : ascp_args
-        Aspera.assert_type(@ascp_args, Array){'ascp_args'}
-        Aspera.assert(@ascp_args.all?(String)){'all ascp arguments must be String'}
+        Aspera.assert_array_all(@ascp_args, String){'ascp_args'}
         @wss = wss
         @quiet = quiet
         @trusted_certs = trusted_certs.nil? ? [] : trusted_certs
@@ -208,8 +207,8 @@ module Aspera
           env_args[:args].unshift('-Y', Ascp::Installation.instance.path(:fallback_private_key))
           env_args[:args].unshift('-I', Ascp::Installation.instance.path(:fallback_certificate))
         end
-        # disable redis in client
-        env_args[:env]['ASPERA_TEST_REDIS_DISABLE'] = 'true'
+        # disable redis in client, only for ascp, this makes ascp4 fail
+        env_args[:env]['ASPERA_TEST_REDIS_DISABLE'] = 'true' if env_args[:name].eql?(:ascp)
         Log.log.debug{"ascp args: #{env_args}"}
         return env_args
       end

data/lib/aspera/transfer/spec.rb

@@ -22,7 +22,7 @@ module Aspera
       # fields for WSS
       WSS_FIELDS = %w[wss_enabled wss_port].freeze
       # all fields for transport
-      TRANSPORT_FIELDS = %w[remote_host remote_user ssh_port fasp_port].concat(WSS_FIELDS).freeze
+      TRANSPORT_FIELDS = (%w[remote_host] + AK_TSPEC_BASE.keys + WSS_FIELDS).freeze
       # reserved tag for Aspera
       TAG_RESERVED = 'aspera'
       class << self
@@ -49,8 +49,7 @@ module Aspera
           transfer_spec['resume_policy'] = POLICY_FIX[transfer_spec['resume_policy']] if transfer_spec.key?('resume_policy')
         end
       end
-      SCHEMA = CommandLineBuilder.read_schema(__FILE__, 'spec')
-      CommandLineBuilder.validate_schema(SCHEMA, ascp: true)
+      SCHEMA = CommandLineBuilder.read_schema(__dir__, 'spec', ascp: true)
       # define constants for enums of parameters: <parameter>_<enum>, e.g. CIPHER_AES_128, DIRECTION_SEND, ...
       SCHEMA['properties'].each do |name, description|
         next unless description['enum'].is_a?(Array)

data/lib/aspera/transfer/spec.schema.yaml

@@ -46,14 +46,22 @@ properties:
     x-cli-option: -c
     x-cli-convert: remove_hyphen
   content_protection:
-    description: Enable client-side encryption at rest (CSEAR).
+    description: >-
+      Enable client-side content protection (CSEAR, encryption-at-rest).
+
+      For uploads, set to `encrypt` to transfer encrypted files and store them
+      on the server with the extension `.aspera-env`.
+      (`aspera.conf` parameter `transfer_encryption_content_protection_extension`).
+      To download and decrypt encrypted files, set to `decrypt`
+
+      `content_protection_password` must be specified if this option is set.
     type: string
     enum:
       - encrypt
       - decrypt
     x-cli-option: --file-crypt
   content_protection_password:
-    description: Specifies CSEAR password.
+    description: Password for encryption/decryption of transferred assets.
     type: string
     x-cli-envvar: ASPERA_SCP_FILEPASS
   cookie:
@@ -61,7 +69,27 @@ properties:
     type: string
     x-cli-envvar: ASPERA_SCP_COOKIE
   create_dir:
-    description: Specifies whether to create new directories.
+    description: >-
+      Create target directory if it doesn't already exist.
+
+      If **all** the following conditions are met, then the `destination_root` specifies a filename instead of destination folder:
+
+      - `create_dir` is `false`
+
+      - A single source file is given on **command line**
+
+      - The target folder specified by `destination_root` does not exist
+
+      In all other cases, `destination_root` specifies a folder, and it is created if it does not already exist.
+      I.e. if **any** of those conditions is met:
+
+      - `create_dir` is `true`
+
+      - Multiple source files are provided
+
+      - List of source files are provided in a file (list or pair), default for Node API and `ascli`.
+
+      - The target folder exists
     type: boolean
     x-cli-option: -d
     x-cli-switch: true
@@ -91,6 +119,7 @@ properties:
     description: Destination root directory.
     type: string
     x-cli-special: true
+    $comment: Last argument on ascp command line.
   destination_root_id:
     description: >-
       The file ID of the destination root directory.
@@ -676,17 +705,6 @@ properties:
       - direct
       - transferd
     x-cli-option: -i
-  ssh_args:
-    $comment: "TODO: Generate multiple options and place as in comment (after -i , before user/host)"
-    description: >-
-      Add arguments to the command-line arguments passed to the external ssh program (implies -SSH).
-      The arguments are inserted before any key file(s) supplied to `ascp` and before the user/host arguments.
-    type: array
-    x-agents:
-      - direct
-      - transferd
-    x-cli-option: --ssh-arg
-    x-cli-special: true
   symlink_policy:
     description: Handle source side symbolic links.
     type: string
@@ -749,16 +767,28 @@ properties:
     x-cli-special: true
   use_system_ssh:
     description: >-
-      Use an external ssh program instead of the built-in libssh2 implementation to establish
+      Use an external `ssh` program instead of the built-in `libssh2` implementation to establish
       the connection to the remote host.
-      The desired ssh program must be in the environment's PATH.
+      The desired `ssh` program must be in the environment's `PATH`.
 
-      To enable debugging of the ssh process, supply `-DD` and `--ssh-arg=-vv` arguments to `ascp`.
-    type: string
+      To enable debugging of the `ssh` process, supply `-DD` and `--ssh-arg=-vv` arguments to `ascp`.
+    type: boolean
     x-agents:
       - direct
       - transferd
     x-cli-option: -SSH
+    x-cli-switch: true
+  ssh_args:
+    $comment: "TODO: Generate multiple options and place as in comment (after -i , before user/host)"
+    description: >-
+      Add arguments to the command-line arguments passed to the external ssh program (implies -SSH).
+      The arguments are inserted before any key file(s) supplied to `ascp` and before the user/host arguments.
+    type: array
+    x-agents:
+      - direct
+      - transferd
+    x-cli-option: --ssh-arg
+    x-cli-special: true
   keepalive:
     description: The session is running in persistent session mode.
     type: boolean
@@ -851,7 +881,7 @@ properties:
   xfer_max_retries:
     description: >-
       Maximum number of retries, for node API initiated transfers.
-      Shall not exceed aspera.conf `transfer_manager_max_retries` (default 5).
+      Shall not exceed `aspera.conf` parameter `transfer_manager_max_retries` (default 5).
     type: integer
     x-agents:
       - node

data/lib/aspera/transfer/spec_doc.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 require 'aspera/agent/factory'
+require 'aspera/markdown'
 
 module Aspera
   module Transfer
-    # translate transfer specification to ascp parameter list
+    # Generate documentation from Schema, for Transfer Spec, or async Conf spec
     class SpecDoc
       class << self
-        # first letter of agent name symbol
+        # First letter of agent name symbol
         def agent_to_short(agent_sym)
           agent_sym.to_sym.eql?(:direct) ? :a : agent_sym.to_s[0].to_sym
         end
 
-        # @param formatter      [Cli::Formatter] Formatter to use, methods: special_format, check_row
+        # @param formatter      [Cli::Formatter] Formatter to use, methods: markdown, tick, check_row
         # @param include_option [Boolean]        `true` : include CLI options
         # @param agent_columns  [Boolean]        `true` : include agents columns
         # @param schema         [Hash]           The JSON spec
@@ -23,23 +24,21 @@ module Aspera
           cols.insert(-2, *AGENT_LIST.map(&:last)) if agent_columns
           rows = []
           schema['properties'].each do |name, info|
-            if info['type'].eql?('object') && info['properties']
-              rows.concat(man_table(formatter, include_option: include_option, agent_columns: agent_columns, schema: info).last.map { |h| h.merge(name: "#{name}.#{h[:name]}") })
-            end
-            # manual table
+            rows.concat(man_table(formatter, include_option: include_option, agent_columns: agent_columns, schema: info).last.map{ |h| h.merge(name: "#{name}.#{h[:name]}")}) if info['type'].eql?('object') && info['properties']
+            rows.concat(man_table(formatter, include_option: include_option, agent_columns: agent_columns, schema: info['items']).last.map{ |h| h.merge(name: "#{name}[].#{h[:name]}")}) if info['type'].eql?('array') && info['items'] && info['items']['properties']
+            # Manual table
             columns = {
               name:        name,
               type:        info['type'],
               description: []
             }
-            # replace "back solidus" HTML entity with its text value, highlight keywords, and split lines
+            # Render Markdown formatting and split lines
             columns[:description] =
               info['description']
-                .gsub('&bsol;', '\\')
-                .gsub(/`([a-z0-9_.+-]+)`/){formatter.keyword_highlight(Regexp.last_match(1))}
+                .gsub(Markdown::FORMATS){formatter.markdown(Regexp.last_match)}
                 .split("\n") if info.key?('description')
             columns[:description].unshift("DEPRECATED: #{info['x-deprecation']}") if info.key?('x-deprecation')
-            # add flags for supported agents in doc
+            # Add flags for supported agents in doc
             agents = []
             AGENT_LIST.each do |agent_info|
               agents.push(agent_info.last) if info['x-agents'].nil? || info['x-agents'].include?(agent_info.first.to_s)
@@ -52,9 +51,9 @@ module Aspera
             else
               columns[:description].push("(#{agents.map(&:upcase).join(', ')})") unless agents.length.eql?(AGENT_LIST.length)
             end
-            # only keep lines that are usable in supported agents
+            # Only keep lines that are usable in supported agents
             next false if agents.empty?
-            columns[:description].push("Allowed values: #{info['enum'].map{ |v| formatter.keyword_highlight(v)}.join(', ')}") if info.key?('enum')
+            columns[:description].push("Allowed values: #{info['enum'].map{ |v| formatter.markdown("`#{v}`")}.join(', ')}") if info.key?('enum')
             if include_option
               envvar_prefix = ''
               cli_option =
@@ -70,7 +69,8 @@ module Aspera
                   sep = info['x-cli-option'].start_with?('--') ? '=' : ' '
                   "#{info['x-cli-option']}#{sep}#{"(#{conversion_tag})" if conversion_tag}#{arg_type}"
                 end
-              columns[:description].push("(#{'special:' if info['x-cli-special']}#{envvar_prefix}#{formatter.keyword_highlight(cli_option)})") if cli_option
+              short = info.key?('x-cli-short') ? "(#{info['x-cli-short']})" : nil
+              columns[:description].push("(#{'special:' if info['x-cli-special']}#{envvar_prefix}#{formatter.markdown("`#{cli_option}`")})#{short}") if cli_option
             end
             rows.push(formatter.check_row(columns))
           end

data/lib/aspera/uri_reader.rb

@@ -18,7 +18,7 @@ module Aspera
         uri = URI.parse(uri_to_read)
         case uri.scheme
         when 'http', 'https'
-          return Rest.new(base_url: uri_to_read, redirect_max: 5).call(operation: 'GET', headers: {'Accept' => '*/*'})[:data]
+          return Rest.new(base_url: uri_to_read, redirect_max: 5).read(nil, headers: {'Accept' => '*/*'})
         when SCHEME_FILE, NilClass
           local_file_path = uri.path
           raise Error, 'URL shall have a path, check syntax' if local_file_path.nil?