aspera-cli 4.23.0 → 4.24.0

data/lib/aspera/colors.rb

@@ -10,7 +10,7 @@ class String
     def vt_cmd(code); "\e[#{code}m"; end
   end
   # see https://en.wikipedia.org/wiki/ANSI_escape_code
-  # symbol is the method name added to String
+  # symbol is the method name added to String, e.g. "hello".bold
   # it adds control chars to set color (and reset at the end).
   VT_STYLES = {
     bold:          1,
@@ -20,6 +20,7 @@ class String
     blink:         5,
     reverse_color: 7,
     invisible:     8,
+    strike:        9,
     black:         30,
     red:           31,
     green:         32,
@@ -38,21 +39,25 @@ class String
     bg_gray:       47
   }.freeze
   private_constant :VT_STYLES
-  # defines methods to String, one per entry in VT_STYLES
+  # Defines methods to String, one per entry in VT_STYLES
   VT_STYLES.each do |name, code|
     if $stdout.tty?
       begin_seq = vt_cmd(code)
-      end_code = 0 # by default reset all
-      if code <= 7 then code + 20
-      elsif code <= 37 then 39
-      elsif code <= 47 then 49
-      end
-      end_seq = vt_cmd(end_code)
+      end_seq = vt_cmd(
+        if code <= 2 then 22
+        elsif code <= 8 then code + 20
+        elsif code <= 37 then 39
+        elsif code <= 47 then 49
+        else
+          0 # by default reset all
+        end
+      )
       define_method(name){"#{begin_seq}#{self}#{end_seq}"}
     else
       define_method(name){self}
     end
   end
+  # Transform capitalized to snake case
   def capital_to_snake
     return gsub(/([a-z\d])([A-Z])/, '\1_\2')
         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')

data/lib/aspera/command_line_builder.rb

@@ -13,19 +13,24 @@ module Aspera
     # type           [String,Array] Accepted type(s) for non-enum
     # default        [String]       Default value if not specified
     # enum           [Array]        Set with list of values for enum types accepted in transfer spec
+    # items          [Array]
+    # properties     [Array]
     # x-cli-envvar   [String]       Name of env var
     # x-cli-option   [String]       Command line option (starts with "-")
     # x-cli-switch   [Bool]         true if option has no arg, else by default option has a value
     # x-cli-special  [Bool]         true if special handling (defered)
     # x-cli-convert  [String,Hash]  Method name for Convert object or Conversion for enum ts to arg
     # x-agents       [Array]        Supported agents (for doc only), if not specified: all
-    # x-tspec        [Bool,String]  (async) true if same name in transfer spec, else name in transfer spec, else ignored
+    # x-ts-name      [Bool,String]  (async) true if same name in transfer spec, else real name in transfer spec, else ignored
+    # x-ts-convert   [String]       (async) Method name for Convert object
     # x-deprecation  [String]       Deprecation message for doc
