aspera-cli 4.17.0 → 4.18.1

data/lib/aspera/api/node.rb

@@ -14,21 +14,28 @@ module Aspera
   module Api
     # Provides additional functions using node API with gen4 extensions (access keys)
     class Node < Aspera::Rest
-      # permissions
-      ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
+      SCOPE_SEPARATOR = ':'
+      SCOPE_NODE_PREFIX = 'node.'
       # prefix for ruby code for filter (deprecated)
       MATCH_EXEC_PREFIX = 'exec:'
       MATCH_TYPES = [String, Proc, Regexp, NilClass].freeze
+      SIGNATURE_DELIMITER = '==SIGNATURE=='
+      BEARER_TOKEN_VALIDITY_DEFAULT = 86400
+      # fields in @app_info
+      REQUIRED_APP_INFO_FIELDS = %i[api app node_info workspace_id workspace_name].freeze
+      # methods of @app_info[:api]
+      REQUIRED_APP_API_METHODS = %i[node_api_from add_ts_tags].freeze
+      private_constant :SCOPE_SEPARATOR, :SCOPE_NODE_PREFIX, :MATCH_EXEC_PREFIX, :MATCH_TYPES,
+        :SIGNATURE_DELIMITER, :BEARER_TOKEN_VALIDITY_DEFAULT,
+        :REQUIRED_APP_INFO_FIELDS, :REQUIRED_APP_API_METHODS
+
+      # node api permissions
+      ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
       HEADER_X_ASPERA_ACCESS_KEY = 'X-Aspera-AccessKey'
-      PATH_SEPARATOR = '/'
-      TS_FIELDS_TO_COPY = %w[remote_host remote_user ssh_port fasp_port wss_enabled wss_port].freeze
+      HEADER_X_TOTAL_COUNT = 'X-Total-Count'
       SCOPE_USER = 'user:all'
       SCOPE_ADMIN = 'admin:all'
-      SCOPE_PREFIX = 'node.'
-      SCOPE_SEPARATOR = ':'
-      SIGNATURE_DELIMITER = '==SIGNATURE=='
-      BEARER_TOKEN_VALIDITY_DEFAULT = 86400
-      BEARER_TOKEN_SCOPE_DEFAULT = SCOPE_USER
+      PATH_SEPARATOR = '/'
 
       # register node special token decoder
       OAuth::Factory.instance.register_decoder(lambda{|token|Node.decode_bearer_token(token)})
@@ -57,19 +64,19 @@ module Aspera
         end
 
         def file_matcher_from_argument(options)
-          return file_matcher(options.get_next_argument('filter', type: MATCH_TYPES, mandatory: false))
+          return file_matcher(options.get_next_argument('filter', validation: MATCH_TYPES, mandatory: false))
         end
 
         # node API scopes
         def token_scope(access_key, scope)
-          return [SCOPE_PREFIX, access_key, SCOPE_SEPARATOR, scope].join('')
+          return [SCOPE_NODE_PREFIX, access_key, SCOPE_SEPARATOR, scope].join('')
         end
 
         def decode_scope(scope)
           items = scope.split(SCOPE_SEPARATOR, 2)
           Aspera.assert(items.length.eql?(2)){"invalid scope: #{scope}"}
-          Aspera.assert(items[0].start_with?(SCOPE_PREFIX)){"invalid scope: #{scope}"}
-          return {access_key: items[0][SCOPE_PREFIX.length..-1], scope: items[1]}
+          Aspera.assert(items[0].start_with?(SCOPE_NODE_PREFIX)){"invalid scope: #{scope}"}
+          return {access_key: items[0][SCOPE_NODE_PREFIX.length..-1], scope: items[1]}
         end
 
         # Create an Aspera Node bearer token
@@ -84,7 +91,7 @@ module Aspera
           # manage convenience parameters
           expiration_sec = payload['_validity'] || BEARER_TOKEN_VALIDITY_DEFAULT
           payload.delete('_validity')
