aspera-cli 4.24.2 → 4.25.0

data/lib/aspera/ascp/installation.rb

@@ -33,25 +33,12 @@ module Aspera
     class Installation
       include Singleton
 
-      DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
-        <?xml version='1.0' encoding='UTF-8'?>
-        <CONF version="2">
-        <default>
-            <file_system>
-                <resume_suffix>.aspera-ckpt</resume_suffix>
-                <partial_file_suffix>.partial</partial_file_suffix>
-            </file_system>
-        </default>
-        </CONF>
-      END_OF_CONFIG_FILE
-      # 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, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL
       # options for SSH client private key
       CLIENT_SSH_KEY_OPTIONS = %i{dsa_rsa rsa per_client}.freeze
+      # prefix
+      USE_PRODUCT_PREFIX = 'product:'
+      # policy for product selection
+      FIRST_FOUND = 'FIRST'
 
       # Loads YAML from cloud with locations of SDK archives for all platforms
       # @return location structure
@@ -66,12 +53,13 @@ module Aspera
         end
       end
 
-      # set ascp executable path
+      # set ascp executable "location"
       def ascp_path=(v)
         Aspera.assert_type(v, String)
-        Aspera.assert(!v.empty?){'ascp path cannot be empty: check your config file'}
-        Aspera.assert(File.exist?(v)){"No such file: [#{v}]"}
-        @path_to_ascp = v
+        Aspera.assert(!v.empty?){'ascp location cannot be empty: check your config file'}
+        @ascp_location = v
+        @ascp_path = nil
+        return
       end
 
       def ascp_path
@@ -93,8 +81,7 @@ module Aspera
           pl = installed_products.find{ |i| i[:name].eql?(product_name)}
           raise "No such product installed: #{product_name}" if pl.nil?
         end
-        self.ascp_path = pl[:ascp_path]
-        Log.log.debug{"ascp_path=#{@path_to_ascp}"}
+        @ascp_path = pl[:ascp_path]
       end
 
       # @return [Hash] with key = file name (String), and value = path to file
@@ -111,7 +98,9 @@ module Aspera
         end
       end
 
+      # TODO: if using another product than SDK, should use files from there
       def check_or_create_sdk_file(filename, force: false, &block)
+        FileUtils.mkdir_p(Products::Transferd.sdk_directory)
         return Environment.write_file_restricted(File.join(Products::Transferd.sdk_directory, filename), force: force, mode: 0o644, &block)
       end
 
@@ -127,10 +116,18 @@ module Aspera
           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?
+            # find ascp when needed
+            if @ascp_path.nil?
+              if @ascp_location.start_with?(USE_PRODUCT_PREFIX)
+                use_ascp_from_product(@ascp_location[USE_PRODUCT_PREFIX.length..-1])
+              else
+                @ascp_path = @ascp_location
+              end
+              Aspera.assert(File.exist?(@ascp_path)){"No such file: [#{@ascp_path}]"}
+              Log.log.debug{"ascp_path=#{@ascp_path}"}
+            end
             # NOTE: that there might be a .exe at the end
-            @path_to_ascp.gsub('ascp', k.to_s)
+            @ascp_path.gsub('ascp', k.to_s)
           end
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
@@ -195,7 +192,9 @@ module Aspera
         return exe_version
       end
 
-      def ascp_pvcl_info
+      # Extract some stings from ascp logs
+      # Folder, PVCL, version, license information
+      def ascp_info_from_log
         data = {}
         # read PATHs from ascp directly, and pvcl modules as well
         Open3.popen3(ascp_path, '-DDL-') do |_stdin, _stdout, stderr, thread|
@@ -227,8 +226,9 @@ module Aspera
         return data
       end
 
-      # extract some stings from ascp binary
-      def ascp_ssl_info
+      # Extract some stings from ascp binary
+      # Openssl information
+      def ascp_info_from_file
         data = {}
         File.binread(ascp_path).scan(/[\x20-\x7E]{10,}/) do |bin_string|
           if (m = bin_string.match(/OPENSSLDIR.*"(.*)"/))
@@ -243,17 +243,17 @@ module Aspera
       # information for `ascp info`
       def ascp_info
         ascp_data = file_paths
-        ascp_data.merge!(ascp_pvcl_info)
-        ascp_data.merge!(ascp_ssl_info)
+        ascp_data.merge!(ascp_info_from_log)
+        ascp_data.merge!(ascp_info_from_file)
         return ascp_data
       end
 
       # @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
+        all_locations = sdk_locations
         platform = Environment.instance.architecture if platform.nil?