-    SCHEMA_KEYS = %w[
+    PROPERTY_KEYS = %w[
       description
       type
       default
       enum
+      items
+      properties
       required
       $comment
       x-cli-envvar
@@ -34,13 +39,13 @@ module Aspera
       x-cli-special
       x-cli-convert
       x-agents
-      x-tspec
+      x-ts-name
       x-deprecation
     ].freeze
 
     CLI_AGENT = 'direct'
 
-    private_constant :SCHEMA_KEYS, :CLI_AGENT
+    private_constant :PROPERTY_KEYS, :CLI_AGENT
 
     class << self
       # @return true if given agent supports that field
@@ -48,22 +53,23 @@ module Aspera
         !properties.key?('x-agents') || properties['x-agents'].include?(agent)
       end
 
-      # Called by provider of definition before constructor of this class so that schema has all mandatory fields
-      def read_schema(source_path, suffix=nil)
-        suffix = "_#{suffix}" unless suffix.nil?
-        schema = YAML.load_file("#{source_path[0..-4]}#{suffix}.schema.yaml")
-        schema['properties'].each do |name, properties|
-          Aspera.assert_type(properties, Hash){name}
-          unsupported_keys = properties.keys - SCHEMA_KEYS
+      # fill default values
+      def adjust_properties_defaults(properties)
+        properties.each do |name, info|
+          Aspera.assert_type(info, Hash){"#{info.class} for #{name}"}
+          unsupported_keys = info.keys - PROPERTY_KEYS
           Aspera.assert(unsupported_keys.empty?){"Unsupported definition keys: #{unsupported_keys}"}
           # by default : string, unless it's without arg
-          properties['type'] ||= properties['x-cli-switch'] ? 'boolean' : 'string'
+          info['type'] ||= info['x-cli-switch'] ? 'boolean' : 'string'
           # add default cli option name if not present, and if supported in "direct".
-          properties['x-cli-option'] = '--' + name.to_s.tr('_', '-') if !properties.key?('x-cli-option') && !properties['x-cli-envvar'] && (properties.key?('x-cli-switch') || supported_by_agent(CLI_AGENT, properties))
-          properties.freeze
+          info['x-cli-option'] = "--#{name.to_s.tr('_', '-')}" if !info.key?('x-cli-option') && !info['x-cli-envvar'] && (info.key?('x-cli-switch') || supported_by_agent(CLI_AGENT, info))
+          info.freeze
         end
-        schema['required'] = [] unless schema.key?('required')
-        schema.freeze
+      end
+
+      # Called by provider of definition before constructor of this class so that schema has all mandatory fields
+      def read_schema(source_path, name)
+        YAML.load_file(File.join(File.dirname(source_path), "#{name}.schema.yaml"))
       end
     end
 
@@ -83,7 +89,7 @@ module Aspera
     # Change required-ness of property in schema
     def required(name, required)
       if required
-        @schema['required'].push(name) unless @schema['required'].include?(name)
+        @schema['required'].push(name) unless @schema['required']&.include?(name)
       else
         @schema['required'].delete(name)
       end
@@ -100,7 +106,7 @@ module Aspera
       # set result
       env_args[:env].merge!(@result[:env])
       env_args[:args].concat(@result[:args])
-      return nil
+      return
     end
 
     # add options directly to command line
@@ -132,7 +138,7 @@ module Aspera
         return
       end
       # check mandatory parameter (nil is valid value), TODO: change exception ?
-      raise Transfer::Error, "Missing mandatory parameter: #{name}" if @schema['required'].include?(name) && !properties['x-cli-special'] && !@object.key?(name)
+      raise Transfer::Error, "Missing mandatory parameter: #{name}" if @schema['required']&.include?(name) && !properties['x-cli-special'] && !@object.key?(name)
       parameter_value = @object[name]
       # no default setting
       # parameter_value=properties['default'] if parameter_value.nil? and properties.has_key?('default')
@@ -145,17 +151,17 @@ module Aspera
           when 'object' then [Hash]
           when 'integer' then [Integer]
           when 'boolean' then [TrueClass, FalseClass]
-          else Aspera.error_unexpected_value(properties['type'])
+          else Aspera.error_unexpected_value(properties['type']){"Property #{name}"}
           end
         end.flatten
       # check that value is of expected type
-      raise Transfer::Error, "#{name} is : #{parameter_value.class} (#{parameter_value}), shall be #{properties['type']}, " \
+      raise Transfer::Error, "#{name} is #{parameter_value.class} (#{parameter_value}), shall be #{properties['type']}, " \
         unless parameter_value.nil? || expected_classes.include?(parameter_value.class)
       # special processing will be requested with type get_value
       @processed_parameters.push(name) if !properties['x-cli-special'] || read
 
       # process only non-nil values
-      return nil if parameter_value.nil?
+      return if parameter_value.nil?
 
       # check that value is of an accepted type (string, integer, boolean)
       raise "Enum value #{parameter_value} is not allowed for #{name}" if properties.key?('enum') && !properties['enum'].include?(parameter_value)

data/lib/aspera/command_line_converter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'aspera/assert'
+module Aspera
+  # conversion class for transfer spec values to CLI values (ascp)
+  class CommandLineConverter
+    class << self
+      # special encoding methods used in YAML (key: convert)
+      def remove_hyphen(value); value.tr('-', ''); end
+
+      # special encoding methods used in YAML (key: convert)
+      def json64(value); Base64.strict_encode64(JSON.generate(value)); end
+
+      # special encoding methods used in YAML (key: convert)
+      def base64(value); Base64.strict_encode64(value); end
+
+      # transform yes/no to true/false
+      def yes_to_true(value)
+        case value
+        when 'yes' then return true
+        when 'no' then return false
+        else Aspera.error_unexpected_value(value){'only: yes or no: '}
+        end
+      end
+
+      def kbps_to_bps(value)
+        1000 * value
+      end
+    end
+  end
+end

data/lib/aspera/environment.rb

@@ -14,13 +14,12 @@ module Aspera
   class Environment
     include Singleton
 
-    USER_INTERFACES = %i[text graphical].freeze
-
     OS_WINDOWS = :windows
     OS_MACOS = :osx
     OS_LINUX = :linux
     OS_AIX = :aix
     OS_LIST = [OS_WINDOWS, OS_MACOS, OS_LINUX, OS_AIX].freeze
+
     CPU_X86_64 = :x86_64
     CPU_ARM64 = :arm64
     CPU_PPC64 = :ppc64
@@ -32,60 +31,18 @@ module Aspera
     MEBI = 1024 * 1024
     BYTES_PER_MEBIBIT = MEBI / BITS_PER_BYTE
 
+    I18N_VARS = %w(LC_ALL LC_CTYPE LANG).freeze
+
+    # "/" is invalid on both Unix and Windows, other are Windows special characters
+    # See: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+    WINDOWS_FILENAME_INVALID_CHARACTERS = '<>:"/\\|?*'
+    REPLACE_CHARACTER = '_'
+
     class << self
       def ruby_version
         return RbConfig::CONFIG['RUBY_PROGRAM_VERSION']
       end
 
-      def os
-        case RbConfig::CONFIG['host_os']
-        when /mswin/, /msys/, /mingw/, /cygwin/, /bccwin/, /wince/, /emc/
-          return OS_WINDOWS
-        when /darwin/, /mac os/
-          return OS_MACOS
-        when /linux/
-          return OS_LINUX
-        when /aix/
-          return OS_AIX
-        else Aspera.error_unexpected_value(RbConfig::CONFIG['host_os']){'host_os'}
-        end
-      end
-
-      def cpu
-        case RbConfig::CONFIG['host_cpu']
-        when /x86_64/, /x64/
-          return CPU_X86_64
-        when /powerpc/, /ppc64/
-          return CPU_PPC64LE if os.eql?(OS_LINUX)
-          return CPU_PPC64
-        when /s390/
-          return CPU_S390
-        when /arm/, /aarch64/
-          return CPU_ARM64
-        else Aspera.error_unexpected_value(RbConfig::CONFIG['host_cpu']){'host_cpu'}
-        end
-      end
-
-      # normalized architecture name
-      # see constants: OS_* and CPU_*
-      def architecture
-        return "#{os}-#{cpu}"
-      end
-
-      # executable file extension for current OS
-      def exe_file(name='')
-        return "#{name}.exe" if os.eql?(OS_WINDOWS)
-        return name
-      end
-
-      # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
-      # so, tell Ruby the right way
-      def fix_home
-        return unless os.eql?(OS_WINDOWS) && ENV.key?('USERPROFILE') && Dir.exist?(ENV.fetch('USERPROFILE', nil))
-        ENV['HOME'] = ENV.fetch('USERPROFILE', nil)
-        Log.log.debug{"Windows: set HOME to USERPROFILE: #{Dir.home}"}
-      end
-
       # empty variable binding for secure eval
       def empty_binding
         return Kernel.binding
@@ -120,9 +77,9 @@ module Aspera
       # @raise  [Exception]         if problem
       def secure_spawn(exec:, args: nil, env: nil, **options)
         Aspera.assert_type(exec, String)
-        Aspera.assert_type(args, Array) unless args.nil?
-        Aspera.assert_type(env, Hash) unless env.nil?
-        Aspera.assert_type(options, Hash) unless options.nil?
+        Aspera.assert_type(args, Array, NilClass)
+        Aspera.assert_type(env, Hash, NilClass)
+        Aspera.assert_type(options, Hash, NilClass)
         Log.log.debug{log_spawn(exec: exec, args: args, env: env)}
         # start ascp in separate process
         spawn_args = []
@@ -143,8 +100,8 @@ module Aspera
       # @return [String] PID of process
       def secure_execute(exec:, args: nil, env: nil, **system_args)
         Aspera.assert_type(exec, String)
-        Aspera.assert_type(args, Array) unless args.nil?
-        Aspera.assert_type(env, Hash) unless env.nil?
+        Aspera.assert_type(args, Array, NilClass)
+        Aspera.assert_type(env, Hash, NilClass)
         Log.log.debug{log_spawn(exec: exec, args: args, env: env)}
         # start in separate process
         spawn_args = []
@@ -163,15 +120,17 @@ module Aspera
       # @param args [Array] arguments to executable
       # @param opts [Hash] options to capture3
       # @return stdout of executable or raise exception
-      def secure_capture(exec:, args: [], **opts)
+      def secure_capture(exec:, args: [], exception: true, **opts)
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array)
         Aspera.assert_type(opts, Hash)
         Log.log.debug{log_spawn(exec: exec, args: args)}