-          scope = payload['_scope'] || BEARER_TOKEN_SCOPE_DEFAULT
+          scope = payload['_scope'] || SCOPE_USER
           payload.delete('_scope')
           payload['scope'] ||= token_scope(access_key, scope)
           payload['auth_type'] ||= 'access_key'
@@ -115,25 +122,20 @@ module Aspera
         end
       end
 
-      # fields in @app_info
-      REQUIRED_APP_INFO_FIELDS = %i[api app node_info workspace_id workspace_name].freeze
-      # methods of @app_info[:api]
-      REQUIRED_APP_API_METHODS = %i[node_api_from add_ts_tags].freeze
-      private_constant :REQUIRED_APP_INFO_FIELDS, :REQUIRED_APP_API_METHODS
-
       attr_reader :app_info
 
+      # @param app_info  [Hash,NilClass]   Special processing for AoC
+      # @param add_tspec [Hash,NilClass]   Additional transfer spec
       # @param base_url  [String]          Rest parameters
       # @param auth      [String,NilClass] Rest parameters
       # @param headers   [String,NilClass] Rest parameters
-      # @param app_info  [Hash,NilClass]   Special processing for AoC
-      # @param add_tspec [Hash,NilClass]   Additional transfer spec
       def initialize(app_info: nil, add_tspec: nil, **rest_args)
         # init Rest
         super(**rest_args)
         @app_info = app_info
         # this is added to transfer spec, for instance to add tags (COS)
         @add_tspec = add_tspec
+        @std_t_spec_cache = nil
         if !@app_info.nil?
           REQUIRED_APP_INFO_FIELDS.each do |field|
             Aspera.assert(@app_info.key?(field)){"app_info lacks field #{field}"}
@@ -159,25 +161,42 @@ module Aspera
             workspace_id: @app_info[:workspace_id],
             workspace_name: @app_info[:workspace_name])
         end
-        Log.log.warn{"cannot resolve link with node id #{node_id}"}
+        Log.log.warn{"Cannot resolve link with node id #{node_id}, no resolver"}
         return nil
       end
 
+      # Check if a link entry in folder has target information
+      # @param entry [Hash] entry in folder
+      # @return [Boolean] true if target information is available
+      def entry_has_link_information(entry)
+        # if target information is missing in folder, try to get it on entry
+        if entry['target_node_id'].nil? || entry['target_id'].nil?
+          link_entry = read("files/#{entry['id']}")[:data]
+          entry['target_node_id'] = link_entry['target_node_id']
+          entry['target_id'] = link_entry['target_id']
+        end
+        return true unless entry['target_node_id'].nil? || entry['target_id'].nil?
+        Log.log.warn{"Missing target information for link: #{entry['name']}"}
+        return false
+      end
+
       # Recursively browse in a folder (with non-recursive method)
       # sub folders are processed if the processing method returns true
+      # links are processed on the respective node
       # @param state [Object] state object sent to processing method
       # @param top_file_id [String] file id to start at (default = access key root file id)
       # @param top_file_path [String] path of top folder (default = /)
       # @param block [Proc] processing method, arguments: entry, path, state
-      def process_folder_tree(state:, top_file_id:, top_file_path: '/', &block)
+      def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/')
         Aspera.assert(!top_file_path.nil?){'top_file_path not set'}
-        Aspera.assert(block){'Missing block'}
+        Log.log.debug{"process_folder_tree: node=#{@app_info ? @app_info[:node_info]['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}"}
         # start at top folder
         folders_to_explore = [{id: top_file_id, path: top_file_path}]
         Log.log.debug{Log.dump(:folders_to_explore, folders_to_explore)}
         until folders_to_explore.empty?
+          # consume first in job list
           current_item = folders_to_explore.shift
-          Log.log.debug{"searching #{current_item[:path]}".bg_green}
+          Log.log.debug{"Exploring #{current_item[:path]}".bg_green}
           # get folder content
           folder_contents =
             begin
@@ -189,23 +208,25 @@ module Aspera
           Log.log.debug{Log.dump(:folder_contents, folder_contents)}
           folder_contents.each do |entry|
             relative_path = File.join(current_item[:path], entry['name'])
