aspera-cli 4.25.0.pre2 → 4.25.0

data/lib/aspera/cli/plugins/ats.rb

@@ -18,10 +18,10 @@ module Aspera
         # columns for list of cloud providers
         CLOUD_TABLE = %w[id name].freeze
         private_constant :CLOUD_TABLE
-        def initialize(**_)
-          super
-          @ats_api_pub = nil
-          @ats_api_pub_v1_cache = nil
+        def initialize(api: nil, **base_args)
+          super(**base_args)
+          @ats_api_open = Api::Ats.new
+          @ats_api_auth = api
           options.declare(:ibm_api_key, 'IBM API key, see https://cloud.ibm.com/iam/apikeys')
           options.declare(:instance, 'ATS instance in ibm cloud')
           options.declare(:ats_key, 'ATS key identifier (ats_xxx)')
@@ -36,13 +36,13 @@ module Aspera
           # TODO: provide list ?
           cloud = options.get_option(:cloud, mandatory: true).upcase
           region = options.get_option(:region, mandatory: true)
-          return @ats_api_pub.read("servers/#{cloud}/#{region}")
+          return @ats_api_open.read("servers/#{cloud}/#{region}")
         end
 
         # require api key only if needed
-        def ats_api_pub_v1
-          return @ats_api_pub_v1_cache unless @ats_api_pub_v1_cache.nil?
-          @ats_api_pub_v1_cache = Rest.new(
+        def ats_api
+          return @ats_api_auth unless @ats_api_auth.nil?
+          @ats_api_auth = Rest.new(
             base_url: "#{Api::Ats::SERVICE_BASE_URL}/pub/v1",
             auth:     {
               type:     :basic,
@@ -73,10 +73,10 @@ module Aspera
               when 'ibm-s3'
                 server_data2 = nil
                 if server_data.nil?
-                  server_data2 = @ats_api_pub.all_servers.find{ |s| s['id'].eql?(params['transfer_server_id'])}
+                  server_data2 = @ats_api_open.all_servers.find{ |s| s['id'].eql?(params['transfer_server_id'])}
                   raise "no such transfer server id: #{params['transfer_server_id']}" if server_data2.nil?
                 else
-                  server_data2 = @ats_api_pub.all_servers.find do |s|
+                  server_data2 = @ats_api_open.all_servers.find do |s|
                     s['cloud'].eql?(server_data['cloud']) &&
                       s['region'].eql?(server_data['region']) &&
                       s.key?('s3_authentication_endpoint')
@@ -88,31 +88,31 @@ module Aspera
                 params['storage']['endpoint'] = server_data2['s3_authentication_endpoint'] if !params['storage'].key?('authentication_endpoint')
               end
             end
-            res = ats_api_pub_v1.create('access_keys', params)
+            res = ats_api.create('access_keys', params)
             return Main.result_single_object(res)
             # TODO : action : modify, with "PUT"
           when :list
             params = query_read_delete(default: {'offset' => 0, 'max_results' => 1000})
-            res = ats_api_pub_v1.read('access_keys', params)
+            res = ats_api.read('access_keys', params)
             return Main.result_object_list(res['data'], fields: ['name', 'id', 'created.at', 'modified.at'])
           when :show
-            res = ats_api_pub_v1.read("access_keys/#{access_key_id}")
+            res = ats_api.read("access_keys/#{access_key_id}")
             return Main.result_single_object(res)
           when :modify
             params = value_create_modify(command: command)
             params['id'] = access_key_id
-            ats_api_pub_v1.update("access_keys/#{access_key_id}", params)
+            ats_api.update("access_keys/#{access_key_id}", params)
             return Main.result_status('modified')
           when :entitlement
-            ak = ats_api_pub_v1.read("access_keys/#{access_key_id}")
+            ak = ats_api.read("access_keys/#{access_key_id}")
             api_bss = Api::Alee.new(ak['license']['entitlement_id'], ak['license']['customer_id'])
             return Main.result_single_object(api_bss.read('entitlement'))
           when :delete
-            ats_api_pub_v1.delete("access_keys/#{access_key_id}")
+            ats_api.delete("access_keys/#{access_key_id}")
             return Main.result_status("deleted #{access_key_id}")
           when :node
-            ak_data = ats_api_pub_v1.read("access_keys/#{access_key_id}")
-            server_data = @ats_api_pub.all_servers.find{ |i| i['id'].start_with?(ak_data['transfer_server_id'])}
+            ak_data = ats_api.read("access_keys/#{access_key_id}")
+            server_data = @ats_api_open.all_servers.find{ |i| i['id'].start_with?(ak_data['transfer_server_id'])}
             raise Cli::Error, 'no such server found' if server_data.nil?
             node_url = server_data['transfer_setup_url']
             api_node = Api::Node.new(
@@ -126,7 +126,7 @@ module Aspera
             command = options.get_next_command(Node::COMMANDS_GEN4)
             return Node.new(context: context, api: api_node).execute_command_gen4(command, ak_data['root_file_id'])
           when :cluster
-            ats_url = ats_api_pub_v1.base_url
+            ats_url = ats_api.base_url
             api_ak_auth = Rest.new(
               base_url: ats_url,
               auth:     {
@@ -140,19 +140,19 @@ module Aspera
           end
         end
 
-        def execute_action_cluster_pub
+        def execute_action_cluster_open
           command = options.get_next_command(%i[clouds list show])
           case command
           when :clouds
-            return Main.result_object_list(@ats_api_pub.cloud_names.map{ |k, v| CLOUD_TABLE.zip([k, v]).to_h})
+            return Main.result_object_list(@ats_api_open.cloud_names.map{ |k, v| CLOUD_TABLE.zip([k, v]).to_h})
           when :list
-            return Main.result_object_list(@ats_api_pub.all_servers, fields: %w[id cloud region])
+            return Main.result_object_list(@ats_api_open.all_servers, fields: %w[id cloud region])
           when :show
             if options.get_option(:cloud) || options.get_option(:region)
               server_data = server_by_cloud_region
             else
               server_id = instance_identifier
-              server_data = @ats_api_pub.all_servers.find{ |i| i['id'].eql?(server_id)}
+              server_data = @ats_api_open.all_servers.find{ |i| i['id'].eql?(server_id)}
               raise BadIdentifier.new('server', server_id) if server_data.nil?
             end
             return Main.result_single_object(server_data)
@@ -170,7 +170,9 @@ module Aspera
               # does not work:  base_url:    'https://iam.cloud.ibm.com/identity',
               grant_type:    'urn:ibm:params:oauth:grant-type:apikey',
               response_type: 'cloud_iam',
-              apikey:        options.get_option(:ibm_api_key, mandatory: true)
+              params:        {
+                apikey: options.get_option(:ibm_api_key, mandatory: true)
+              }
             }
           )
         end
@@ -213,31 +215,23 @@ module Aspera
         ACTIONS = %i[cluster access_key api_key aws_trust_policy].freeze
 
         # called for legacy and AoC
-        def execute_action_gen(ats_api_arg)
+        def execute_action
           actions = ACTIONS.dup
-          actions.delete(:api_key) unless ats_api_arg.nil?
+          actions.delete(:api_key) unless @ats_api_auth.nil?
           command = options.get_next_command(actions)
-          @ats_api_pub_v1_cache = ats_api_arg
-          # keep as member variable as we may want to use the api in AoC name space
-          @ats_api_pub = Api::Ats.new
           case command
           when :cluster # display general ATS cluster information, this uses public API, no auth
-            return execute_action_cluster_pub
+            return execute_action_cluster_open
           when :access_key
             return execute_action_access_key
           when :api_key # manage credential to access ATS API
             return execute_action_api_key
           when :aws_trust_policy
-            res = ats_api_pub_v1.read('aws/trustpolicy', {region: options.get_option(:region, mandatory: true)})
+            res = ats_api.read('aws/trustpolicy', {region: options.get_option(:region, mandatory: true)})
             return Main.result_single_object(res)
           else Aspera.error_unexpected_value(command)
           end
         end
-
-        # called for legacy ATS only
-        def execute_action
-          execute_action_gen(nil)
-        end
       end
     end
   end

data/lib/aspera/cli/plugins/base.rb

@@ -136,12 +136,12 @@ module Aspera
         # @param command        [Symbol]  command to execute: create show list modify delete
         # @param display_fields [Array]   fields to display by default
         # @param items_key      [String]  result is in a sub key of the json
-        # @param delete_style   [String]  if set, the delete operation by array in payload
-        # @param id_as_arg      [String]  if set, the id is provided as url argument ?<id_as_arg>=<id>
-        # @param is_singleton   [Boolean] if true, entity is the full path to the resource
-        # @param tclo           [Bool]    if set, :list use paging with total_count, limit, offset
-        # @param block          [Proc]    block to search for identifier based on attribute value
-        # @return result suitable for CLI result
+        # @param delete_style   [String]  If set, the delete operation by array in payload
+        # @param id_as_arg      [String]  If set, the id is provided as url argument ?<id_as_arg>=<id>
+        # @param is_singleton   [Boolean] If `true`, entity is the full path to the resource
+        # @param tclo           [Boolean] If `true`, :list use paging with total_count, limit, offset
+        # @param block          [Proc]    Block to search for identifier based on attribute value
+        # @return [Hash] Result suitable for CLI result
         def entity_execute(
           api:,
           entity:,

data/lib/aspera/cli/plugins/config.rb

@@ -1170,16 +1170,17 @@ module Aspera
         end
 
         # Lookup the corresponding secret for the given URL and usernames
-        # @raise Exception if mandatory and not found
-        def lookup_secret(url:, username:, mandatory: false)
+        # @param url      [String] Server URL
+        # @param username [String] Username
+        # @return [String, nil] Secret if found
+        def lookup_secret(url:, username:)
           secret = options.get_option(:secret)
-          if secret.nil?
+          if secret.eql?('PRESET')
             conf = lookup_preset(url: url, username: username)
             if conf.is_a?(Hash)
               Log.log.debug{"Found preset #{conf} with URL and username"}
               secret = conf['password']
             end
-            raise "Please provide secret for #{username} using option: secret or by setting a preset for #{username}@#{url}." if secret.nil? && mandatory
           end
           return secret
         end

data/lib/aspera/cli/plugins/faspex.rb

@@ -150,7 +150,9 @@ module Aspera
                 grant_method: :generic,
                 base_url:     "#{faspex_api_base}/auth/oauth2",
                 auth:         {type: :basic, username: options.get_option(:username, mandatory: true), password: options.get_option(:password, mandatory: true)},
-                scope:        'admin',
+                params:       {
+                  scope: 'admin'
+                },
                 grant_type:   'password'
               }
             )
@@ -337,12 +339,12 @@ module Aspera
                   skip_ids_persistency = PersistencyActionOnce.new(
                     manager: persistency,
                     data:    skip_ids_data,
-                    id:      IdGenerator.from_list([
+                    id:      IdGenerator.from_list(
                       'faspex_recv',
                       options.get_option(:url, mandatory: true),
                       options.get_option(:username, mandatory: true),
                       options.get_option(:box, mandatory: true).to_s
-                    ])
+                    )
                   )
                 end
                 # get command line parameters

data/lib/aspera/cli/plugins/faspex5.rb

@@ -79,12 +79,14 @@ module Aspera
           )
           return {
             preset_value: {
-              url:           app_url,
-              username:      wiz_username,
-              auth:          :jwt.to_s,
-              private_key:   "@file:#{private_key_path}",
-              client_id:     client_id,
-              client_secret: client_secret
+              url:         app_url,
+              username:    wiz_username,
+              auth:        :jwt.to_s,
+              private_key: "@file:#{private_key_path}",
+              params:      {
+                client_id:     client_id,
+                client_secret: client_secret
+              }
             },
             test_args:    'user profile show'
           }
@@ -198,12 +200,12 @@ module Aspera
             skip_ids_persistency = PersistencyActionOnce.new(
               manager: persistency,
               data:    [],
-              id:      IdGenerator.from_list([
+              id:      IdGenerator.from_list(
                 'faspex_recv',
                 options.get_option(:url, mandatory: true),
                 options.get_option(:username, mandatory: true),
                 options.get_option(:box, mandatory: true)
-              ])
+              )
             )
           end
           packages = []

data/lib/aspera/cli/plugins/faspio.rb

@@ -64,7 +64,9 @@ module Aspera
                   type:            :oauth2,
                   grant_method:    :jwt,
                   base_url:        "#{base_url}/auth",
-                  client_id:       app_client_id,
+                  params:          {
+                    client_id: app_client_id
+                  },
                   use_query:       true,
                   payload:         {
                     iss: app_client_id, # issuer

data/lib/aspera/cli/plugins/node.rb

@@ -415,10 +415,12 @@ module Aspera
               root_file_id = options.get_option(:root_id)
               if root_file_id.nil?
                 ak_info = @api_node.read("access_keys/#{access_key_id}")
+                ak_secret = config.lookup_secret(url: @api_node.base_url, username: ak_info['id'])
                 # change API credentials if different access key
                 if !access_key_id.eql?('self')
+                  Aspera.assert(ak_secret, type: Cli::MissingArgument){"Please provide secret for #{ak_info['id']} using option: secret or by setting a preset for #{ak_info['id']}@#{@api_node.base_url}."}
                   @api_node.auth_params[:username] = ak_info['id']
-                  @api_node.auth_params[:password] = config.lookup_secret(url: @api_node.base_url, username: ak_info['id'], mandatory: true)
+                  @api_node.auth_params[:password] = ak_secret
                 end
                 root_file_id = ak_info['root_file_id']
               end
@@ -517,7 +519,8 @@ module Aspera
             else Aspera.error_unreachable_line
             end
             return Main.result_single_object(result) if command_repo.eql?(:node_info)
-            raise BadArgument, 'Cannot get bearer token if authenticating with secret' unless apifid[:api].auth_params[:type].eql?(:oauth2)
+            Log.dump(:result, result)
+            raise BadArgument, "Cannot get bearer token if authenticating with secret (#{apifid[:api].auth_params[:type]})" unless apifid[:api].auth_params[:type].eql?(:oauth2)
             Aspera.assert(OAuth::Factory.bearer_auth?(result[:password])){'Not using bearer token auth'}
             return Main.result_text(result[:password])
           when :browse
@@ -728,12 +731,12 @@ module Aspera
               skip_ids_persistency = PersistencyActionOnce.new(
                 manager: persistency,
                 data:    iteration_data,
-                id:      IdGenerator.from_list([
+                id:      IdGenerator.from_list(
                   'sync_files',
                   options.get_option(:url, mandatory: true),
                   options.get_option(:username, mandatory: true),
                   async_id
-                ])
+                )
               )
               data.select!{ |l| l['fnid'].to_i > iteration_data.first} unless iteration_data.first.nil?
               iteration_data[0] = data.last['fnid'].to_i unless data.empty?
@@ -873,11 +876,11 @@ module Aspera
                 iteration_persistency = PersistencyActionOnce.new(
                   manager: persistency,
                   data:    [],
-                  id:      IdGenerator.from_list([
+                  id:      IdGenerator.from_list(
                     'node_transfers',
                     options.get_option(:url, mandatory: true),
                     options.get_option(:username, mandatory: true)
-                  ])
+                  )
                 )
                 if transfer_filter.delete('reset')
                   iteration_persistency.data.clear

data/lib/aspera/cli/plugins/oauth.rb

@@ -10,7 +10,7 @@ module Aspera
         # OAuth methods supported
         AUTH_TYPES = %i[web jwt boot].freeze
         # Options used for authentication
-        AUTH_OPTIONS = %i[url auth client_id client_secret scope redirect_uri private_key passphrase username password].freeze
+        AUTH_OPTIONS = %i[url auth client_id client_secret redirect_uri private_key passphrase username password].freeze
         def initialize(**_)
           super
           options.declare(:auth, 'OAuth type of authentication', allowed: AUTH_TYPES, default: :jwt)
@@ -19,22 +19,23 @@ module Aspera
           options.declare(:redirect_uri, 'OAuth (Web) redirect URI for web authentication')
           options.declare(:private_key, 'OAuth (JWT) RSA private key PEM value (prefix file path with @file:)')
           options.declare(:passphrase, 'OAuth (JWT) RSA private key passphrase')
-          options.declare(:scope, 'OAuth scope for API calls')
         end
 
-        # Get all options specified by AUTH_OPTIONS and add.keys
-        # Adds those not nil to the `base`.
+        # Get command line options specified by `AUTH_OPTIONS` and `option.keys` (value is default).
+        # Adds those not nil to the `kwargs`.
         # Instantiate the provided `klass` with those kwargs.
-        # `add` can specify a default value (not `nil`)
-        # @param klass [Class] API object to create
-        # @param base  [Hash] The base options for creation
-        # @param add   [Hash] Additional options, key=symbol, value:default value or nil
-        def new_with_options(klass, base: {}, add: {})
+        # `option` can specify a default value (not `nil`)
+        # @param klass   [Class] API object to create
+        # @param kwargs  [Hash] The fixed keyword arguments for creation
+        # @param option [Hash] Additional options, key=symbol, value:default value or nil
+        # @return [Object] instance of `klass`
+        # @raise [Cli::Error] if a required option is missing
+        def new_with_options(klass, kwargs: {}, option: {})
           klass.new(**
-            (AUTH_OPTIONS + add.keys).each_with_object(base) do |i, m|
+            (AUTH_OPTIONS + option.keys).each_with_object(kwargs) do |i, m|
               v = options.get_option(i)
               m[i] = v unless v.nil?
-              m[i] = add[i] unless !m[i].nil? || add[i].nil?
+              m[i] = option[i] unless !m[i].nil? || option[i].nil?
             end)
         rescue ::ArgumentError => e
           if (m = e.message.match(/missing keyword: :(.*)$/))

data/lib/aspera/cli/plugins/preview.rb

@@ -451,12 +451,12 @@ module Aspera
               iteration_persistency = PersistencyActionOnce.new(
                 manager: persistency,
                 data:    [],
-                id:      IdGenerator.from_list([
+                id:      IdGenerator.from_list(
                   'preview_iteration',
                   command.to_s,
                   options.get_option(:url, mandatory: true),
                   options.get_option(:username, mandatory: true)
-                ])
+                )
               )
             end
             # call processing method specified by command line command

data/lib/aspera/cli/transfer_agent.rb

@@ -31,7 +31,6 @@ module Aspera
         :FILE_LIST_FROM_TRANSFER_SPEC,
         :FILE_LIST_OPTIONS,
         :DEFAULT_TRANSFER_NOTIFY_TEMPLATE
-      TRANSFER_AGENTS = Agent::Factory.instance.list.freeze
 
       class << self
         # @return :success if all sessions statuses returned by "start" are success
@@ -65,7 +64,7 @@ module Aspera
         @opt_mgr.declare(:to_folder, 'Destination folder for transferred files')
         @opt_mgr.declare(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})", default: FILE_LIST_FROM_ARGS)
         @opt_mgr.declare(:src_type, 'Type of file list', allowed: %i[list pair], default: :list)
-        @opt_mgr.declare(:transfer, 'Type of transfer agent', allowed: TRANSFER_AGENTS, default: :direct)
+        @opt_mgr.declare(:transfer, 'Type of transfer agent', allowed: Agent::Factory::ALL.keys, default: :direct)
         @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', allowed: Hash, handler: {o: self, m: :transfer_info})
         @opt_mgr.parse_options!
         @notification_cb = nil

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # For beta add extension : .beta1
     # For dev version add extension : .pre
-    VERSION = '4.25.0.pre2'
+    VERSION = '4.25.0'
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -22,11 +22,11 @@ module Aspera
       'x-cli-envvar',   # [String]       Name of env var
       'x-cli-option',   # [String]       Command line option (starts with "-")
       'x-cli-short',    # [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 (deferred)
+      'x-cli-switch',   # [Boolean]      `true` if option has no arg, else by default option has a value
+      'x-cli-special',  # [Boolean]      `true` if special handling (deferred)
       '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-ts-name',      # [Bool,String]  (async) true if same name in transfer spec, else real name in transfer spec, else ignored
+      'x-ts-name',      # [Boolean,String] (async) true if same name in transfer spec, else real name in transfer spec, else ignored
       'x-ts-convert',   # [String]       (async) Name of methods to convert value from transfer spec to `conf` API.
       'x-deprecation'   # [String]       Deprecation message for doc
     ].freeze
@@ -50,8 +50,8 @@ module Aspera
       private
 
       # Fill default values for some fields in the schema
-      # @param schema [Hash] The JSON schema
-      # @param ascp [Bool] `true` if ascp
+      # @param schema [Hash]    The JSON schema
+      # @param ascp   [Boolean] `true` if ascp
       def validate_schema(schema, ascp: false)
         direct_props = %w[x-cli-option x-cli-envvar x-cli-special].freeze
         schema['properties'].each do |name, info|

data/lib/aspera/dot_container.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'aspera/assert'
+
+module Aspera
+  # Convert dotted-path to/from nested Hash/Array container
+  class DotContainer
+    class << self
+      # Insert extended value `value` into struct `result` at `path`
+      # @param path   [String] Dotted path in container
+      # @param value  [String] Last value to insert
+      # @param result [NilClass, Hash, Array] current value
+      # @return [Hash, Array]
+      def dotted_to_container(path, value, result = nil)
+        # Typed keys
+        keys = path.split(OPTION_DOTTED_SEPARATOR).map{ |k| int_or_string(k)}
+        # Create, or re-use first level container
+        current = (result ||= new_hash_or_array_from_key(keys.first))
+        # walk the path, and create sub-containers if necessary
+        keys.each_cons(2) do |k, next_k|
+          array_requires_integer_index!(current, k)
+          current = (current[k] ||= new_hash_or_array_from_key(next_k))
+        end
+        # Assign value at last index
+        array_requires_integer_index!(current, keys.last)
+        current[keys.last] = value
+        result
+      end
+
+      private
+
+      # Convert `String` to `Integer`, or keep `String` if not `Integer`
+      def int_or_string(value)
+        Integer(value, exception: false) || value
+      end
+
+      # Assert that if `container` is an `Array`, then `index` is an `Integer`
+      # @param container [Hash, Array]
+      # @param index     [String, Integer]
+      def array_requires_integer_index!(container, index)
+        Aspera.assert(container.is_a?(Hash) || index.is_a?(Integer)){'Using String index when Integer index used previously'}
+      end
+
+      # Create a new `Hash` or `Array` depending on type of `key`
+      def new_hash_or_array_from_key(key)
+        key.is_a?(Integer) ? [] : {}
+      end
+    end
+
+    # @param [Hash,Array] Container object
+    def initialize(container)
+      Aspera.assert_type(container, Hash)
+      # tail (pop,push) contains the next element to display
+      # elements are [path, value]
+      @stack = container.empty? ? [] : [[[], container]]
+    end
+
+    # Convert nested Hash/Array container to dotted-path Hash
+    # @return [Hash] Dotted-path Hash
+    def to_dotted
+      result = {}
+      until @stack.empty?
+        path, current = @stack.pop
+        to_insert = nil
+        # empty things are left intact
+        if current.respond_to?(:empty?) && current.empty?
+          to_insert = current
+        else
+          case current
+          when Hash
+            add_elements(path, current)
+          when Array
+            # Array has no nested structures -> list of Strings
+            if current.none?{ |i| i.is_a?(Array) || i.is_a?(Hash)}
+              to_insert = current.map(&:to_s)
+            # Array of Hashes with only 'name' keys -> list of Strings
+            elsif current.all?{ |i| i.is_a?(Hash) && i.keys == ['name']}
+              to_insert = current.map{ |i| i['name']}
+            # Array of Hashes with only 'name' and 'value' keys -> Hash of key/values
+            elsif current.all?{ |i| i.is_a?(Hash) && i.keys.sort == %w[name value]}
+              add_elements(path, current.each_with_object({}){ |i, h| h[i['name']] = i['value']})
+            else
+              add_elements(path, current.each_with_index.map{ |v, i| [i, v]})
+            end
+          else
+            to_insert = current
+          end
+        end
+        result[path.map(&:to_s).join(OPTION_DOTTED_SEPARATOR)] = to_insert unless to_insert.nil?
+      end
+      result
+    end
+
+    private
+
+    # Add elements of enumerator to the @stack, in reverse order
+    def add_elements(path, enum)
+      enum.reverse_each do |key, value|
+        @stack.push([path + [key], value])
+      end
+      nil
+    end
+
+    # "."
+    OPTION_DOTTED_SEPARATOR = '.'
+    private_constant :OPTION_DOTTED_SEPARATOR
+  end
+end

data/lib/aspera/id_generator.rb

@@ -9,19 +9,16 @@ module Aspera
     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
+      # @param ids [Array] the object IDs (can be nested, will be flattened, and nils removed)
       # @return [String] the generated ID
-      def from_list(object_id)
+      def from_list(*ids)
         safe_char = Environment.instance.safe_filename_character
-        if object_id.is_a?(Array)
-          # compact: remove nils
-          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(safe_char)
-        end
-        Aspera.assert_type(object_id, String)
+        # compact: remove nils
+        id = ids.flatten.compact.map do |i|
+          i.is_a?(String) && i.start_with?('https://') ? URI.parse(i).host : i.to_s
+        end.join(safe_char)
         # keep dot for extension only (nicer)
-        return Environment.instance.sanitized_filename(object_id.gsub('.', safe_char)).downcase
+        return Environment.instance.sanitized_filename(id.gsub('.', safe_char)).downcase
       end
     end
   end