+        Log.dump(:opts, opts, level: :trace2)
+        Log.dump(:ENV, ENV.to_h, level: :trace1)
         stdout, stderr, status = Open3.capture3(exec, *args, **opts)
         Log.log.debug{"status=#{status}, stderr=#{stderr}"}
         Log.log.trace1{"stdout=#{stdout}"}
-        raise "process failed: #{status.exitstatus} : #{stderr}" unless status.success?
+        raise "process failed: #{status.exitstatus} (#{stderr})" if !status.success? && exception
         return stdout
       end
 
@@ -181,7 +140,7 @@ module Aspera
       # @param mode [Integer] the file mode (permissions)
       # @block [Proc] return the content to write to the file
       def write_file_restricted(path, force: false, mode: nil)
-        Aspera.assert(block_given?, exception_class: Aspera::InternalError)
+        Aspera.assert(block_given?, type: Aspera::InternalError)
         if force || !File.exist?(path)
           # Windows may give error
           File.unlink(path) rescue nil
@@ -214,71 +173,155 @@ module Aspera
         $stdout.tty?
       end
 
-      # @return :text or :graphical depending on the environment
-      def default_gui_mode
-        # assume not remotely connected on macos and windows
-        return :graphical if [Environment::OS_WINDOWS, Environment::OS_MACOS].include?(Environment.os)
-        # unix family
-        return :graphical if ENV.key?('DISPLAY') && !ENV['DISPLAY'].empty?
-        return :text
+      # force locale to C so that unicode characters are not used
+      def force_terminal_c
+        I18N_VARS.each{ |var| ENV[var] = 'C'}
       end
 