-            Log.log.debug{"process_folder_tree checking #{relative_path}"}
-            # continue only if method returns true
-            next unless yield(entry, relative_path, state)
+            Log.log.debug{"process_folder_tree: checking #{relative_path}"}
+            # call block, continue only if method returns true
+            next unless send(method_sym, entry, relative_path, state)
             # entry type is file, folder or link
             case entry['type']
             when 'folder'
               folders_to_explore.push({id: entry['id'], path: relative_path})
             when 'link'
-              node_id_to_node(entry['target_node_id'])&.process_folder_tree(
-                state:         state,
-                top_file_id:   entry['target_id'],
-                top_file_path: relative_path,
-                &block)
+              if entry_has_link_information(entry)
+                node_id_to_node(entry['target_node_id'])&.process_folder_tree(
+                  method_sym:    method_sym,
+                  state:         state,
+                  top_file_id:   entry['target_id'],
+                  top_file_path: relative_path)
+              end
             end
           end
         end
-      end # process_folder_tree
+      end
 
       # Navigate the path from given file id
       # @param top_file_id [String] id initial file id
@@ -213,65 +234,44 @@ module Aspera
       # @return [Hash] {.api,.file_id}
       def resolve_api_fid(top_file_id, path)
         Aspera.assert_type(top_file_id, String)
+        Aspera.assert_type(path, String)
+        # if last element is a link and followed by "/", we list the content of that folder, else we return the link
         process_last_link = path.end_with?(PATH_SEPARATOR)
+        # keep only non-empty elements
         path_elements = path.split(PATH_SEPARATOR).reject(&:empty?)
         return {api: self, file_id: top_file_id} if path_elements.empty?
-        resolve_state = {path: path_elements, result: nil}
-        process_folder_tree(state: resolve_state, top_file_id: top_file_id) do |entry, _path, state|
-          # this block is called recursively for each entry in folder
-          # stop digging here if not in right path
-          next false unless entry['name'].eql?(state[:path].first)
-          # ok it matches, so we remove the match
-          state[:path].shift
-          case entry['type']
-          when 'file'
-            # file must be terminal
-            raise "#{entry['name']} is a file, expecting folder to find: #{state[:path]}" unless state[:path].empty?
-            # it's terminal, we found it
-            state[:result] = {api: self, file_id: entry['id']}
-            next false
-          when 'folder'
-            if state[:path].empty?
-              # we found it
-              state[:result] = {api: self, file_id: entry['id']}
-              next false
-            end
-          when 'link'
-            if state[:path].empty?
-              if process_last_link
-                # we found it
-                other_node = node_id_to_node(entry['target_node_id'])
-                raise 'cannot resolve link' if other_node.nil?
-                state[:result] = {api: other_node, file_id: entry['target_id']}
-              else
-                # we found it but we do not process the link
-                state[:result] = {api: self, file_id: entry['id']}
-              end
-              next false
-            end
-          else
-            Log.log.warn{"Unknown element type: #{entry['type']}"}
-          end
-          # continue to dig folder
-          next true
-        end
+        resolve_state = {path: path_elements, result: nil, process_last_link: process_last_link}
+        process_folder_tree(method_sym: :process_api_fid, state: resolve_state, top_file_id: top_file_id)
         raise "entry not found: #{resolve_state[:path]}" if resolve_state[:result].nil?
+        Log.log.debug{"resolve_api_fid: #{path} -> #{resolve_state[:result][:api].base_url} #{resolve_state[:result][:file_id]}"}
         return resolve_state[:result]
       end
 
       def find_files(top_file_id, test_block)
         Log.log.debug{"find_files: file id=#{top_file_id}"}
         find_state = {found: [], test_block: test_block}
-        process_folder_tree(state: find_state, top_file_id: top_file_id) do |entry, path, state|
-          state[:found].push(entry.merge({'path' => path})) if state[:test_block].call(entry)
-          # test all files deeply
-          true
-        end
+        process_folder_tree(method_sym: :process_find_files, state: find_state, top_file_id: top_file_id)
         return find_state[:found]
       end
 
       def refreshed_transfer_token
