aspera-cli 4.5.0 → 4.8.0

data/lib/aspera/cli/transfer_agent.rb

@@ -1,4 +1,6 @@
-require 'aspera/fasp/parameters'
+# frozen_string_literal: true
+
+require 'aspera/fasp/transfer_spec'
 require 'aspera/cli/listener/logger'
 require 'aspera/cli/listener/progress_multi'
 
@@ -9,42 +11,42 @@ module Aspera
     # provides CLI options to select one of the transfer agents (FASP/ascp client)
     class TransferAgent
       # special value for --sources : read file list from arguments
-      FILE_LIST_FROM_ARGS='@args'
+      FILE_LIST_FROM_ARGS = '@args'
       # special value for --sources : read file list from transfer spec (--ts)
-      FILE_LIST_FROM_TRANSFER_SPEC='@ts'
-      DEFAULT_TRANSFER_NOTIF_TMPL=<<END_OF_TEMPLATE
-From: <%=from_name%> <<%=from_email%>>
-To: <<%=to%>>
-Subject: <%=subject%>
+      FILE_LIST_FROM_TRANSFER_SPEC = '@ts'
+      DEFAULT_TRANSFER_NOTIF_TMPL = <<~END_OF_TEMPLATE
+        From: <%=from_name%> <<%=from_email%>>
+        To: <<%=to%>>
+        Subject: <%=subject%>
 
-Transfer is: <%=global_transfer_status%>
+        Transfer is: <%=global_transfer_status%>
 
-<%=ts.to_yaml%>
-END_OF_TEMPLATE
+        <%=ts.to_yaml%>
+      END_OF_TEMPLATE
       #% (formating bug in eclipse)
       private_constant :FILE_LIST_FROM_ARGS,:FILE_LIST_FROM_TRANSFER_SPEC,:DEFAULT_TRANSFER_NOTIF_TMPL
-      TRANSFER_AGENTS=[:direct,:node,:connect,:httpgw,:trsdk]
+      TRANSFER_AGENTS = %i[direct node connect httpgw trsdk].freeze
 
       # @param env external objects: option manager, config file manager
       def initialize(opt_mgr,config)
-        @opt_mgr=opt_mgr
-        @config=config
+        @opt_mgr = opt_mgr
+        @config = config
         # command line can override transfer spec
-        @transfer_spec_cmdline={'create_dir'=>true}
+        @transfer_spec_cmdline = {'create_dir' => true}
         # the currently selected transfer agent
-        @agent=nil
-        @progress_listener=Listener::ProgressMulti.new
+        @agent = nil
+        @progress_listener = Listener::ProgressMulti.new
         # source/destination pair, like "paths" of transfer spec
-        @transfer_paths=nil
+        @transfer_paths = nil
         @opt_mgr.set_obj_attr(:ts,self,:option_transfer_spec)
-        @opt_mgr.add_opt_simple(:ts,"override transfer spec values (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:ts,:optional)}")
-        @opt_mgr.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:local_resume,:optional)}")
-        @opt_mgr.add_opt_simple(:to_folder,"destination folder for downloaded files")
-        @opt_mgr.add_opt_simple(:sources,"list of source files (see doc)")
-        @opt_mgr.add_opt_simple(:transfer_info,"parameters for transfer agent")
-        @opt_mgr.add_opt_list(:src_type,[:list,:pair],"type of file list")
-        @opt_mgr.add_opt_list(:transfer,TRANSFER_AGENTS,"type of transfer agent")
-        @opt_mgr.add_opt_list(:progress,[:none,:native,:multi],"type of progress bar")
+        @opt_mgr.add_opt_simple(:ts,"override transfer spec values (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:ts)}")
+        @opt_mgr.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:local_resume)}")
+        @opt_mgr.add_opt_simple(:to_folder,'destination folder for downloaded files')
+        @opt_mgr.add_opt_simple(:sources,'list of source files (see doc)')
+        @opt_mgr.add_opt_simple(:transfer_info,'parameters for transfer agent')
+        @opt_mgr.add_opt_list(:src_type,%i[list pair],'type of file list')
+        @opt_mgr.add_opt_list(:transfer,TRANSFER_AGENTS,'type of transfer agent')
+        @opt_mgr.add_opt_list(:progress,%i[none native multi],'type of progress bar')
         @opt_mgr.set_option(:transfer,:direct)
         @opt_mgr.set_option(:src_type,:list)
         @opt_mgr.set_option(:progress,:native) # use native ascp progress bar as it is more reliable