-        locations = locations.select{ |l| l['platform'].eql?(platform)}
-        raise "No SDK for platform: #{platform}" if locations.empty?
+        locations = all_locations.select{ |l| l['platform'].eql?(platform)}
+        raise "No SDK for platform: #{platform}, available: #{all_locations.map{ |i| i['platform']}.uniq}" if locations.empty?
         version = locations.max_by{ |entry| Gem::Version.new(entry['version'])}['version'] if version.nil?
         info = locations.select{ |entry| entry['version'].eql?(version)}
         raise "No such version: #{version} for #{platform}" if info.empty?
@@ -294,12 +294,12 @@ module Aspera
       end
 
       # Retrieves ascp binary for current system architecture from URL or file
-      # @param url      [String] URL to SDK archive, or SpecialValues::DEF
-      # @param folder   [String] Destination folder path
-      # @param backup   [Bool]   If destination folder exists, then rename
-      # @param with_exe [Bool]   If false, only retrieves files, but do not generate or restrict access
-      # @param &block   [Proc]   A lambda that receives a file path from archive and tells destination sub folder(end with /) or file, or nil to not extract
-      # @return ascp version (from execution)
+      # @param url      [String]  URL to SDK archive, or SpecialValues::DEF
+      # @param folder   [String]  Destination folder path
+      # @param backup   [Boolean] If destination folder exists, then rename
+      # @param with_exe [Boolean] If false, only retrieves files, but do not generate or restrict access
+      # @param &block   [Proc]    A lambda that receives a file path from archive and tells destination sub folder(end with /) or file, or nil to not extract
+      # @return [Array] name, ascp version (from execution), folder
       def install_sdk(url: nil, version: nil, folder: nil, backup: true, with_exe: true, &block)
         url = sdk_url_for_platform(version: version) if url.nil? || url.eql?('DEF')
         folder = Products::Transferd.sdk_directory if folder.nil?
@@ -348,20 +348,34 @@ module Aspera
         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>")
-        return sdk_name, sdk_version
+        return sdk_name, sdk_version, folder
       end
 
       attr_accessor :transferd_urls
 
       private
 
-      # policy for product selection
-      FIRST_FOUND = 'FIRST'
-
-      private_constant :FIRST_FOUND
+      DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
+        <?xml version='1.0' encoding='UTF-8'?>
+        <CONF version="2">
+        <default>
+            <file_system>
+                <resume_suffix>.aspera-ckpt</resume_suffix>
+                <partial_file_suffix>.partial</partial_file_suffix>
+            </file_system>
+        </default>
+        </CONF>
+      END_OF_CONFIG_FILE
+      # 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, :EXE_FILES, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL
 
       def initialize
-        @path_to_ascp = nil
+        @ascp_path = nil
+        @ascp_location = nil
         @sdk_dir = nil
         @found_products = nil
         @transferd_urls = TRANSFERD_ARCHIVE_LOCATION_URL

data/lib/aspera/ascp/management.rb

@@ -5,8 +5,12 @@ require 'aspera/assert'
 module Aspera
   module Ascp
     # processing of ascp management port events
+    # Reference: `mgmtmess.c`
     class Management
-      # from https://www.google.com/search?q=FASP+error+codes
+      # References:
+      # https://www.google.com/search?q=FASP+error+codes
+      # https://www.ibm.com/support/pages/error-code-reference-tables
+      # mgmtmess.c : as_mgmt_err_is_retryable
       # Note that the fact that an error is retry-able is not internally defined by protocol, it's client-side responsibility
       # rubocop:disable Layout/FirstHashElementLineBreak
       ERRORS = {
@@ -289,7 +293,7 @@ module Aspera
       # cspell: enable
 
       class << self
-        # translate native event name to snake case
+        # Translate native event name to snake case
         def field_native_to_snake(name)
           case name
           when 'Elapsedusec' then 'elapsed_usec'
@@ -298,7 +302,7 @@ module Aspera
           end
         end
 
-        # translate snake case event name to native
+        # Translate snake case event name to native
         # @param name [String] Field name
         def field_snake_to_native(name)
           field = name.delete('_')
@@ -320,7 +324,7 @@ module Aspera
         end
 
         # Build command to send on management port
-        # @param data [Hash] e.g. {'type'=>'START','source'=>_path_,'destination'=>_path_}
+        # @param data [Hash] keys are snake case: e.g. {'type'=>'START','source'=>_path_,'destination'=>_path_}
         # @return [String] frame to send on management port
         def command_to_stream(data)
           data
@@ -339,7 +343,7 @@ module Aspera
       end
       attr_reader :last_event
 
-      # process line of mgt port event
+      # Process line of mgt port event
       # @param line [String] line of mgt port event
       # @return [Hash] event hash or nil if event is not yet complete
       def process_line(line)

data/lib/aspera/assert.rb

@@ -31,7 +31,7 @@ module Aspera
     end
 
     # Assert that a condition is true, else raise exception
-    # @param assertion [Bool]       Must be true
+    # @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 block     [Proc]       Produces a string that describes the problem for complex messages
@@ -41,8 +41,8 @@ module Aspera
       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__)}}"