-        return oauth_token(force_refresh: true)
+        return oauth.token(refresh: true)
+      end
+
+      # @return part of transfer spec with transport parameters only
+      def transport_params
+        if @std_t_spec_cache.nil?
+          # retrieve values from API (and keep a copy/cache)
+          full_spec = create(
+            'files/download_setup',
+            {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
+          )[:data]['transfer_specs'].first['transfer_spec']
+          # set available fields
+          @std_t_spec_cache = Transfer::Spec::TRANSPORT_FIELDS.each_with_object({}) do |i, h|
+            h[i] = full_spec[i] if full_spec.key?(i)
+          end
+        end
+        return @std_t_spec_cache
       end
 
       # Create transfer spec for gen4
@@ -285,9 +285,9 @@ module Aspera
           ak_token = Rest.basic_token(auth_params[:username], auth_params[:password])
         when :oauth2
           ak_name = params[:headers][HEADER_X_ASPERA_ACCESS_KEY]
-          # TODO: token_generation_lambda = lambda{|do_refresh|oauth_token(force_refresh: do_refresh)}
+          # TODO: token_generation_lambda = lambda{|do_refresh|oauth.token(refresh: do_refresh)}
           # get bearer token, possibly use cache
-          ak_token = oauth_token(force_refresh: false)
+          ak_token = oauth.token
         else Aspera.error_unexpected_value(auth_params[:type])
         end
         transfer_spec = {
@@ -327,18 +327,64 @@ module Aspera
             transfer_spec[i] = settings[i] if settings.key?(i)
           end if settings.is_a?(Hash)
         else
-          # retrieve values from API (and keep a copy/cache)
-          @std_t_spec_cache ||= create(
-            'files/download_setup',
-            {transfer_requests: [{ transfer_request: {paths: [{'source' => '/'}] } }] }
-          )[:data]['transfer_specs'].first['transfer_spec']
-          # copy some parts
-          TS_FIELDS_TO_COPY.each {|i| transfer_spec[i] = @std_t_spec_cache[i] if @std_t_spec_cache.key?(i)}
+          transfer_spec.merge!(transport_params)
         end
         Log.log.warn{"Expected transfer user: #{Transfer::Spec::ACCESS_KEY_TRANSFER_USER}, but have #{transfer_spec['remote_user']}"} \
           unless transfer_spec['remote_user'].eql?(Transfer::Spec::ACCESS_KEY_TRANSFER_USER)
         return transfer_spec
       end
+
+      private
+
+      def process_api_fid(entry, path, state)
+        # this block is called recursively for each entry in folder
+        # stop digging here if not in right path
+        return false unless entry['name'].eql?(state[:path].first)
+        # ok it matches, so we remove the match, and continue digging
+        state[:path].shift
+        path_fully_consumed = state[:path].empty?
+        case entry['type']
+        when 'file'
+          # file must be terminal
+          raise "#{entry['name']} is a file, expecting folder to find: #{state[:path]}" unless path_fully_consumed
+          # it's terminal, we found it
+          Log.log.debug{"resolve_api_fid: found #{path} -> #{entry['id']}"}
+          state[:result] = {api: self, file_id: entry['id']}
+          return false
+        when 'folder'
+          if path_fully_consumed
+            # we found it
+            state[:result] = {api: self, file_id: entry['id']}
+            return false
+          end
+        when 'link'
+          if path_fully_consumed
+            if state[:process_last_link]
+              # we found it
+              other_node = nil
+              if entry_has_link_information(entry)
+                other_node = node_id_to_node(entry['target_node_id'])
+              end
+              raise 'Cannot resolve link' if other_node.nil?
+              state[:result] = {api: other_node, file_id: entry['target_id']}
+            else
+              # we found it but we do not process the link
+              state[:result] = {api: self, file_id: entry['id']}
+            end
+            return false
+          end
+        else
+          Log.log.warn{"Unknown element type: #{entry['type']}"}
+        end
+        # continue to dig folder
+        return true
+      end
+
+      def process_find_files(entry, _path, state)
+        state[:found].push(entry.merge({'path' => path})) if state[:test_block].call(entry)
+        # test all files deeply
+        return true
+      end
     end
   end
 end

data/lib/aspera/ascmd.rb

@@ -22,6 +22,7 @@ module Aspera
       mv:     2,
       rm:     1
     }.freeze
+    private_constant :OPS_ARGS
     # list of supported actions
     OPERATIONS = OPS_ARGS.keys.freeze
 
@@ -94,7 +95,7 @@ module Aspera
       raise Error.new(result[:errno], result[:errstr], action_sym, arguments) if
         result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map{|i|i[:name]}.sort)
       return result