@@ -58,12 +60,12 @@ END_OF_TEMPLATE
 
       def option_transfer_spec_deep_merge(ts); @transfer_spec_cmdline.deep_merge!(ts); end
 
-      def set_agent_instance(instance)
-        @agent=instance
+      def agent_instance=(instance)
+        @agent = instance
         @agent.add_listener(Listener::Logger.new)
         # use local progress bar if asked so, or if native and non local ascp (because only local ascp has native progress bar)
-        if @opt_mgr.get_option(:progress,:mandatory).eql?(:multi) or
-        (@opt_mgr.get_option(:progress,:mandatory).eql?(:native) and ! instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
+        if @opt_mgr.get_option(:progress,is_type: :mandatory).eql?(:multi) ||
+        (@opt_mgr.get_option(:progress,is_type: :mandatory).eql?(:native) && !instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
           @agent.add_listener(@progress_listener)
         end
       end
@@ -71,25 +73,27 @@ END_OF_TEMPLATE
       # analyze options and create new agent if not already created or set
       def set_agent_by_options
         return nil unless @agent.nil?
-        agent_type=@opt_mgr.get_option(:transfer,:mandatory)
+        agent_type = @opt_mgr.get_option(:transfer,is_type: :mandatory)
+        # agent plugin is loaded on demand to avoid loading unnecessary dependencies
         require "aspera/fasp/agent_#{agent_type}"
-        agent_options=@opt_mgr.get_option(:transfer_info,:optional)
-        raise CliBadArgument,"the transfer agent configuration shall be Hash, not #{agent_options.class} (#{agent_options}), use either @json:<json> or @preset:<parameter set name>" unless [Hash,NilClass].include?(agent_options.class)
+        agent_options = @opt_mgr.get_option(:transfer_info)
+        raise CliBadArgument,"the transfer agent configuration shall be Hash, not #{agent_options.class} (#{agent_options}), "\
+          'use either @json:<json> or @preset:<parameter set name>' unless [Hash,NilClass].include?(agent_options.class)
         # special case
-        if agent_type.eql?(:node) and agent_options.nil?
-          param_set_name=@config.get_plugin_default_config_name(:node)
-          raise CliBadArgument,"No default node configured, Please specify --#{:transfer_info.to_s.gsub('_','-')}" if param_set_name.nil?
-          agent_options=@config.preset_by_name(param_set_name)
+        if agent_type.eql?(:node) && agent_options.nil?
+          param_set_name = @config.get_plugin_default_config_name(:node)
+          raise CliBadArgument,"No default node configured, Please specify --#{:transfer_info.to_s.tr('_','-')}" if param_set_name.nil?
+          agent_options = @config.preset_by_name(param_set_name)
         end
         # special case
-        if agent_type.eql?(:direct) and @opt_mgr.get_option(:progress,:mandatory).eql?(:native)
-          agent_options={} if agent_options.nil?
-          agent_options[:quiet]=false
+        if agent_type.eql?(:direct) && @opt_mgr.get_option(:progress,is_type: :mandatory).eql?(:native)
+          agent_options = {} if agent_options.nil?
+          agent_options[:quiet] = false
         end
-        agent_options=agent_options.symbolize_keys if agent_options.is_a?(Hash)
+        agent_options = agent_options.symbolize_keys if agent_options.is_a?(Hash)
         # get agent instance
-        new_agent=Kernel.const_get("Aspera::Fasp::Agent#{agent_type.capitalize}").new(agent_options)
-        set_agent_instance(new_agent)
+        new_agent = Kernel.const_get("Aspera::Fasp::Agent#{agent_type.capitalize}").new(agent_options)
+        self.agent_instance = new_agent
         return nil
       end
 
@@ -97,14 +101,14 @@ END_OF_TEMPLATE
       # sets default if needed
       # param: 'send' or 'receive'
       def destination_folder(direction)
-        dest_folder=@opt_mgr.get_option(:to_folder,:optional)
+        dest_folder = @opt_mgr.get_option(:to_folder)
         return File.expand_path(dest_folder) unless dest_folder.nil?
-        dest_folder=@transfer_spec_cmdline['destination_root']
+        dest_folder = @transfer_spec_cmdline['destination_root']
         return dest_folder unless dest_folder.nil?
         # default: / on remote, . on local
         case direction.to_s
-        when 'send';dest_folder='/'
-        when 'receive';dest_folder='.'
+        when Fasp::TransferSpec::DIRECTION_SEND then dest_folder = '/'
+        when Fasp::TransferSpec::DIRECTION_RECEIVE then dest_folder = '.'
         else raise "wrong direction: #{direction}"
         end
         return dest_folder
@@ -112,45 +116,46 @@ END_OF_TEMPLATE
 
       # This is how the list of files to be transfered is specified
       # get paths suitable for transfer spec from command line
-      # @return {:source=>(mandatory), :destination=>(optional)}
+      # @return {source: (mandatory), destination: (optional)}
       # computation is done only once, cache is kept in @transfer_paths
       def ts_source_paths
         # return cache if set
         return @transfer_paths unless @transfer_paths.nil?
         # start with lower priority : get paths from transfer spec on command line
-        @transfer_paths=@transfer_spec_cmdline['paths'] if @transfer_spec_cmdline.has_key?('paths')
+        @transfer_paths = @transfer_spec_cmdline['paths'] if @transfer_spec_cmdline.has_key?('paths')
         # is there a source list option ?
-        file_list=@opt_mgr.get_option(:sources,:optional)
+        file_list = @opt_mgr.get_option(:sources)
         case file_list
         when nil,FILE_LIST_FROM_ARGS
-          Log.log.debug("getting file list as parameters")
+          Log.log.debug('getting file list as parameters')
           # get remaining arguments
-          file_list=@opt_mgr.get_next_argument("source file list",:multiple)
-          raise CliBadArgument,"specify at least one file on command line or use --sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) or file_list.empty?
+          file_list = @opt_mgr.get_next_argument('source file list',expected: :multiple)
+          raise CliBadArgument,'specify at least one file on command line or use '\
+            "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) || file_list.empty?
         when FILE_LIST_FROM_TRANSFER_SPEC
-          Log.log.debug("assume list provided in transfer spec")
-          special_case_direct_with_list=@opt_mgr.get_option(:transfer,:mandatory).eql?(:direct) and Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
-          raise CliBadArgument,"transfer spec on command line must have sources" if @transfer_paths.nil? and !special_case_direct_with_list
+          Log.log.debug('assume list provided in transfer spec')
+          (special_case_direct_with_list = @opt_mgr.get_option(:transfer,is_type: :mandatory).eql?(:direct)) && Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
+          raise CliBadArgument,'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
           # here we assume check of sources is made in transfer agent
           return @transfer_paths
         when Array
-          Log.log.debug("getting file list as extended value")
-          raise CliBadArgument,"sources must be a Array of String" if !file_list.select{|f|!f.is_a?(String)}.empty?
+          Log.log.debug('getting file list as extended value')
+          raise CliBadArgument,'sources must be a Array of String' if !file_list.reject{|f|f.is_a?(String)}.empty?
         else
           raise CliBadArgument,"sources must be a Array, not #{file_list.class}"
         end
         # here, file_list is an Array or String
         if !@transfer_paths.nil?
-          Log.log.warn("--sources overrides paths from --ts")
+          Log.log.warn('--sources overrides paths from --ts')
         end
-        case @opt_mgr.get_option(:src_type,:mandatory)
+        case @opt_mgr.get_option(:src_type,is_type: :mandatory)
         when :list
           # when providing a list, just specify source
-          @transfer_paths=file_list.map{|i|{'source'=>i}}
+          @transfer_paths = file_list.map{|i|{'source' => i}}
         when :pair
           raise CliBadArgument,"When using pair, provide an even number of paths: #{file_list.length}" unless file_list.length.even?
-          @transfer_paths=file_list.each_slice(2).to_a.map{|s,d|{'source'=>s,'destination'=>d}}
-        else raise "Unsupported src_type"
+          @transfer_paths = file_list.each_slice(2).to_a.map{|s,d|{'source' => s,'destination' => d}}
+        else raise 'Unsupported src_type'
         end
         Log.log.debug("paths=#{@transfer_paths}")
         return @transfer_paths
@@ -163,18 +168,18 @@ END_OF_TEMPLATE
       # other options are carried to specific agent
       def start(transfer_spec,tr_opts)
         # check parameters
-        raise "transfer_spec must be hash" unless transfer_spec.is_a?(Hash)
-        raise "tr_opts must be hash" unless tr_opts.is_a?(Hash)
+        raise 'transfer_spec must be hash' unless transfer_spec.is_a?(Hash)
+        raise 'tr_opts must be hash' unless tr_opts.is_a?(Hash)
         # process :src option
         case transfer_spec['direction']
-        when 'receive'
+        when Fasp::TransferSpec::DIRECTION_RECEIVE
           # init default if required in any case
-          @transfer_spec_cmdline['destination_root']||=destination_folder(transfer_spec['direction'])
-        when 'send'
+          @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
+        when Fasp::TransferSpec::DIRECTION_SEND
           case tr_opts[:src]
           when :direct
             # init default if required
-            @transfer_spec_cmdline['destination_root']||=destination_folder(transfer_spec['direction'])
+            @transfer_spec_cmdline['destination_root'] ||= destination_folder(transfer_spec['direction'])
           when :node_gen3
             # in that case, destination is set in return by application (API/upload_setup)
             # but to_folder was used in initial API call
@@ -190,14 +195,15 @@ END_OF_TEMPLATE
         tr_opts.delete(:src)
 
         # update command line paths, unless destination already has one
-        @transfer_spec_cmdline['paths']=transfer_spec['paths'] || ts_source_paths
+        @transfer_spec_cmdline['paths'] = transfer_spec['paths'] || ts_source_paths
 
         transfer_spec.merge!(@transfer_spec_cmdline)
         # create transfer agent
-        self.set_agent_by_options
+        set_agent_by_options
         Log.log.debug("transfer agent is a #{@agent.class}")
         @agent.start_transfer(transfer_spec,tr_opts)
-        result=@agent.wait_for_transfers_completion
+        # list of : :success or error message
+        result = @agent.wait_for_transfers_completion
         @progress_listener.reset
         Fasp::AgentBase.validate_status_list(result)
         send_email_transfer_notification(transfer_spec,result)
@@ -205,13 +211,13 @@ END_OF_TEMPLATE
       end
 
       def send_email_transfer_notification(transfer_spec,statuses)
-        return if @opt_mgr.get_option(:notif_to,:optional).nil?
-        global_status=self.class.session_status(statuses)
-        email_vars={
+        return if @opt_mgr.get_option(:notif_to).nil?
+        global_status = self.class.session_status(statuses)
+        email_vars = {
           global_transfer_status: global_status,
-          subject: "ascli transfer: #{global_status}",
-          body: "Transfer is: #{global_status}",
-          ts: transfer_spec
+          subject:                "ascli transfer: #{global_status}",
+          body:                   "Transfer is: #{global_status}",
+          ts:                     transfer_spec
         }
         @config.send_email_template(email_vars,DEFAULT_TRANSFER_NOTIF_TMPL)
       end
@@ -219,7 +225,7 @@ END_OF_TEMPLATE
       # @return :success if all sessions statuses returned by "start" are success
       # else return the first error exception object
       def self.session_status(statuses)
-        error_statuses=statuses.select{|i|!i.eql?(:success)}
+        error_statuses = statuses.reject{|i|i.eql?(:success)}
         return :success if error_statuses.empty?
         return error_statuses.first
       end
@@ -228,7 +234,6 @@ END_OF_TEMPLATE
       def shutdown
         @agent.shutdown if @agent.respond_to?(:shutdown)
       end
-
     end
   end
 end

data/lib/aspera/cli/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Aspera
   module Cli
-    VERSION = "4.5.0"
+    VERSION = '4.8.0'
   end
 end

data/lib/aspera/colors.rb

@@ -1,43 +1,52 @@
+# frozen_string_literal: true
+
 # simple vt100 colors
 class String
-  private
-  def self.vtcmd(code);"\e[#{code}m";end
+  class << self
+    private
+
+    def vtcmd(code);"\e[#{code}m";end
+  end
   # see https://en.wikipedia.org/wiki/ANSI_escape_code
   # symbol is the method name added to String
   # it adds control chars to set color (and reset at the end).
   VTSTYLES = {
-    :bold=>1,
-    :italic=>3,
-    :underline=>4,
-    :blink=>5,
-    :reverse_color=>7,
-    :black=>30,
-    :red=>31,
-    :green=>32,
-    :brown=>33,
-    :blue=>34,
-    :magenta=>35,
-    :cyan=>36,
-    :gray=>37,
-    :bg_black=>40,
-    :bg_red=>41,
-    :bg_green=>42,
-    :bg_brown=>43,
-    :bg_blue=>44,
-    :bg_magenta=>45,
-    :bg_cyan=>46,
-    :bg_gray=>47,
-  }
+    bold:          1,
+    italic:        3,
+    underline:     4,
+    blink:         5,
+    reverse_color: 7,
+    black:         30,
+    red:           31,
+    green:         32,
+    brown:         33,
+    blue:          34,
+    magenta:       35,
+    cyan:          36,
+    gray:          37,
+    bg_black:      40,
+    bg_red:        41,
+    bg_green:      42,
+    bg_brown:      43,
+    bg_blue:       44,
+    bg_magenta:    45,
+    bg_cyan:       46,
+    bg_gray:       47
+  }.freeze
   private_constant :VTSTYLES
   # defines methods to String, one per entry in VTSTYLES
   VTSTYLES.each do |name,code|
-    begin_seq=vtcmd(code)
-    end_seq=vtcmd((code >= 10) ? 0 : code+20+(code.eql?(1)?1:0))
-    if STDERR.tty?
+    if $stderr.tty?
+      begin_seq = vtcmd(code)
+      end_code = 0 # by default reset all
+      if code <= 7 then 20 + code
+      elsif code <= 37 then 39
+      elsif code <= 47 then 49
+      end
+      end_seq = vtcmd(end_code)
       define_method(name){"#{begin_seq}#{self}#{end_seq}"}
     else
       define_method(name){self}
     end
-    public name
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -1,42 +1,49 @@
+# frozen_string_literal: true
+
 module Aspera
   # helper class to build command line from a parameter list (key-value hash)
   # constructor takes hash: { 'param1':'value1', ...}
   # process_param is called repeatedly with all known parameters
   # add_env_args is called to get resulting param list and env var (also checks that all params were used)
   class CommandLineBuilder
-    # transform yes/no to trye/false
-    def self.yes_to_true(value)
-      case value
-      when 'yes'; return true
-      when 'no'; return false
+    # parameter with onne of those tags is an ascp command line option with --
+    CLTYPE_OPTIONS=%i[opt_without_arg opt_with_arg].freeze
+    class<<self
+      # transform yes/no to true/false
+      def yes_to_true(value)
+        case value
+        when 'yes' then return true
+        when 'no' then return false
+        end
+        raise "unsupported value: #{value}"
       end
-      raise "unsupported value: #{value}"
-    end
 
-    # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
-    def self.normalize_description(d)
-      d.each do |param_name,options|
-        raise "Expecting Hash, but have #{options.class} in #{param_name}" unless options.is_a?(Hash)
-        #options[:accepted_types]=:bool if options[:cltype].eql?(:envvar) and !options.has_key?(:accepted_types)
-        # by default : not mandatory
-        options[:mandatory]||=false
-        options[:desc]||=''
-        # by default : string, unless it's without arg
-        if ! options.has_key?(:accepted_types)
-          options[:accepted_types]=options[:cltype].eql?(:opt_without_arg) ? :bool : :string
-        end
-        # single type is placed in array
-        options[:accepted_types]=[options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
-        if !options.has_key?(:option_switch) and options.has_key?(:cltype) and [:opt_without_arg,:opt_with_arg].include?(options[:cltype])
-          options[:option_switch]='--'+param_name.to_s.gsub('_','-')
+      # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
+      def normalize_description(d)
+        d.each do |param_name,options|
+          raise "Expecting Hash, but have #{options.class} in #{param_name}" unless options.is_a?(Hash)
+          #options[:accepted_types]=:bool if options[:cltype].eql?(:envvar) and !options.has_key?(:accepted_types)
+          # by default : not mandatory
+          options[:mandatory] ||= false
+          options[:desc] ||= ''
+          # by default : string, unless it's without arg
+          if !options.has_key?(:accepted_types)
+            options[:accepted_types] = options[:cltype].eql?(:opt_without_arg) ? :bool : :string
+          end
+          # single type is placed in array
+          options[:accepted_types] = [options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
+          # add default switch name if not present
+          if !options.has_key?(:clswitch) && options.has_key?(:cltype) && CLTYPE_OPTIONS.include?(options[:cltype])
+            options[:clswitch] = '--' + param_name.to_s.tr('_','-')
+          end
         end
       end
-    end
+  end
 
     private
 
     # clvarname : command line variable name
-    def env_name(param_name,options)
+    def env_name(_param_name,options)
       return options[:clvarname]
     end
 
@@ -46,11 +53,11 @@ module Aspera
 
     # @param param_hash
     def initialize(param_hash,params_definition)
-      @param_hash=param_hash  # keep reference so that it can be modified by caller before calling `process_params`
-      @params_definition=params_definition
-      @result_env={}
-      @result_args=[]
-      @used_param_names=[]
+      @param_hash = param_hash # keep reference so that it can be modified by caller before calling `process_params`
+      @params_definition = params_definition
+      @result_env = {}
+      @result_args = []
+      @used_param_names = []
     end
 
     def warn_unrecognized_params
@@ -85,43 +92,55 @@ module Aspera
     # @param action : type of processing: ignore getvalue envvar opt_without_arg opt_with_arg defer
     # @param options : options for type
     def process_param(param_name,action=nil)
-      options=@params_definition[param_name]
-      action=options[:cltype] if action.nil?
+      options = @params_definition[param_name]
       # should not happen
-      raise "Internal error: ask processing of param #{param_name}" if options.nil?
+      if options.nil?
+        Log.log.warn("Unknown parameter #{param_name}")
+        return
+      end
+      action = options[:cltype] if action.nil?
       # check mandatory parameter (nil is valid value)
-      raise Fasp::Error.new("mandatory parameter: #{param_name}") if options[:mandatory] and !@param_hash.has_key?(param_name)
-      parameter_value=@param_hash[param_name]
+      raise Fasp::Error, "Missing mandatory parameter: #{param_name}" if options[:mandatory] && !@param_hash.has_key?(param_name)
+      parameter_value = @param_hash[param_name]
+
       #parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
-      expected_classes=options[:accepted_types].map do |s|
+
+      # Check parameter type
+      expected_classes = options[:accepted_types].map do |s|
         case s
-        when :string; String
-        when :array; Array
-        when :hash; Hash
-        when :int; Integer
-        when :bool; [TrueClass,FalseClass]
+        when :string then String
+        when :array then Array
+        when :hash then Hash
+        when :int then Integer
+        when :bool then [TrueClass,FalseClass]
         else raise "INTERNAL: unexpected value: #{s}"
         end
       end.flatten
-      # check provided type
-      raise Fasp::Error.new("#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, ") unless parameter_value.nil? or expected_classes.include?(parameter_value.class)
+      raise Fasp::Error,"#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, " \
+        unless parameter_value.nil? || expected_classes.include?(parameter_value.class)
       @used_param_names.push(param_name) unless action.eql?(:defer)
 
       # process only non-nil values
       return nil if parameter_value.nil?
 
-      if options.has_key?(:translate_values)
+      # check that value is of an accepted type (string, int bool)
+      raise "Value #{parameter_value} is not allowed for #{param_name}" if options.has_key?(:enum) && !options[:enum].include?(parameter_value)
+
+      # convert some values if value on command line needs processing from value in structure
+      case options[:clconvert]
+      when Hash
         # translate using conversion table
-        new_value=options[:translate_values][parameter_value]
-        raise "unsupported value: #{parameter_value}" if new_value.nil?
-        parameter_value=new_value
-      end
-      raise "unsupported value: #{parameter_value}" unless options[:accepted_values].nil? or options[:accepted_values].include?(parameter_value)
-      if options[:encode]
-        # :encode has name of class with encoding method
-        newvalue=Kernel.const_get(options[:encode]).send("encode_#{param_name}",parameter_value)
-        raise Fasp::Error.new("unsupported #{param_name}: #{parameter_value}") if newvalue.nil?
-        parameter_value=newvalue
+        new_value = options[:clconvert][parameter_value]
+        raise "unsupported value: #{parameter_value}, expect: #{options[:clconvert].keys.join(', ')}" if new_value.nil?
+        parameter_value = new_value
+      when String
+        # :clconvert has name of class and encoding method
+        convclass,convmethod = options[:clconvert].split('.')
+        newvalue = Kernel.const_get(convclass).send(convmethod,parameter_value)
+        raise Fasp::Error, "unsupported #{param_name}: #{parameter_value}" if newvalue.nil?
+        parameter_value = newvalue
+      when NilClass
+      else raise "not expected type for clconvert #{options[:clconvert].class} for #{param_name}"
       end
 
       case action
@@ -133,21 +152,23 @@ module Aspera
         # define ascp parameter in env var from transfer spec
         @result_env[env_name(param_name,options)] = parameter_value
       when :opt_without_arg # if present and true : just add option without value
-        add_param=false
+        add_param = false
         case parameter_value
-        when false# nothing to put on command line, no creation by default
-        when true; add_param=true
-        else raise Fasp::Error.new("unsupported #{param_name}: #{parameter_value}")
+        when false then nil # nothing to put on command line, no creation by default
+        when true then add_param = true
+        else raise Fasp::Error, "unsupported #{param_name}: #{parameter_value}"
         end
-        add_param=!add_param if options[:add_on_false]
-        add_command_line_options([options[:option_switch]]) if add_param
+        add_param = !add_param if options[:add_on_false]
+        add_command_line_options([options[:clswitch]]) if add_param
       when :opt_with_arg # transform into command line option with value
         #parameter_value=parameter_value.to_s if parameter_value.is_a?(Integer)
-        parameter_value=[parameter_value] unless parameter_value.is_a?(Array)
+        parameter_value = [parameter_value] unless parameter_value.is_a?(Array)
         # if transfer_spec value is an array, applies option many times
-        parameter_value.each{|v|add_command_line_options([options[:option_switch],v])}
+        parameter_value.each{|v|add_command_line_options([options[:clswitch],v])}
+      when NilClass
+        Log.log.debug("Ignoring parameter: #{param_name}")
       else
-        raise "Error"
+        raise "ERROR: unknown action: #{action}/#{action.class}"
       end
     end
   end