+      message = type.eql?(AssertError) ? "#{message}: #{info}" : info if info
+      # message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
       report_error(type, message)
     end
 
@@ -52,11 +52,33 @@ module Aspera
     # @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}"}
+      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting #{classes.join(', ')}, but have (#{value.class})#{value.inspect}"}
+    end
+
+    # Assert that all value of array are of the same specified type
+    # @param array   [Array]            The array to check
+    # @param klass   [Class]            The expected type of elements
+    # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block   [Proc]             Additional description in front of message
+    def assert_array_all(array, klass, type: AssertError)
+      assert_type(array, Array, type: type)
+      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 type        [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block       [Proc]             Additional description in front of message
+    def assert_hash_all(hash, key_class, value_class, type: AssertError)
+      assert_type(hash, Hash, type: type)
+      assert_array_all(hash.keys, key_class, type: AssertError){"#{"#{yield}: " if block_given?}keys"} unless key_class.nil?
+      assert_array_all(hash.values, value_class, type: AssertError){"#{"#{yield}: " if block_given?}values"} unless value_class.nil?
     end
 
     # Assert that value is one of the given values
-    # @param value  [any]              Value to check
+    # @param value  [Object]           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
@@ -69,7 +91,7 @@ module Aspera
     end
 
     # The value is not one of the expected values
-    # @param value  [any]              The wrong value
+    # @param value  [Object]           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)

data/lib/aspera/cli/error.rb

@@ -6,11 +6,13 @@ module Aspera
     class Error < StandardError; end
     # Raised when an unexpected argument is provided.
     class BadArgument < Error; end
+    class MissingArgument < Error; end
     class NoSuchElement < Error; end
 
     class BadIdentifier < Error
-      def initialize(res_type, res_id)
-        super("#{res_type} with identifier #{res_id} not found")
+      def initialize(res_type, res_id, field: 'identifier', count: 0)
+        msg = count.eql?(0) ? 'not found' : "found #{count}"
+        super("#{res_type} with #{field}=#{res_id}: #{msg}")
       end
     end
   end

data/lib/aspera/cli/extended_value.rb

@@ -17,16 +17,8 @@ module Aspera
     class ExtendedValue
       include Singleton
 
-      MARKER_START = '@'
-      MARKER_END = ':'
-      MARKER_IN_END = '@'
-
-      # Special handlers stop processing of handlers on right
-      # :extend includes processing of other handlers in itself
-      # :val keeps the value intact
-      SPECIAL_HANDLERS = %i[extend val].freeze
-
-      private_constant :MARKER_START, :MARKER_END, :MARKER_IN_END, :SPECIAL_HANDLERS
+      # First is default
+      DEFAULT_DECODERS = %i[none json ruby yaml]
 
       class << self
         # Decode comma separated table text
@@ -45,8 +37,41 @@ module Aspera
           return hash_array
         end
 
-        def assert_no_value(value, what)
-          raise "no value allowed for extended value type: #{what}" unless value.empty?
+        # JSON Parser, with more information on error location
+        # extract a context: 10 chars before and after the error on the given line and display a pointer "^"
+        # :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 = value.lines
+          raise if line >= lines.size
+          error_line = lines[line].chomp
+          context_col_beg = [column - 10, 0].max
+          context_col_end = [column + 10, error_line.length].min
+          context = error_line[context_col_beg...context_col_end]
+          cursor_pos = column - context_col_beg
+          pointer = ' ' * cursor_pos + '^'.blink
+          raise BadArgument, "#{e.message}\n#{context}\n#{pointer}"
+        end
+
+        # The value must be empty
+        # @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}"}
+        end
+
+        def read_stdin(mode)
+          case mode
+          when '' then $stdin.read
+          when 'bin' then $stdin.binmode.read
+          when 'chomp' then $stdin.chomp
+          else raise BadArgument, "`stdin` supports only: '', 'bin' or 'chomp'"
+          end
         end
       end
 
@@ -54,7 +79,8 @@ module Aspera
 
       def initialize
         # Base handlers
-        # Other handlers can be set using set_handler, e.g. `preset` is reader in config plugin
+        # Other handlers can be set using `on`
+        # e.g. `preset` is reader in config plugin
         @handlers = {
           val:    lambda{ |i| i},
           base64: lambda{ |i| Base64.decode64(i)},
@@ -62,7 +88,7 @@ module Aspera
           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)},
+          json:   lambda{ |i| ExtendedValue.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
@@ -70,67 +96,63 @@ module Aspera
           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
+          stdin:  lambda{ |i| ExtendedValue.read_stdin(i)},
           yaml:   lambda{ |i| YAML.load(i)},
           zlib:   lambda{ |i| Zlib::Inflate.inflate(i)},
-          extend: lambda{ |i| ExtendedValue.instance.evaluate_all(i)}
+          extend: lambda{ |i| ExtendedValue.instance.evaluate_extend(i)}
         }
+        @regex_single = nil
+        @regex_extend = nil
         @default_decoder = nil
+        update_regex
       end
 
-      # Regex to match an extended value
-      def handler_regex_string
-        "#{MARKER_START}(#{modifiers.join('|')})#{MARKER_END}"
-      end
-
-      # JSON Parser, with more information on error location
-      # :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 = value.lines
-        raise if line >= lines.size
-        error_line = lines[line].chomp
-        context_col_beg = [column - 10, 0].max
-        context_col_end = [column + 10, error_line.length].min
-        context = error_line[context_col_beg...context_col_end]
-        cursor_pos = column - context_col_beg
-        pointer = ' ' * cursor_pos + '^'.blink
-        raise BadArgument, "#{e.message}\n#{context}\n#{pointer}"
+      # Update the Regex to match an extended value based on @handlers
+      def update_regex
+        handler_regex = "#{MARKER_START}(#{modifiers.join('|')})#{MARKER_END}"
+        @regex_single = Regexp.new("^#{handler_regex}(.*)$", Regexp::MULTILINE)
+        @regex_extend = Regexp.new("^(.*)#{handler_regex}([^#{MARKER_IN_END}]*)#{MARKER_IN_END}(.*)$", Regexp::MULTILINE)
       end
 
       public
 
+      attr_reader :default_decoder
+
       def default_decoder=(value)
         Log.log.debug{"Setting default decoder to (#{value.class}) #{value}"}
-        Aspera.assert(value.nil? || @handlers.key?(value))
+        Aspera.assert_values(value, DEFAULT_DECODERS)
+        value = nil if value.eql?(:none)
         @default_decoder = value
       end
 
+      # List of Extended Value methods
       def modifiers; @handlers.keys; end
 
       # Add a new handler
-      def set_handler(name, method)
-        Log.log.debug{"setting handler for #{name}"}
+      def on(name, &block)
         Aspera.assert_type(name, Symbol){'name'}
-        @handlers[name] = method
+        Aspera.assert(block)
+        Log.log.debug{"Setting handler for #{name}"}
+        @handlers[name] = block
+        update_regex
       end
 
-      # 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)
+      # Parses a `String` value to extended value.
+      # If it is a String using supported extended value modifiers, then evaluate them.
+      # Other value types are returned as is.
+      # @param value   [String] the value to parse
+      # @param context [String] Context in which evaluation is done
+      # @param allowed [Array<Class>,NilClass] Expected types
+      # @return [Object] Evaluated value
+      def evaluate(value, context:, allowed: nil)
         return value unless value.is_a?(String)
-        regex = Regexp.new("^#{handler_regex_string}(.*)$", Regexp::MULTILINE)
+        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?
+        value = [MARKER_START, @default_decoder, MARKER_END, value].join if using_default_decoder
         # First determine decoders, in reversed order
         handlers_reversed = []
-        while (m = value.match(regex))
+        while (m = value.match(@regex_single))
           handler = m[1].to_sym
           handlers_reversed.unshift(handler)
           value = m[2]
@@ -139,27 +161,37 @@ module Aspera
         Log.log.trace1{"evaluating: #{handlers_reversed}, value: #{value}"}
         handlers_reversed.each do |handler|
           value = @handlers[handler].call(value)
+        rescue => e
+          raise BadArgument, "Evaluation of #{handler} for #{context}: #{e.message}"
         end
         return value
       end
 
-      # Parse string value as extended value
-      # Use default decoder if none is specified
-      def evaluate_with_default(value)
-        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
-
       # Find inner extended values
-      def evaluate_all(value)
-        regex = Regexp.new("^(.*)#{handler_regex_string}([^#{MARKER_IN_END}]*)#{MARKER_IN_END}(.*)$", Regexp::MULTILINE)
-        while (m = value.match(regex))
+      # Only used in above lambda
+      def evaluate_extend(value)
+        while (m = value.match(@regex_extend))
           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, context: 'composite extended value')}#{m[4]}"
         end
         return value
       end
+      # marker "@"
+      MARKER_START = '@'
+      # marker ":"
+      MARKER_END = ':'
+      # marker "@"
+      MARKER_IN_END = '@'
+
+      # Special handlers stop processing of handlers on right
+      # :extend includes processing of other handlers in itself
+      # :val keeps the value intact
+      SPECIAL_HANDLERS = %i[extend val].freeze
+
+      # Array and Hash types:
+      DEFAULT_PARSER_TYPES = [Array, Hash].freeze
+      private_constant :MARKER_START, :MARKER_END, :MARKER_IN_END, :SPECIAL_HANDLERS, :DEFAULT_PARSER_TYPES
     end
   end
 end