-    end # execute_single
+    end
 
     # This exception is raised when +ascmd+ returns an error.
     class Error < StandardError
@@ -103,7 +104,7 @@ module Aspera
 
       def message; "ascmd: #{@errstr} (#{@errno})"; end
       def extended_message; "ascmd: errno=#{@errno} errstr=\"#{@errstr}\" command=#{@command} arguments=#{@arguments&.join(',')}"; end
-    end # Error
+    end
 
     # description of result structures (see ascmdtypes.h). Base types are big endian
     # key = name of type
@@ -211,7 +212,7 @@ module Aspera
             end
           end
         else Aspera.error_unexpected_value(type_descr[:decode])
-        end # is_a
+        end
         return result
       end
     end

data/lib/aspera/ascp/installation.rb

@@ -173,8 +173,7 @@ module Aspera
         return exe_version
       end
 
-      def ascp_info
-        data = file_paths
+      def ascp_add_pvcl(data)
         # read PATHs from ascp directly, and pvcl modules as well
         Open3.popen3(data['ascp'], '-DDL-') do |_stdin, _stdout, stderr, thread|
           last_line = ''
@@ -202,15 +201,24 @@ module Aspera
             raise last_line
           end
         end
-        # ascp's openssl directory
+      end
+
+      # extract some stings from ascp binary
+      def ascp_add_openssl(data)
         ascp_file = data['ascp']
-        File.binread(ascp_file).scan(/[\x20-\x7E]{4,}/) do |match|
-          if (m = match.match(/OPENSSLDIR.*"(.*)"/))
+        File.binread(ascp_file).scan(/[\x20-\x7E]{10,}/) do |bin_string|
+          if (m = bin_string.match(/OPENSSLDIR.*"(.*)"/))
             data['openssldir'] = m[1]
+          elsif (m = bin_string.match(/OpenSSL (\d[^ -]+)/))
+            data['openssl_version'] = m[1]
           end
         end if File.file?(ascp_file)
-        # log is "-" no need to display
-        data.delete('log')
+      end
+
+      def ascp_info
+        data = file_paths
+        ascp_add_pvcl(data)
+        ascp_add_openssl(data)
         return data
       end
 

data/lib/aspera/ascp/management.rb

@@ -209,7 +209,7 @@ module Aspera
             h[new_name] = value
           end
         end
-      end # class << self
+      end
 
       def initialize
         # current event being parsed line by line
@@ -236,7 +236,7 @@ module Aspera
           return @last_event
         else
           raise "mgt port: unexpected line: [#{line}]"
-        end # case
+        end
         return nil
       end
     end

data/lib/aspera/ascp/products.rb

@@ -44,7 +44,7 @@ module Aspera
               app_root: File.join('C:', 'Program Files', 'Aspera', 'Enterprise Server'),
               log_root: File.join('C:', 'Program Files', 'Aspera', 'Enterprise Server', 'var', 'log')
             }]