-      # open a URI in a graphical browser
-      # command must be non blocking
-      def open_uri_graphical(uri)
-        case Environment.os
-        when Environment::OS_MACOS then return system('open', uri.to_s)
-        when Environment::OS_WINDOWS then return system('start', 'explorer', %Q{"#{uri}"})
-        when Environment::OS_LINUX   then return system('xdg-open', uri.to_s)
-        else
-          raise "no graphical open method for #{Environment.os}"
-        end
+      # @return true if we can display Unicode characters
+      # https://www.gnu.org/software/libc/manual/html_node/Locale-Categories.html
+      # https://pubs.opengroup.org/onlinepubs/7908799/xbd/envvar.html
+      def terminal_supports_unicode?
+        terminal? && I18N_VARS.any?{ |var| ENV[var]&.include?('UTF-8')}
       end
+    end
+    attr_accessor :url_method, :file_illegal_characters
+    attr_reader :os, :cpu, :executable_extension, :default_gui_mode
+
+    def initialize
+      initialize_fields
+    end
 
-      # open a file in an editor
-      def open_editor(file_path)
-        if ENV.key?('EDITOR')
-          system(ENV['EDITOR'], file_path.to_s)
-        elsif Environment.os.eql?(Environment::OS_WINDOWS)
-          system('notepad.exe', %Q{"#{file_path}"})
+    # initialize fields from environment
+    def initialize_fields
+      @os =
+        case RbConfig::CONFIG['host_os']
+        when /mswin/, /msys/, /mingw/, /cygwin/, /bccwin/, /wince/, /emc/
+          OS_WINDOWS
+        when /darwin/, /mac os/
+          OS_MACOS
+        when /linux/
+          OS_LINUX
+        when /aix/
+          OS_AIX
+        else Aspera.error_unexpected_value(RbConfig::CONFIG['host_os']){'host_os'}
+        end
+      @cpu =
+        case RbConfig::CONFIG['host_cpu']
+        when /x86_64/, /x64/
+          CPU_X86_64
+        when /powerpc/, /ppc64/
+          @os.eql?(OS_LINUX) ? CPU_PPC64LE : CPU_PPC64
+        when /s390/
+          CPU_S390
+        when /arm/, /aarch64/
+          CPU_ARM64
+        else Aspera.error_unexpected_value(RbConfig::CONFIG['host_cpu']){'host_cpu'}
+        end
+      @executable_extension = @os.eql?(OS_WINDOWS) ? 'exe' : nil
+      # :text or :graphical depending on the environment
+      @default_gui_mode =
+        if [Environment::OS_WINDOWS, Environment::OS_MACOS].include?(os) ||
+            (ENV.key?('DISPLAY') && !ENV['DISPLAY'].empty?)
+          # assume not remotely connected on macos and windows or unix family
+          :graphical
         else
