aspera-cli 4.27.0 → 4.27.2

data/lib/aspera/assert.rb

@@ -34,9 +34,9 @@ module Aspera
     end
 
     # Assert that a condition is true, else raise exception
-    # @param assertion [TrueClass, FalseClass]       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 assertion [Boolean] 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 level
     # @yieldreturn [String] A string that describes the problem for complex messages
     # The block is executed in the context of the Aspera module
     def assert(assertion, info = nil, type: AssertError)
@@ -45,7 +45,6 @@ module Aspera
       message = 'assertion failed'
       info = yield if block_given?
       message = type.eql?(AssertError) ? "#{message}: #{info}" : info if info
-      # message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
       report_error(type, message)
     end
 
@@ -55,7 +54,7 @@ module Aspera
     # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_type(value, *classes, type: AssertError)
-      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting type #{classes.join(', ')}, but have (#{value.class})#{value.inspect}"}
+      assert(classes.any? { |k| value.is_a?(k) }, type: type) { "#{"#{yield}: " if block_given?}expecting type #{classes.join(', ')}, but have (#{value.class})#{value.inspect}" }
     end
 
     # Assert that all value of array are of the same specified type.
@@ -64,20 +63,20 @@ module Aspera
     # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_array_all(array, klass, type: AssertError)
-      assert_type(array, Array, type: AssertError){'array'}
-      assert(array.all?(klass), type: type){"#{"#{yield}: " if block_given?}expecting all as #{klass}, but have #{array.map(&:class).uniq}"}
+      assert_type(array, Array, type: AssertError) { 'array' }
+      assert(array.all?(klass), type: type) { "#{"#{yield}: " if block_given?}expecting all as #{klass}, but have #{array.map(&:class).uniq}" }
     end
 
     # Assert value is Hash, keys have type, and Values have type
     # @param hash        [Hash]             The hash to check
-    # @param key_class   [Class]            The expected type of keys (or nil)
-    # @param value_class [Class]            The expected type of values (or nil)
+    # @param key_class   [Class]            The expected type of keys (or nil for no check)
+    # @param value_class [Class]            The expected type of values (or nil for no check)
     # @param type        [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_hash_all(hash, key_class, value_class, type: AssertError)
-      assert_type(hash, Hash, type: AssertError){'hash'}
-      assert_array_all(hash.keys, key_class, type: type){"#{"#{yield}: " if block_given?}keys"} unless key_class.nil?
-      assert_array_all(hash.values, value_class, type: type){"#{"#{yield}: " if block_given?}values"} unless value_class.nil?
+      assert_type(hash, Hash, type: AssertError) { 'hash' }
+      assert_array_all(hash.keys, key_class, type: type) { "#{"#{yield}: " if block_given?}keys" } unless key_class.nil?
+      assert_array_all(hash.values, value_class, type: type) { "#{"#{yield}: " if block_given?}values" } unless value_class.nil?
     end
 
     # Assert that value is one of the given values
@@ -86,7 +85,7 @@ module Aspera
     # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_values(value, values, type: AssertError)
-      assert_type(values, Array, type: AssertError){'values'}
+      assert_type(values, Array, type: AssertError) { 'values' }
       assert(values.include?(value), type: type) do
         val_list = values.inspect
         val_list = "one of #{val_list}" if values.is_a?(Array)

data/lib/aspera/cli/ascp_actions.rb

@@ -27,14 +27,14 @@ module Aspera
           @sdk_default_location = true
           Log.log.debug('SDK folder is not set, checking default')
           sdk_dir = self.class.default_app_main_folder(app_name: TRANSFERD_APP_NAME)
-          Log.log.debug{"Checking: #{sdk_dir}"}
+          Log.log.debug { "Checking: #{sdk_dir}" }
           if !Dir.exist?(sdk_dir)
-            Log.log.debug{"No such folder: #{sdk_dir}"}
+            Log.log.debug { "No such folder: #{sdk_dir}" }
             former_sdk_folder = File.join(self.class.default_app_main_folder(app_name: Info::CMD_NAME), TRANSFERD_APP_NAME)
-            Log.log.debug{"Checking: #{former_sdk_folder}"}
+            Log.log.debug { "Checking: #{former_sdk_folder}" }
             sdk_dir = former_sdk_folder if Dir.exist?(former_sdk_folder)
           end
-          Log.log.debug{"Using: #{sdk_dir}"}
+          Log.log.debug { "Using: #{sdk_dir}" }
           Products::Transferd.sdk_directory = sdk_dir
         end
       end
@@ -59,7 +59,7 @@ module Aspera
       def action_ascp_info(**)
         data = Ascp::Installation.instance.ascp_info
         data['ts'] = transfer.user_transfer_spec
-        DataRepository::ELEMENTS.each_with_object(data){ |i, h| h[i.to_s] = DataRepository.instance.item(i)}
+        DataRepository::ELEMENTS.each_with_object(data) { |i, h| h[i.to_s] = DataRepository.instance.item(i) }
         SecretHider::ADDITIONAL_KEYS_TO_HIDE.concat(DataRepository::ELEMENTS.map(&:to_s))
         Result::SingleObject.new(data)
       end
@@ -75,7 +75,7 @@ module Aspera
 
       def action_ascp_schema(agent_name: nil, **)
         schema = Transfer::Spec::SCHEMA.current.merge({'$comment'=>'DO NOT EDIT, this file was generated from the YAML.'})
-        schema['properties'] = schema['properties'].select{ |_k, v| CommandLineBuilder.supported_by_agent(agent_name, v)} unless agent_name.nil?
+        schema['properties'] = schema['properties'].select { |_k, v| CommandLineBuilder.supported_by_agent(agent_name, v) } unless agent_name.nil?
         schema['properties'] = schema['properties'].sort.to_h
         Result::SingleObject.new(schema)
       end
@@ -106,7 +106,7 @@ module Aspera
             'short'      => names[:short].to_s,
             'parameters' => param_names
           }
-        end.sort_by{ |r| r['name']}
+        end.sort_by { |r| r['name'] }
         Result::ObjectList.new(rows, fields: %w[name short parameters])
       end
 

data/lib/aspera/cli/async_transfer_store.rb

@@ -27,18 +27,46 @@ module Aspera
       CATEGORY = 'async_transfer_'
       private_constant :CATEGORY
 
+      # Class-level registry of in-process agent references, keyed by job_id.
+      # Shared across all AsyncTransferStore instances within the same Ruby process,
+      # so that a reference registered in one Runner call is visible in the next
+      # (e.g. MCP server mode where each tool call creates a fresh Runner/Context).
+      # Never persisted to disk.
+      @agent_refs = {}
+      class << self
+        attr_reader :agent_refs
+      end
+
       # @param persistency [PersistencyFolder]
       def initialize(persistency)
         @persistency = persistency
       end
 
+      # Register an in-process agent reference for a job.
+      # Called by TransferAgent immediately after start_transfer (async mode).
+      # The reference is only available while the same Ruby process is alive.
+      # @param job_id    [String] the ascli-generated UUID
+      # @param agent_ref [Object] live agent instance (responds to sessions_by_job)
+      def register_agent_ref(job_id, agent_ref)
+        self.class.agent_refs[job_id] = agent_ref
+      end
+
+      # Retrieve a previously registered in-process agent reference.
+      # @param job_id [String]
+      # @return [Object, nil] the live agent instance, or nil if not registered / process restarted
+      def agent_ref(job_id)
+        self.class.agent_refs[job_id]
+      end
+
       # Persist (create or update) an async transfer entry.
+      # Keys whose name starts with '_' are in-process references (e.g. '_agent_ref')
+      # and are intentionally excluded from the JSON serialization — at every nesting level.
       # @param job_id [String] the ascli-generated UUID
       # @param data   [Hash]   fields to store (will be JSON-serialised)
       def write(job_id, data)
-        Aspera.assert_type(job_id, String){'job_id'}
-        Aspera.assert_type(data, Hash){'data'}
-        @persistency.put(store_key(job_id), JSON.generate(data))
+        Aspera.assert_type(job_id, String) { 'job_id' }
+        Aspera.assert_type(data, Hash) { 'data' }
+        @persistency.put(store_key(job_id), JSON.generate(strip_internal_keys(data)))
         nil
       end
 
@@ -46,7 +74,7 @@ module Aspera
       # @param job_id [String]
       # @return [Hash, nil] the stored data, or nil if not found
       def read(job_id)
-        Aspera.assert_type(job_id, String){'job_id'}
+        Aspera.assert_type(job_id, String) { 'job_id' }
         raw = @persistency.get(store_key(job_id))
         return if raw.nil?
         JSON.parse(raw)
@@ -65,7 +93,7 @@ module Aspera
       # Delete one entry.
       # @param job_id [String]
       def delete(job_id)
-        Aspera.assert_type(job_id, String){'job_id'}
+        Aspera.assert_type(job_id, String) { 'job_id' }
         @persistency.delete(store_key(job_id))
         nil
       end
@@ -76,6 +104,22 @@ module Aspera
       def store_key(job_id)
         "#{CATEGORY}#{job_id}"
       end
+
+      # Recursively remove keys whose name starts with '_' from a Hash.
+      # Such keys hold in-process Ruby object references (e.g. '_agent_ref') that
+      # cannot be serialized to JSON and must never reach the file system.
+      def strip_internal_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(k, v), h|
+            h[k] = strip_internal_keys(v) unless k.to_s.start_with?('_')
+          end
+        when Array
+          value.map { |v| strip_internal_keys(v) }
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/aspera/cli/bootstrapper.rb

@@ -66,7 +66,7 @@ module Aspera
 
       # @param context [Context] the shared context to populate
       def initialize(context)
-        Aspera.assert_type(context, Context){'context'}
+        Aspera.assert_type(context, Context) { 'context' }
         @context = context
         @pac_exec = nil
       end
@@ -101,7 +101,7 @@ module Aspera
           default: default_app_main_folder(app_name: Info::CMD_NAME)
         )
         @context.options.parse_options!
-        Log.log.debug{"#{Info::CMD_NAME} folder: #{@context.main_folder}"}
+        Log.log.debug { "#{Info::CMD_NAME} folder: #{@context.main_folder}" }
       end
 
       # context.persistency + plugin lookup folders
@@ -130,20 +130,20 @@ module Aspera
         @context.options.declare(:vault_password, description: 'Vault password')
         # Register @preset and @vault handlers BEFORE parse_options! so that
         # values like --secret=@preset:name are correctly evaluated at parse time.
-        ExtendedValue.instance.on(EXTEND_PRESET){ |v| @context.presets.by_name(v)}
+        ExtendedValue.instance.on(EXTEND_PRESET) { |v| @context.presets.by_name(v) }
         ExtendedValue.instance.on(EXTEND_VAULT, &vault_value_cb)
         @context.options.parse_options!
         # Load global config default preset (equivalent of add_plugin_default_preset(:config))
         default_config_name = @context.presets.plugin_default_name(CONF_GLOBAL_SYM)
         unless default_config_name.nil?
-          Log.log.debug{"add_plugin_default_preset:#{CONF_GLOBAL_SYM}:#{default_config_name}"}
+          Log.log.debug { "add_plugin_default_preset:#{CONF_GLOBAL_SYM}:#{default_config_name}" }
           @context.options.add_option_preset(@context.presets.by_name(default_config_name), 'default_plugin', override: false)
         end
       end
 
       # Declare + parse :progress_bar: sets context.progress_bar
       def setup_progress_bar
-        @context.options.declare(:progress_bar, description: 'Display progress bar', allowed: Allowed::TYPES_BOOLEAN, default: Environment.terminal?)
+        @context.options.declare(:progress_bar, description: 'Display progress bar', allowed: Type::BOOLEAN, default: Environment.terminal?)
         @context.options.parse_options!
         @context.progress_bar = TransferProgress.new if @context.options.get_option(:progress_bar)
       end
@@ -159,7 +159,7 @@ module Aspera
         @context.pac_executor = ProxyAutoConfig.new(pac_script).register_uri_generic
         proxy_user_pass = @context.options.get_option(:proxy_credentials)
         if proxy_user_pass
-          Aspera.assert(proxy_user_pass.length.eql?(2), type: Cli::BadArgument){"proxy_credentials shall have two elements (#{proxy_user_pass.length})"}
+          Aspera.assert(proxy_user_pass.length.eql?(2), type: Cli::BadArgument) { "proxy_credentials shall have two elements (#{proxy_user_pass.length})" }
           @context.pac_executor.proxy_user = proxy_user_pass[0]
           @context.pac_executor.proxy_pass = proxy_user_pass[1]
         end
@@ -171,8 +171,8 @@ module Aspera
       def setup_rest_and_transfer_runtime
         RestParameters.instance.user_agent    = Info::CMD_NAME
         RestParameters.instance.progress_bar  = @context.progress_bar
-        RestParameters.instance.session_cb    = ->(http_session){@context.http_config.update_session(http_session)}
-        RestParameters.instance.spinner_cb    = ->(title = nil, action: :spin){@context.formatter.long_operation(title, action: action)}
+        RestParameters.instance.session_cb    = ->(http_session) { @context.http_config.update_session(http_session) }
+        RestParameters.instance.spinner_cb    = ->(title = nil, action: :spin) { @context.formatter.long_operation(title, action: action) }
         OAuth::Web.additional_info = "#{Info::CMD_NAME} v#{Cli::VERSION}"
         Transfer::Parameters.file_list_folder = File.join(@context.main_folder, FILE_LIST_FOLDER_NAME)
         RestErrorAnalyzer.instance.log_file   = File.join(@context.main_folder, REST_EXCEPTIONS_LOG_FILENAME)
@@ -182,7 +182,7 @@ module Aspera
       # @return [String] ~/.aspera
       def module_family_folder
         user_home_folder = Dir.home
-        Aspera.assert(Dir.exist?(user_home_folder), type: Cli::Error){"Home folder does not exist: #{user_home_folder}. Check your user environment."}
+        Aspera.assert(Dir.exist?(user_home_folder), type: Cli::Error) { "Home folder does not exist: #{user_home_folder}. Check your user environment." }
         File.join(user_home_folder, ASPERA_HOME_FOLDER_NAME)
       end
 

data/lib/aspera/cli/command_registry.rb

@@ -118,7 +118,7 @@ module Aspera
           # Rule: leaf commands with no explicit action must have a matching instance method
           next if spec.action # explicit action: skip
           next if @children_index[path]&.any? # intermediate node: skip
-          next if spec.delegates_to || spec.entity_execute # delegated: skip
+          next if spec.delegates_to # delegated: skip
           next unless plugin_class
           implicit_method = CommandSpec.action_method(path)
           unless plugin_class.method_defined?(implicit_method) || plugin_class.private_method_defined?(implicit_method)

data/lib/aspera/cli/command_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/schema/registry'
+
 module Aspera
   module Cli
     # Declares a positional argument consumed by a command.
@@ -14,7 +16,10 @@ module Aspera
     # @!attribute default     [Object, nil]               Default value when mandatory: false and no argument provided
     # @!attribute schema      [String, nil]               JSON schema name for validation and --help introspection
     # @!attribute bulk        [Boolean]                   When true, wraps read+loop for bulk mode (Array if --bulk yes)
-    # @!attribute lookup      [Symbol, nil]               Instance method name for percent-selector resolution (only used when type: :identifier)
+    # @!attribute lookup      [Symbol, Proc, nil]         Percent-selector resolver (only used when type: :identifier).
+    #                                                     Symbol → resolved via send(lookup, field, value, **ctx).
+    #                                                     Proc/lambda → called via instance_exec(field, value, **ctx, &lookup).
+    #                                                     Style: use Symbol for named methods; ->(){} for 1-liners; lambda do…end for 2–3 statements.
     # @!attribute allowed     [Array<Symbol>, nil]        Allowed Symbol values; when set, type is forced to Symbol and accept_list is applied
     # @!attribute interactive [Boolean]                   When true, sets ask_missing_mandatory before resolving so interactive prompting is triggered when no CLI args are provided
     ArgumentSpec = Struct.new(
@@ -81,7 +86,6 @@ module Aspera
     # @!attribute delegates_to     [Symbol, Array<Symbol>, nil]  Re-enter the command tree at this path
     # @!attribute delegate_instance [Symbol, nil]                Instance method returning a different plugin object
     # @!attribute aliases          [Array<Symbol>, nil] Alternative names accepted for this command (each resolves to this command's id)
-    # @!attribute entity_execute   [Hash, nil]                   Shorthand: expand to Base#entity_execute with these parameters
     # @!attribute transfer_paths   [:send, :receive, nil]        File-list resolution delegated to TransferAgent; mutually exclusive with arguments
     # @!attribute condition        [Symbol, nil]                 Instance method returning Boolean; if false command is hidden from dispatch
     # @!attribute query_schema     [String, nil]                 Schema path for --query help; when set, the runner hints `--query=help`
@@ -96,7 +100,6 @@ module Aspera
       :delegates_to,
       :delegate_instance,
       :aliases,
-      :entity_execute,
       :transfer_paths,
       :condition,
       :query_schema,

data/lib/aspera/cli/context.rb

@@ -40,7 +40,7 @@ module Aspera
       # Initialize all members to nil, so that they are defined and can be validated later
       # @return [nil]
       def initialize
-        MEMBERS.each{ |i| instance_variable_set(:"@#{i}", nil)}
+        MEMBERS.each { |i| instance_variable_set(:"@#{i}", nil) }
         @progress_bar = nil
         @pac_executor = nil
       end
@@ -50,8 +50,8 @@ module Aspera
       # @return [nil]
       def validate
         MEMBERS.each do |i|
-          Aspera.assert(instance_variable_defined?(:"@#{i}")){"context member @#{i} is not defined"}
-          Aspera.assert(!instance_variable_get(:"@#{i}").nil?){"context member @#{i} is nil"}
+          Aspera.assert(instance_variable_defined?(:"@#{i}")) { "context member @#{i} is not defined" }
+          Aspera.assert(!instance_variable_get(:"@#{i}").nil?) { "context member @#{i} is nil" }
         end
       end
 

data/lib/aspera/cli/extended_value.rb

@@ -68,7 +68,7 @@ module Aspera
         # @param value [String] The value as parameter
         # @param ext_type [Symbol] The method of extended value
         def assert_no_value(value, ext_type)
-          Aspera.assert(value.empty?, type: BadArgument){"no value allowed for extended value type: #{ext_type}"}
+          Aspera.assert(value.empty?, type: BadArgument) { "no value allowed for extended value type: #{ext_type}" }
         end
 
         def read_stdin(mode)
@@ -89,25 +89,25 @@ module Aspera
         # e.g. `preset` is reader in config plugin
         # @type [Hash{Symbol => Proc}]
         @handlers = {
-          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| ExtendedValue.JSON_parse(i)},
-          lines:  lambda{ |i| i.split("\n")},
-          list:   lambda{ |i| i[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__)},
+          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| ExtendedValue.JSON_parse(i) },
+          lines:  lambda { |i| i.split("\n") },
+          list:   lambda { |i| i[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__) },
           s:      lambda(&:to_s),
-          secret: lambda{ |i| prompt = i.empty? ? 'secret' : i; $stdin.getpass("#{prompt}> ")}, # rubocop:disable Style/Semicolon
-          stdin:  lambda{ |i| ExtendedValue.read_stdin(i)},
-          yaml:   lambda{ |i| YAML.safe_load(i)},
-          zlib:   lambda{ |i| Zlib::Inflate.inflate(i)},
-          extend: lambda{ |i| ExtendedValue.instance.evaluate_extend(i)}
+          secret: lambda { |i| prompt = i.empty? ? 'secret' : i; $stdin.getpass("#{prompt}> ") }, # rubocop:disable Style/Semicolon
+          stdin:  lambda { |i| ExtendedValue.read_stdin(i) },
+          yaml:   lambda { |i| YAML.safe_load(i) },
+          zlib:   lambda { |i| Zlib::Inflate.inflate(i) },
+          extend: lambda { |i| ExtendedValue.instance.evaluate_extend(i) }
         }
         @regex_single = nil
         @regex_extend = nil
@@ -127,7 +127,7 @@ module Aspera
       attr_reader :default_decoder
 
       def default_decoder=(value)
-        Log.log.debug{"Setting default decoder to (#{value.class}) #{value}"}
+        Log.log.debug { "Setting default decoder to (#{value.class}) #{value}" }
         Aspera.assert_values(value, DEFAULT_DECODERS)
         value = nil if value.eql?(:none)
         @default_decoder = value
@@ -138,9 +138,9 @@ module Aspera
 
       # Add a new handler
       def on(name, &block)
-        Aspera.assert_type(name, Symbol){'name'}
-        Aspera.assert(block){"block required when registering handler for #{name}"}
-        Log.log.debug{"Setting handler for #{name}"}
+        Aspera.assert_type(name, Symbol) { 'name' }
+        Aspera.assert(block) { "block required when registering handler for #{name}" }
+        Log.log.debug { "Setting handler for #{name}" }
         @handlers[name] = block
         update_regex
       end
@@ -156,7 +156,7 @@ module Aspera
         return value unless value.is_a?(String)
         Aspera.assert_array_all(allowed, Class) unless allowed.nil?
         # use default decoder if not an extended value and expect complex types
-        using_default_decoder = allowed&.all?{ |t| DEFAULT_PARSER_TYPES.include?(t)} && !@regex_single.match?(value) && !@default_decoder.nil?
+        using_default_decoder = allowed&.all? { |t| DEFAULT_PARSER_TYPES.include?(t) } && !@regex_single.match?(value) && !@default_decoder.nil?
         value = [MARKER_START, @default_decoder, MARKER_END, value].join if using_default_decoder
         # First determine decoders, in reversed order
         handlers_reversed = []
@@ -166,7 +166,7 @@ module Aspera
           value = m[2]
           break if SPECIAL_HANDLERS.include?(handler)
         end
-        Log.log.trace1{"evaluating: #{handlers_reversed}, value: #{value}"}
+        Log.log.trace1 { "evaluating: #{handlers_reversed}, value: #{value.class}:#{value}" }
         handlers_reversed.each do |handler|
           value = @handlers[handler].call(value)
         rescue => e
@@ -180,7 +180,7 @@ module Aspera
       def evaluate_extend(value)
         while (m = value.match(@regex_extend))
           sub_value = "@#{m[2]}:#{m[3]}"
-          Log.log.debug{"evaluating #{sub_value}"}
+          Log.log.debug { "evaluating #{sub_value}" }
           value = "#{m[1]}#{evaluate(sub_value, context: 'composite extended value')}#{m[4]}"
         end
         return value