-            when Aspera::Environment::OS_X then [{
+            when Aspera::Environment::OS_MACOS then [{
               expected: CONNECT,
               app_root: File.join(Dir.home, 'Applications', 'Aspera Connect.app'),
               log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Connect'),

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -8,10 +8,7 @@ module Aspera
     # base class for applications supporting basic authentication
     class BasicAuthPlugin < Cli::Plugin
       class << self
-        #@@basic_options_declared = false # rubocop:disable Style/ClassVars
-        def declare_options(options) # , force: false
-          #return if @@basic_options_declared && !force
-          #@@basic_options_declared = true # rubocop:disable Style/ClassVars
+        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(:password, "User's password")
@@ -21,14 +18,13 @@ module Aspera
 
       def initialize(basic_options: true, **env)
         super(**env)
-        # , force: env[:all_manuals]
         BasicAuthPlugin.declare_options(options) if basic_options
       end
 
       # returns a Rest object with basic auth
       def basic_auth_params(subpath=nil)
         api_url = options.get_option(:url, mandatory: true)
-        api_url = api_url + '/' + subpath unless subpath.nil?
+        api_url = "#{api_url}/#{subpath}" unless subpath.nil?
         return {
           base_url: api_url,
           auth:     {
@@ -41,6 +37,6 @@ module Aspera
       def basic_auth_api(subpath=nil)
         return Rest.new(**basic_auth_params(subpath))
       end
-    end # BasicAuthPlugin
-  end # Cli
-end # Aspera
+    end
+  end
+end

data/lib/aspera/cli/extended_value.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# cspell:ignore csvt jsonpp
+# cspell:ignore csvt jsonpp stdbin
 require 'aspera/uri_reader'
 require 'aspera/environment'
 require 'aspera/log'
@@ -17,10 +17,9 @@ module Aspera
     class ExtendedValue
       include Singleton
 
-      # special values
-      INIT = 'INIT'
-      ALL = 'ALL'
-      DEF = 'DEF'
+      MARKER_START = '@'
+      MARKER_END = ':'
+      MARKER_IN_END = '@'
 
       class << self
         # decode comma separated table text
@@ -61,18 +60,31 @@ module Aspera
           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)},
+          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, :stdin); $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)}
         }
+        @default_decoder = nil
+      end
+
+      # Regex to match an extended value
+      def handler_regex_string
+        "#{MARKER_START}(#{modifiers.join('|')})#{MARKER_END}"
       end
 
       public
 
+      def default_decoder=(value)
+        Log.log.debug{"setting default decoder to #{value} (#{value.class})"}
+        Aspera.assert(value.nil? || @handlers.key?(value))
+        @default_decoder = value
+      end
+
       def modifiers; @handlers.keys; end
 
       # add a new handler
@@ -82,16 +94,13 @@ module Aspera
         @handlers[name] = method
       end
 
-      # Regex to match an extended value
-      def ext_re
-        "@(#{modifiers.join('|')}):"
-      end
-
-      # parse an option value if it is a String using supported extended value modifiers
+      # parse an string value to extended value, if it is a String using supported extended value modifiers
       # other value types are returned as is
+      # @param value [String] the value to parse
+      # @param expect [Class,Array] one or a list of expected types
       def evaluate(value)
         return value unless value.is_a?(String)
-        regex = Regexp.new("^#{ext_re}(.*)$")
+        regex = Regexp.new("^#{handler_regex_string}(.*)$", Regexp::MULTILINE)
         # first determine decoders, in reversed order
         handlers_reversed = []
         while (m = value.match(regex))
@@ -101,18 +110,28 @@ module Aspera
           # stop processing if handler is extend (it will be processed later)
           break if handler.eql?(:extend)
         end
+        Log.log.trace1{"evaluating: #{handlers_reversed}, value: #{value}"}
         handlers_reversed.each do |handler|
           value = @handlers[handler].call(value)
         end
         return value
-      end # evaluate
+      end
+
+      # 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
+        return evaluate(value)
+      end
 
       # find inner extended values
       def evaluate_all(value)
-        regex = Regexp.new("^(.*)#{ext_re}([^@]*)@(.*)$")
+        regex = Regexp.new("^(.*)#{handler_regex_string}([^#{MARKER_IN_END}]*)#{MARKER_IN_END}(.*)$", Regexp::MULTILINE)
         while (m = value.match(regex))
           sub_value = "@#{m[2]}:#{m[3]}"
-          Log.log.debug("evaluating #{sub_value}")
+          Log.log.debug{"evaluating #{sub_value}"}
           value = m[1] + evaluate(sub_value) + m[4]
         end
         return value