-          open_uri_graphical(file_path.to_s)
+          :text
         end
-      end
+      @url_method = @default_gui_mode
+      @file_illegal_characters = REPLACE_CHARACTER + WINDOWS_FILENAME_INVALID_CHARACTERS
+      nil
     end
-    attr_accessor :url_method
 
-    def initialize
-      @url_method = self.class.default_gui_mode
-      @terminal_supports_unicode = nil
+    # Normalized architecture name
+    # See constants: OS_* and CPU_*
+    def architecture
+      "#{@os}-#{@cpu}"
     end
 
-    # @return true if we can display Unicode characters
-    # https://www.gnu.org/software/libc/manual/html_node/Locale-Categories.html
-    # https://pubs.opengroup.org/onlinepubs/7908799/xbd/envvar.html
-    def terminal_supports_unicode?
-      @terminal_supports_unicode = self.class.terminal? && %w(LC_ALL LC_CTYPE LANG).any?{ |var| ENV[var]&.include?('UTF-8')} if @terminal_supports_unicode.nil?
-      return @terminal_supports_unicode
+    # executable file extension for current OS
+    def exe_file(name)
+      return name unless @executable_extension
+      return "#{name}#{@executable_extension}"
     end
 
-    # Allows a user to open a Url
-    # if method is "text", then URL is displayed on terminal
-    # if method is "graphical", then the URL will be opened with the default browser.
+    # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
+    # so, tell Ruby the right way
+    def fix_home
+      return unless @os.eql?(OS_WINDOWS) && ENV.key?('USERPROFILE') && Dir.exist?(ENV.fetch('USERPROFILE', nil))
+      ENV['HOME'] = ENV.fetch('USERPROFILE', nil)
+      Log.log.debug{"Windows: set HOME to USERPROFILE: #{Dir.home}"}
+    end
+
+    def graphical?
+      @default_gui_mode == :graphical
+    end
+
+    # Open a URI in a graphical browser
+    # Command must be non blocking
+    # @param uri [String] the URI to open
+    def open_uri_graphical(uri)
+      case @os
+      when Environment::OS_MACOS then return self.class.secure_execute(exec: 'open', args: [uri.to_s])
+      when Environment::OS_WINDOWS then return self.class.secure_execute(exec: 'start', args: ['explorer', %Q{"#{uri}"}])
+      when Environment::OS_LINUX   then return self.class.secure_execute(exec: 'xdg-open', args: [uri.to_s])
+      else Assert.error_unexpected_value(os){'no graphical open method'}
+      end
+    end
+
+    # open a file in an editor
+    def open_editor(file_path)
+      if ENV.key?('EDITOR')
+        self.class.secure_execute(exec: ENV['EDITOR'], args: [file_path.to_s])
+      elsif @os.eql?(Environment::OS_WINDOWS)
+        self.class.secure_execute(exec: 'notepad.exe', args: [%Q{"#{file_path}"}])
+      else
+        open_uri_graphical(file_path.to_s)
+      end
+    end
+
+    # Allows a user to open a URL
+    # if method is :text, then URL is displayed on terminal
+    # if method is :graphical, then the URL will be opened with the default browser.
     # this is non blocking
     def open_uri(the_url)
       case @url_method
       when :graphical
