aspera-cli 4.23.0 → 4.24.1

data/lib/aspera/ascmd.rb

@@ -30,10 +30,16 @@ module Aspera
     # Description of result structures (see ascmdtypes.h).
     # Base types are big endian
     # key = name of type
-    # index in array `fields` is the type (minus ENUM_START)
+    # index in array `fields` is: the numerical type of TLV - `ENUM_START`. i.e. add `ENUM_START` to index, to get `T`
     # decoding always start at `result`
     # some fields have special handling indicated by `special`
     # field_list, list_tlv_list, list_tlv_restart are composed with a list of TLV
+    # decode:
+    # - :base : value
+    # - :buffer_list : an array of {btype,buffer}
+    # - :field_list : a hash, or array
+    # :check: ???
+    # rubocop:disable Layout/FirstHashElementLineBreak
     TYPES_DESCR = {
       result: {decode: :field_list,
                fields: [{name: :file, is_a: :stat}, {name: :dir, is_a: :stat, special: :list_tlv_list}, {name: :size, is_a: :size}, {name: :error, is_a: :error},
@@ -67,6 +73,7 @@ module Aspera
       zstr:   {decode: :base, unpack: 'Z*'},
       blist:  {decode: :buffer_list}
     }.freeze
+    # rubocop:enable Layout/FirstHashElementLineBreak
 
     private_constant :TYPES_DESCR, :ENUM_START, :OPS_ARGS
 
@@ -122,11 +129,11 @@ module Aspera
       stdin_input = command_lines.join("\n")
       Log.log.trace1{"execute_single:#{stdin_input}"}
       # execute, get binary output
-      byte_buffer = @command_executor.execute(remote_cmd, stdin_input).unpack('C*')
-      raise 'ERROR: empty answer from server' if byte_buffer.empty?
+      byte_buffer = @command_executor.execute(remote_cmd, input: stdin_input).unpack('C*')
+      Aspera.assert(!byte_buffer.empty?){'empty answer from server'}
       # get hash or table result
       result = self.class.parse(byte_buffer, :result)
-      raise 'ERROR: unparsed bytes remaining' unless byte_buffer.empty?
+      Aspera.assert(byte_buffer.empty?){'unparsed bytes remaining'}
       # get and delete info,always present in results
       system_info = result[:info]
       result.delete(:info)
@@ -137,7 +144,7 @@ module Aspera
         result[:dir].each do |file|
           if file.key?(:smode)
             # Converts the first character of the file mode (see 'man ls') into a type.
-            file[:type] = case file[:smode][0, 1]; when 'd' then:directory; when '-' then:file; when 'l' then:link; else; :other; end # rubocop:disable Style/Semicolon
+            file[:type] = case file[:smode][0, 1]; when 'd' then:directory; when '-' then:file; when 'l' then:link; else; :other; end
           end
         end
       end
@@ -153,27 +160,26 @@ module Aspera
       return result
     end
 
-    # This exception is raised when +ascmd+ returns an error.
+    # This exception is raised when `ascmd` returns an error.
     class Error < StandardError
-      def initialize(errno, errstr, cmd, arguments)
-        super(); @errno = errno; @errstr = errstr; @command = cmd; @arguments = arguments; end # rubocop:disable Style/Semicolon
-
+      # rubocop:disable Style/Semicolon
+      def initialize(errno, errstr, cmd, arguments); super(); @errno = errno; @errstr = errstr; @command = cmd; @arguments = arguments; end
       def message; "ascmd: #{@errstr} (#{@errno})"; end
       def extended_message; "ascmd: errno=#{@errno} errstr=\"#{@errstr}\" command=#{@command} arguments=#{@arguments&.join(',')}"; end
+      # rubocop:enable Style/Semicolon
     end
 
     class << self
-      # get description of structure's field, @param struct_name, @param typed_buffer provides field name
+      # Get description of structure's field, @param struct_name, @param typed_buffer provides field name
       def field_description(struct_name, typed_buffer)
         result = TYPES_DESCR[struct_name][:fields][typed_buffer[:btype] - ENUM_START]
         raise "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" if result.nil?
         return result
       end
 
-      # decodes the provided buffer as provided type name
-      # @return a decoded type.
-      # :base : value, :buffer_list : an array of {btype,buffer}, :field_list : a hash, or array
-      def parse(buffer, type_name, indent_level=nil)
+      # Decodes the provided buffer as provided type name
+      # @return a decoded type: single, Array, or Hash
+      def parse(buffer, type_name, indent_level = nil)
         indent_level = (indent_level || -1) + 1
         type_descr = TYPES_DESCR[type_name]
         raise "Unexpected type #{type_name}" if type_descr.nil?
@@ -182,7 +188,7 @@ module Aspera
         case type_descr[:decode]
         when :base
           num_bytes = type_name.eql?(:zstr) ? buffer.length : type_descr[:size]
-          raise 'ERROR:not enough bytes' if buffer.length < num_bytes
+          Aspera.assert(buffer.length >= num_bytes){'not enough bytes'}
           byte_array = buffer.shift(num_bytes)
           byte_array = [byte_array] unless byte_array.is_a?(Array)
           result = byte_array.pack('C*').unpack1(type_descr[:unpack])
@@ -195,7 +201,7 @@ module Aspera
           until buffer.empty?
             btype = parse(buffer, :int8, indent_level)
             length = parse(buffer, :int32, indent_level)
-            raise 'ERROR:not enough bytes' if buffer.length < length
+            Aspera.assert(buffer.length >= length){'not enough bytes'}
             value = buffer.shift(length)
             result.push({btype: btype, buffer: value})
             Log.log.trace1{"#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}"}

data/lib/aspera/ascp/installation.rb

@@ -44,12 +44,12 @@ module Aspera
         </default>
         </CONF>
       END_OF_CONFIG_FILE
-      # all ascp files (in SDK)
-      EXE_FILES = %i[ascp ascp4 async].freeze
-      FILES = %i[transferd ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
-      TRANSFER_SDK_LOCATION_URL = 'https://ibm.biz/sdk_location'
+      # all executable files from SDK
+      EXE_FILES = %i[ascp ascp4 async transferd].freeze
+      SDK_FILES = %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
+      TRANSFERD_ARCHIVE_LOCATION_URL = 'https://ibm.biz/sdk_location'
       # filename for ascp with optional extension (Windows)
-      private_constant :DEFAULT_ASPERA_CONF, :FILES, :TRANSFER_SDK_LOCATION_URL
+      private_constant :DEFAULT_ASPERA_CONF, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL
       # options for SSH client private key
       CLIENT_SSH_KEY_OPTIONS = %i{dsa_rsa rsa per_client}.freeze
 
@@ -99,7 +99,7 @@ module Aspera
 
       # @return [Hash] with key = file name (String), and value = path to file
       def file_paths
-        return FILES.each_with_object({}) do |v, m|
+        return SDK_FILES.each_with_object({}) do |v, m|
           m[v.to_s] =
             begin
               path(v)
@@ -115,19 +115,23 @@ module Aspera
         return Environment.write_file_restricted(File.join(Products::Transferd.sdk_directory, filename), force: force, mode: 0o644, &block)
       end
 
-      # get path of one resource file of currently activated product
+      # Get path of one resource file of currently activated product
       # keys and certs are generated locally... (they are well known values, arch. independent)
+      # @param k [Symbol] key of the resource file
+      # @return [String, nil] Full path to the resource file or nil if not found
       def path(k)
-        file_is_optional = false
+        file_is_required = true
         case k
         when *EXE_FILES
-          file_is_optional = k.eql?(:async)
-          use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?
-          # NOTE: that there might be a .exe at the end
-          file = @path_to_ascp.gsub('ascp', k.to_s)
-        when :transferd
-          file_is_optional = true
-          file = Products::Transferd.transferd_path
+          file_is_required = k.eql?(:ascp)
+          file = if k.eql?(:transferd)
+            Products::Transferd.transferd_path
+          else
+            # ensure at least ascp is found
+            use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?
+            # NOTE: that there might be a .exe at the end
+            @path_to_ascp.gsub('ascp', k.to_s)
+          end
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
           type = k.to_s[-3..-1].to_sym
@@ -150,8 +154,8 @@ module Aspera
           file = k.eql?(:fallback_certificate) ? file_cert : file_key
         else Aspera.error_unexpected_value(k)
         end
-        return nil if file_is_optional && !File.exist?(file)
-        Aspera.assert(File.exist?(file), exception_class: Errno::ENOENT){"#{k} not found (#{file})"}
+        return unless file_is_required || File.exist?(file)
+        Aspera.assert(File.exist?(file), type: Errno::ENOENT){"#{k} not found (#{file})"}
         return file
       end
 
@@ -168,7 +172,7 @@ module Aspera
                when :dsa_rsa, :rsa
                  types.to_s.split('_').map{ |i| Installation.instance.path("ssh_private_#{i}".to_sym)}
                when :per_client
-                 raise 'Not yet implemented'
+                 Aspera.error_not_implemented
                end
       end
 
@@ -179,8 +183,9 @@ module Aspera
 
       # Check that specified path is ascp and get version
       def get_exe_version(exe_path, vers_arg)
-        raise 'ERROR: nil arg' if exe_path.nil?
-        return nil unless File.exist?(exe_path)
+        Aspera.assert_type(exe_path, String)
+        Aspera.assert_type(vers_arg, String)
+        return unless File.exist?(exe_path)
         exe_version = nil
         cmd_out = %x("#{exe_path}" #{vers_arg})
         raise "An error occurred when testing #{exe_path}: #{cmd_out}" unless $CHILD_STATUS == 0
@@ -217,9 +222,7 @@ module Aspera
               data['ascp_version'] = Regexp.last_match(1)
             end
           end
-          if !thread.value.exitstatus.eql?(1) && !data.key?('root')
-            raise last_line
-          end
+          raise last_line if !thread.value.exitstatus.eql?(1) && !data.key?('root')
         end
         return data
       end
@@ -248,7 +251,7 @@ module Aspera
       # @return the url for download of SDK archive for the given platform and version
       def sdk_url_for_platform(platform: nil, version: nil)
         locations = sdk_locations
-        platform = Environment.architecture if platform.nil?
+        platform = Environment.instance.architecture if platform.nil?
         locations = locations.select{ |l| l['platform'].eql?(platform)}
         raise "No SDK for platform: #{platform}" if locations.empty?
         version = locations.max_by{ |entry| Gem::Version.new(entry['version'])}['version'] if version.nil?
@@ -259,7 +262,7 @@ module Aspera
 
       # @param &block called with entry information
       def extract_archive_files(sdk_archive_path)
-        raise 'missing block' unless block_given?
+        Aspera.assert(block_given?){'missing block'}
         case sdk_archive_path
         # Windows and Mac use zip
         when /\.zip$/
@@ -330,21 +333,15 @@ module Aspera
           end
         end
         return unless with_exe
-        # ensure license file are generated so that ascp invocation for version works
-        path(:aspera_license)
-        path(:aspera_conf)
-        sdk_ascp_file = Environment.exe_file('ascp')
-        sdk_ascp_path = File.join(folder, sdk_ascp_file)
-        raise "No #{sdk_ascp_file} found in SDK archive" unless File.exist?(sdk_ascp_path)
-        EXE_FILES.each do |exe_sym|
-          exe_path = sdk_ascp_path.gsub('ascp', exe_sym.to_s)
-          Environment.restrict_file_access(exe_path, mode: 0o755) if File.exist?(exe_path)
+        # ensure necessary files are there, or generate them
+        SDK_FILES.each do |file_id_sym|
+          file_path = path(file_id_sym)
+          if file_path && EXE_FILES.include?(file_id_sym)
+            Environment.restrict_file_access(file_path, mode: 0o755) if File.exist?(file_path)
+          end
         end
-        sdk_ascp_version = get_ascp_version(sdk_ascp_path)
-        transferd_exe_path = Products::Transferd.transferd_path
-        Log.log.warn{"No #{transferd_exe_path} in SDK archive"} unless File.exist?(transferd_exe_path)
-        Environment.restrict_file_access(transferd_exe_path, mode: 0o755) if File.exist?(transferd_exe_path)
-        transferd_version = get_exe_version(transferd_exe_path, 'version')
+        sdk_ascp_version = get_ascp_version(path(:ascp))
+        transferd_version = get_exe_version(path(:transferd), 'version')
         sdk_name = 'IBM Aspera Transfer SDK'
         sdk_version = transferd_version || sdk_ascp_version
         File.write(File.join(folder, Products::Other::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
@@ -362,7 +359,7 @@ module Aspera
         @path_to_ascp = nil
         @sdk_dir = nil
         @found_products = nil
-        @transferd_urls = TRANSFER_SDK_LOCATION_URL
+        @transferd_urls = TRANSFERD_ARCHIVE_LOCATION_URL
       end
 
       public

data/lib/aspera/ascp/management.rb

@@ -184,7 +184,8 @@ module Aspera
         ChunkSize
         PostTransferValidation
         OverwritePolicyCap
-        ExtraCreatePolicy]
+        ExtraCreatePolicy
+      ]
       # Management port start message
       MGT_HEADER = 'FASPMGR 2'
       # empty line is separator to end event information
@@ -252,17 +253,17 @@ module Aspera
           # begin event
           @event_build = {}
         when /^([^:]+): (.*)$/
-          raise 'mgt port: unexpected line: data without header' if @event_build.nil?
+          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: data without header'}
           # event field
           @event_build[Regexp.last_match(1)] = Regexp.last_match(2)
         when MGT_FRAME_SEPARATOR
-          raise 'mgt port: unexpected line: end frame without header' if @event_build.nil?
+          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: end frame without header'}
           @last_event = @event_build
           @event_build = nil
           return @last_event
         else Aspera.error_unexpected_value(line){'mgt port'}
         end
-        return nil
+        return
       end
     end
   end

data/lib/aspera/assert.rb

@@ -1,55 +1,86 @@
 # frozen_string_literal: true
 
 module Aspera
-  class InternalError < StandardError
+  # Generic error in gem
+  class Error < StandardError
   end
 
-  class AssertError < StandardError
+  # Error that shall not happen, else it's a bug
+  class InternalError < Error
+  end
+
+  # An expected condition was not met
+  class AssertError < Error
   end
   class << self
-    # the block is executed in the context of the Aspera module
-    def assert(assertion, info = nil, exception_class: AssertError)
+    # Replace `raise`, allows sending exception, or just error log, when type is `:error`
+    # @param type [Exception,Symbol] Send to log if symbol, else raise exception
+    # @param message [String] Message for error.
+    def report_error(type, message)
+      if type.is_a?(Symbol)
+        Log.log.send(type, message)
+      else
+        raise type, message
+      end
+    end
+
+    # Assert that a condition is true, else raise exception
+    # @param assertion [Bool]       Must be true
+    # @param info      [String,nil] Fixed message in case assert fails, else use `block`
+    # @param type      [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block     [Proc]       Produces a string that desribes the problem for complex messages
+    # The block is executed in the context of the Aspera module
+    def assert(assertion, info = nil, type: AssertError)
       raise InternalError, 'bad assert: both info and block given' unless info.nil? || !block_given?
       return if assertion
       message = 'assertion failed'
       info = yield if block_given?
       message = "#{message}: #{info}" if info
       message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
-      raise exception_class, message
+      report_error(type, message)
     end
 
-    # assert that value has the given type
-    # @param value [Object] the value to check
-    # @param type [Class] the expected type
-    def assert_type(value, type, exception_class: AssertError)
-      assert(value.is_a?(type), exception_class: exception_class){"#{"#{yield}: " if block_given?}expecting #{type}, but have #{value.inspect}"}
+    # Assert that value has the given type
+    # @param value   [Object]       The value to check
+    # @param classes [Class, Array] The expected type(s)
+    # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block   [Proc]         Additional description in front of message
+    def assert_type(value, *classes, type: AssertError)
+      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting #{classes.join(', ')}, but have #{value.inspect}"}
     end
 
-    # assert that value is one of the given values
-    # @param value value to check
-    # @param values accepted values
-    # @param exception_class exception in case of no match
-    def assert_values(value, values, exception_class: AssertError)
-      assert(values.include?(value), exception_class: exception_class) do
+    # Assert that value is one of the given values
+    # @param value  [any]   value to check
+    # @param values [Array] accepted values
+    # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block  [Proc]         Additional description in front of message
+    def assert_values(value, values, type: AssertError)
+      assert(values.include?(value), type: type) do
         val_list = values.inspect
         val_list = "one of #{val_list}" if values.is_a?(Array)
         "#{"#{yield}: " if block_given?}expecting #{val_list}, but have #{value.inspect}"
       end
     end
 
-    # the line with this shall never be reached
+    # The value is not one of the expected values
+    # @param value  [any]              The wrong value
+    # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block  [Proc]             Additional description in front of message
+    def error_unexpected_value(value, type: InternalError)
+      report_error(type, "#{"#{yield}: " if block_given?}unexpected value: #{value.inspect}")
+    end
+
+    # The line with this shall never be reached
     def error_unreachable_line
       raise InternalError, "unreachable line reached: #{caller(2..2).first}"
     end
 
-    # The value is not one of the expected values
-    # @param value the wrong value
-    # @param exception_class exception to raise
-    # @param block additional description in front
-    def error_unexpected_value(value, exception_class: InternalError)
-      raise exception_class, "#{"#{yield}: " if block_given?}unexpected value: #{value.inspect}"
+    # Not implemented error
+    def error_not_implemented
+      raise Error, 'Feature not yet implemented'
     end
 
+    # Use in superclass to require the given method in subclass.
     def require_method!(name)
       define_method(name) do |*_args|
         raise NotImplementedError, "#{self.class} must implement the #{name} method"

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -9,20 +9,20 @@ module Aspera
     class BasicAuthPlugin < Cli::Plugin
       class << self
         def declare_options(options)
-          options.declare(:url, 'URL of application, e.g. https://faspex.example.com/aspera/faspex')
-          options.declare(:username, "User's name to log in")
+          options.declare(:url, 'URL of application, e.g. https://app.example.com/aspera/app')
+          options.declare(:username, "User's identifier")
           options.declare(:password, "User's password")
           options.parse_options!
         end
       end
 
-      def initialize(basic_options: true, **env)
-        super(**env)
+      def initialize(context:, basic_options: true)
+        super(context: context)
         BasicAuthPlugin.declare_options(options) if basic_options
       end
 
       # returns a Rest object with basic auth
-      def basic_auth_params(subpath=nil)
+      def basic_auth_params(subpath = nil)
         api_url = options.get_option(:url, mandatory: true)
         api_url = "#{api_url}/#{subpath}" unless subpath.nil?
         return {
@@ -31,10 +31,11 @@ module Aspera
             type:     :basic,
             username: options.get_option(:username, mandatory: true),
             password: options.get_option(:password, mandatory: true)
-          }}
+          }
+        }
       end
 
-      def basic_auth_api(subpath=nil)
+      def basic_auth_api(subpath = nil)
         return Rest.new(**basic_auth_params(subpath))
       end
     end

data/lib/aspera/cli/error.rb

@@ -4,7 +4,7 @@ module Aspera
   module Cli
     # CLI base exception
     class Error < StandardError; end
-    # raised when an unexpected argument is provided
+    # Raised when an unexpected argument is provided.
     class BadArgument < Error; end
     class NoSuchElement < Error; end
 

data/lib/aspera/cli/extended_value.rb

@@ -41,12 +41,12 @@ module Aspera
               hash_array.push(col_titles.zip(values).to_h)
             end
           end
-          Log.log.warn('Titled CSV file without any line') if hash_array.empty?
+          Log.log.warn('Titled CSV file without any row') if hash_array.empty?
           return hash_array
         end
 
-        def assert_no_value(v, what)
-          raise "no value allowed for extended value type: #{what}" unless v.empty?
+        def assert_no_value(value, what)
+          raise "no value allowed for extended value type: #{what}" unless value.empty?
         end
       end
 
@@ -56,25 +56,25 @@ module Aspera
         # base handlers
         # other handlers can be set using set_handler, e.g. `preset` is reader in config plugin
         @handlers = {
-          val:    lambda{ |v| v},
-          base64: lambda{ |v| Base64.decode64(v)},
-          csvt:   lambda{ |v| ExtendedValue.decode_csvt(v)},
-          env:    lambda{ |v| ENV.fetch(v, nil)},
-          file:   lambda{ |v| File.read(File.expand_path(v))},
-          uri:    lambda{ |v| UriReader.read(v)},
-          json:   lambda{ |v| JSON_parse(v)},
-          lines:  lambda{ |v| v.split("\n")},
-          list:   lambda{ |v| v[1..-1].split(v[0])},
-          none:   lambda{ |v| ExtendedValue.assert_no_value(v, :none); nil}, # rubocop:disable Style/Semicolon
-          path:   lambda{ |v| File.expand_path(v)},
-          re:     lambda{ |v| Regexp.new(v, Regexp::MULTILINE)},
-          ruby:   lambda{ |v| Environment.secure_eval(v, __FILE__, __LINE__)},
-          secret: lambda{ |v| prompt = v.empty? ? 'secret' : v; $stdin.getpass("#{prompt}> ")}, # rubocop:disable Style/Semicolon
-          stdin:  lambda{ |v| ExtendedValue.assert_no_value(v, :stdin); $stdin.read}, # rubocop:disable Style/Semicolon
-          stdbin: lambda{ |v| ExtendedValue.assert_no_value(v, :stdbin); $stdin.binmode.read}, # rubocop:disable Style/Semicolon
-          yaml:   lambda{ |v| YAML.load(v)},
-          zlib:   lambda{ |v| Zlib::Inflate.inflate(v)},
-          extend: lambda{ |v| ExtendedValue.instance.evaluate_all(v)}
+          val:    lambda{ |i| i},
+          base64: lambda{ |i| Base64.decode64(i)},
+          csvt:   lambda{ |i| ExtendedValue.decode_csvt(i)},
+          env:    lambda{ |i| ENV.fetch(i, nil)},
+          file:   lambda{ |i| File.read(File.expand_path(i))},
+          uri:    lambda{ |i| UriReader.read(i)},
+          json:   lambda{ |i| JSON_parse(i)},
+          lines:  lambda{ |i| i.split("\n")},
+          list:   lambda{ |i| i[1..-1].split(i[0])},
+          none:   lambda{ |i| ExtendedValue.assert_no_value(i, :none); nil}, # rubocop:disable Style/Semicolon
+          path:   lambda{ |i| File.expand_path(i)},
+          re:     lambda{ |i| Regexp.new(i, Regexp::MULTILINE)},
+          ruby:   lambda{ |i| Environment.secure_eval(i, __FILE__, __LINE__)},
+          secret: lambda{ |i| prompt = i.empty? ? 'secret' : i; $stdin.getpass("#{prompt}> ")}, # rubocop:disable Style/Semicolon
+          stdin:  lambda{ |i| ExtendedValue.assert_no_value(i, :stdin); $stdin.read}, # rubocop:disable Style/Semicolon
+          stdbin: lambda{ |i| ExtendedValue.assert_no_value(i, :stdbin); $stdin.binmode.read}, # rubocop:disable Style/Semicolon
+          yaml:   lambda{ |i| YAML.load(i)},
+          zlib:   lambda{ |i| Zlib::Inflate.inflate(i)},
+          extend: lambda{ |i| ExtendedValue.instance.evaluate_all(i)}
         }
         @default_decoder = nil
       end
@@ -85,14 +85,15 @@ module Aspera
       end
 
       # JSON Parser, with more information on error location
-      def JSON_parse(v)
-        JSON.parse(v)
+      # :reek:UncommunicativeMethodName
+      def JSON_parse(value) # rubocop:disable Naming/MethodName
+        JSON.parse(value)
       rescue JSON::ParserError => e
         m = /at line (\d+) column (\d+)/.match(e.message)
         raise if m.nil?
         line = m[1].to_i - 1
         column = m[2].to_i - 1
-        lines = v.lines
+        lines = value.lines
         raise if line >= lines.size
         error_line = lines[line].chomp
         context_col_beg = [column - 10, 0].max
@@ -145,9 +146,7 @@ module Aspera
       # parse string value as extended value
       # use default decoder if none is specified
       def evaluate_with_default(value)
-        if value.is_a?(String) && value.match(/^#{handler_regex_string}.*$/).nil? && !@default_decoder.nil?
-          value = [MARKER_START, @default_decoder, MARKER_END, value].join
-        end
+        value = [MARKER_START, @default_decoder, MARKER_END, value].join if value.is_a?(String) && value.match(/^#{handler_regex_string}.*$/).nil? && !@default_decoder.nil?
         return evaluate(value)
       end
 
@@ -157,7 +156,7 @@ module Aspera
         while (m = value.match(regex))
           sub_value = "@#{m[2]}:#{m[3]}"
           Log.log.debug{"evaluating #{sub_value}"}
-          value = m[1] + evaluate(sub_value) + m[4]
+          value = "#{m[1]}#{evaluate(sub_value)}#{m[4]}"
         end
         return value
       end