-        self.class.open_uri_graphical(the_url)
+        open_uri_graphical(the_url)
       when :text
         case the_url.to_s
         when /^http/
-          puts "USER ACTION: please enter this url in a browser:\n#{the_url.to_s.red}\n"
+          puts "USER ACTION: please enter this URL in a browser:\n#{the_url.to_s.red}\n"
         else
           puts "USER ACTION: open this:\n#{the_url.to_s.red}\n"
         end
-      else
-        raise StandardError, "unsupported url open method: #{@url_method}"
+      else Aspera.error_unexpected_value(@url_method){'URL open method'}
+      end
+    end
+
+    # Replacement character for illegal filename characters
+    # Can also be used as safe "join" character
+    def safe_filename_character
+      return REPLACE_CHARACTER if @file_illegal_characters.nil? || @file_illegal_characters.empty?
+      @file_illegal_characters[0]
+    end
+
+    # Sanitize a filename by replacing illegal characters
+    # @param filename [String] the original filename
+    # @return [String] A file name safe to use on file system
+    def sanitized_filename(filename)
+      safe_char = safe_filename_character
+      # Windows does not allow file name ending with space or dot
+      # nor control characters anywhere.
+      filename = filename
+        .gsub(/[\. ]+$/, safe_char)
+        .gsub(/[\x00-\x1F\x7F]/, safe_char)
+      if @file_illegal_characters&.size.to_i >= 2
+        # replace all illegal characters with safe_char
+        filename = filename.tr(@file_illegal_characters[1..-1], safe_char)
       end
+      # ensure only one safe_char is used at a time
+      return filename.gsub(/#{Regexp.escape(safe_char)}+/, safe_char).chomp(safe_char)
     end
   end
 end

data/lib/aspera/faspex_gw.rb

@@ -66,7 +66,7 @@ module Aspera
       case request.path
       when '/aspera/faspex/send'
         begin
-          raise 'no payload' if request.body.nil?
+          Aspera.assert(!request.body.nil?){'payload missing'}
           faspex_pkg_parameters = JSON.parse(request.body)
           Log.log.debug{"faspex pkg create parameters=#{faspex_pkg_parameters}"}
           # compare string, as class is not yet known here

data/lib/aspera/faspex_postproc.rb

@@ -14,7 +14,7 @@ module Aspera
     def initialize(server, parameters)
       Aspera.assert_type(parameters, Hash)
       @parameters = parameters.symbolize_keys
-      Log.log.debug{Log.dump(:post_proc_parameters, @parameters)}
+      Log.dump(:post_proc_parameters, @parameters)
       not_allowed = @parameters.keys - ALLOWED_PARAMETERS
       raise "unsupported parameters: #{not_allowed.join(', ')}" unless not_allowed.empty?
       @parameters[:script_folder] ||= '.'
@@ -24,6 +24,7 @@ module Aspera
       Log.log.debug{'Faspex4PostProcServlet initialized'}
     end
 
+    # :reek:UncommunicativeMethodName
     def do_POST(request, response)
       Log.log.debug{"request=#{request.path}"}
       begin
@@ -46,7 +47,7 @@ module Aspera
         script_path = File.join(@parameters[:script_folder], script_file)
         Log.log.debug{"script=#{script_path}"}
         webhook_parameters = JSON.parse(request.body)
-        Log.log.debug{Log.dump(:webhook_parameters, webhook_parameters)}
+        Log.dump(:webhook_parameters, webhook_parameters)
         # env expects only strings
         environment = webhook_parameters.each_with_object({}){ |(k, v), h| h[k] = v.to_s}
         post_proc_pid = Environment.secure_spawn(env: environment, exec: script_path)

data/lib/aspera/hash_ext.rb

@@ -9,7 +9,7 @@ class ::Hash
     merge!(second){ |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.deep_merge!(v2) : v2}
   end
 
-  def deep_do(memory=nil, &block)
+  def deep_do(memory = nil, &block)
     each do |key, value|
       if value.is_a?(Hash)
         value.deep_do(memory, &block)

data/lib/aspera/id_generator.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
 require 'aspera/assert'
+require 'aspera/environment'
 require 'uri'
 
 module Aspera
   class IdGenerator
-    ID_SEPARATOR = '_'
-    WINDOWS_PROTECTED_CHAR = %r{[/:"<>\\*?]}.freeze
-    PROTECTED_CHAR_REPLACE = '_'
-    private_constant :ID_SEPARATOR, :PROTECTED_CHAR_REPLACE, :WINDOWS_PROTECTED_CHAR
     class << self
+      # Generate an ID from a list of object IDs
+      # The generated ID is safe as file name
+      # @param object_id [Array<String>, String] the object IDs
+      # @return [String] the generated ID
       def from_list(object_id)
+        safe_char = Environment.instance.safe_filename_character
         if object_id.is_a?(Array)
           # compact: remove nils
-          object_id = object_id.compact.map do |i|
+          object_id = object_id.flatten.compact.map do |i|
             i.is_a?(String) && i.start_with?('https://') ? URI.parse(i).host : i.to_s
-          end.join(ID_SEPARATOR)
+          end.join(safe_char)
         end
         Aspera.assert_type(object_id, String)
-        return object_id
-            .gsub(WINDOWS_PROTECTED_CHAR, PROTECTED_CHAR_REPLACE) # remove windows forbidden chars
-            .gsub('.', PROTECTED_CHAR_REPLACE) # keep dot for extension only (nicer)
-            .downcase
+        # keep dot for extension only (nicer)
+        return Environment.instance.sanitized_filename(object_id.gsub('.', safe_char)).downcase
       end
     end
   end

data/lib/aspera/keychain/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Aspera
+  module Keychain
+    class Base
+      CONTENT_KEYS = %i[label username password url description].freeze
+      def validate_set(options)
+        Aspera.assert_type(options, Hash){'options'}
+        unsupported = options.keys - CONTENT_KEYS
+        Aspera.assert(unsupported.empty?){"unsupported options: #{unsupported}, use #{CONTENT_KEYS.join(', ')}"}
+        options.each_pair do |k, v|
+          Aspera.assert_type(v, String){k.to_s}
+        end
+        Aspera.assert(options.key?(:label)){'label is required'}
+      end
+    end
+  end
+end