aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/cli/preset_manager.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'aspera/cli/extended_value'
+require 'aspera/dot_container'
 require 'aspera/cli/version'
 require 'aspera/cli/info'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/yaml'
 require 'digest'
 require 'yaml'
 
@@ -16,10 +18,12 @@ module Aspera
     class PresetManager
       # Reserved keys in the YAML config file
       module Key
-        CONFIG   = 'config'
-        VERSION  = 'version'
-        DEFAULTS = 'default'
-        GLOBAL   = 'global_common_defaults'
+        CONFIG      = 'config'
+        VERSION     = 'version'
+        DEFAULTS    = 'default'
+        GLOBAL      = 'global_common_defaults'
+        # Prefix for comment/meta keys ignored during preset parsing (e.g. _comment)
+        META_PREFIX = '_'
       end
 
       GLOBAL_DEFAULT_KEYWORD = 'GLOBAL'
@@ -39,7 +43,7 @@ module Aspera
         read_config_file
       end
 
-      attr_reader :config_presets, :use_plugin_defaults
+      attr_reader :config_file, :config_presets, :use_plugin_defaults
       attr_writer :use_plugin_defaults
 
       # ------------------------------------------------------------------
@@ -54,26 +58,26 @@ module Aspera
       # Read and validate the YAML config file.
       # Sets @config_presets and @checksum_on_disk.
       def read_config_file
-        Log.log.debug{"config file is: #{@config_file}".red}
+        Log.log.debug { "config file is: #{@config_file}".red }
         if File.exist?(@config_file)
-          Log.log.debug{"loading #{@config_file}"}
-          @config_presets   = YAML.load_file(@config_file)
+          Log.log.debug { "loading #{@config_file}" }
+          @config_presets   = Yaml.safe_load(File.read(@config_file))
           @checksum_on_disk = checksum
         else
-          Log.log.warn{"No config file found. New configuration file: #{@config_file}"}
+          Log.log.warn { "No config file found. New configuration file: #{@config_file}" }
           @config_presets = {Key::CONFIG => {Key::VERSION => 'new file'}}
-          # @checksum_on_disk remains nil → will be saved on first write
+          # @checksum_on_disk remains nil: will be saved on first write
         end
         validate_config_presets!
       rescue Psych::SyntaxError => e
         Log.log.error('YAML error in config file')
         raise e
       rescue StandardError => e
-        Log.log.debug{"-> #{e.class.name} : #{e}"}
+        Log.log.debug { "-> #{e.class.name} : #{e}" }
         if File.exist?(@config_file)
           new_name = "#{@config_file}.pre#{Cli::VERSION}.manual_conversion_needed"
           File.rename(@config_file, new_name)
-          Log.log.warn{"Renamed config file to #{new_name}."}
+          Log.log.warn { "Renamed config file to #{new_name}." }
           Log.log.warn('Manual Conversion is required. Next time, a new empty file will be created.')
         end
         raise Cli::Error, e.to_s
@@ -82,13 +86,13 @@ module Aspera
       # Save to disk only if content changed since last load/save.
       # @return [Boolean] true if actually written
       def save_if_needed
-        raise Cli::Error, 'no configuration loaded' if @config_presets.nil?
+        Aspera.assert(!@config_presets.nil?, type: Cli::Error) { 'no configuration loaded' }
         current = checksum
         return false if @checksum_on_disk.eql?(current)
         FileUtils.mkdir_p(File.dirname(@config_file))
         Environment.restrict_file_access(File.dirname(@config_file))
-        Log.log.info{"Saving config file: #{@config_file}"}
-        Environment.write_file_restricted(@config_file, force: true){ @config_presets.to_yaml }
+        Log.log.info { "Saving config file: #{@config_file}" }
+        Environment.write_file_restricted(@config_file, force: true) { @config_presets.to_yaml }
         @checksum_on_disk = current
         true
       end
@@ -100,10 +104,10 @@ module Aspera
       # @return [String, nil] name of the default preset for a plugin, or nil
       def plugin_default_name(plugin_name_sym)
         Aspera.assert(!@config_presets.nil?, 'config_presets shall be defined')
-        return nil unless @use_plugin_defaults
-        return nil unless @config_presets.key?(Key::DEFAULTS)
-        Aspera.assert_type(@config_presets[Key::DEFAULTS], Hash){'default section'}
-        return nil unless @config_presets[Key::DEFAULTS].key?(plugin_name_sym.to_s)
+        return unless @use_plugin_defaults
+        return unless @config_presets.key?(Key::DEFAULTS)
+        Aspera.assert_type(@config_presets[Key::DEFAULTS], Hash) { 'default section' }
+        return unless @config_presets[Key::DEFAULTS].key?(plugin_name_sym.to_s)
         default_name = @config_presets[Key::DEFAULTS][plugin_name_sym.to_s]
         unless @config_presets.key?(default_name)
           Log.log.error do
@@ -114,7 +118,7 @@ module Aspera
           end
           raise Cli::Error, "No such preset: #{default_name}"
         end
-        Aspera.assert_type(@config_presets[default_name], Hash, type: Cli::Error){'preset type'}
+        Aspera.assert_type(@config_presets[default_name], Hash, type: Cli::Error) { 'preset type' }
         default_name
       end
 
@@ -123,38 +127,62 @@ module Aspera
       # @param config_name [String]
       # @param include_path [Array] guard against include loops
       def by_name(config_name, include_path = [])
-        raise Cli::Error, 'loop in include' if include_path.include?(config_name)
+        Aspera.assert(!include_path.include?(config_name), type: Cli::Error) { 'loop in include' }
         include_path = include_path.clone
         current = @config_presets
         config_name.split(PRESET_DIG_SEPARATOR).each do |name|
-          Aspera.assert_type(current, Hash, type: Cli::Error){"sub key: #{include_path}"}
+          Aspera.assert_type(current, Hash, type: Cli::Error) { "sub key: #{include_path}" }
           include_path.push(name)
           current = current[name]
-          raise Cli::Error, "Unknown config preset: #{include_path}" if current.nil?
+          Aspera.assert(!current.nil?, type: Cli::Error) { "Unknown config preset: #{include_path}" }
         end
         current = self.class.deep_clone(current) unless current.is_a?(String)
+        current.delete_if { |k, _| k.to_s.start_with?(Key::META_PREFIX) } if current.is_a?(Hash)
         ExtendedValue.instance.evaluate(current, context: 'preset')
       end
 
       # Set a single key in a preset hash (creates the preset if absent).
+      # If param_name contains dots, it is treated as a dot-path and deep-merged into the preset.
+      # If param_value is nil, the key is deleted instead.
       def set_key(preset, param_name, param_value)
-        Aspera.assert_type(param_name, String, Symbol){'parameter'}
+        Aspera.assert_type(param_name, String, Symbol) { 'parameter' }
         param_name = param_name.to_s
         selected = @config_presets[preset]
         if selected.nil?
-          Log.log.debug{"Unknown preset name: #{preset}, initializing"}
+          Log.log.debug { "Unknown preset name: #{preset}, initializing" }
           selected = @config_presets[preset] = {}
         end
-        Aspera.assert_type(selected, Hash){"#{preset}.#{param_name}"}
-        if selected.key?(param_name)
-          if selected[param_name].eql?(param_value)
-            Log.log.warn{"keeping same value for #{preset}: #{param_name}: #{param_value}"}
-            return
+        Aspera.assert_type(selected, Hash) { "#{preset}.#{param_name}" }
+        if param_name.include?(DotContainer::SEPARATOR)
+          keys = param_name.split(DotContainer::SEPARATOR)
+          # Navigate to the parent hash
+          parent = keys[0..-2].reduce(selected) do |h, k|
+            break nil unless h.is_a?(Hash)
+            h[k]
           end
-          Log.log.warn{"overwriting value for #{param_name}: #{selected[param_name]}"}
+          if param_value.nil?
+            parent&.delete(keys.last)
+            Log.log.info("Deleted: #{preset}: #{param_name}")
+          else
+            # dot-path: build nested hash and deep-merge into existing preset
+            nested = DotContainer.dotted_to_container(keys, param_value)
+            self.class.deep_merge!(selected, nested)
+            Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
+          end
+        elsif param_value.nil?
+          selected.delete(param_name)
+          Log.log.info("Deleted: #{preset}: #{param_name}")
+        else
+          if selected.key?(param_name)
+            if selected[param_name].eql?(param_value)
+              Log.log.warn { "keeping same value for #{preset}: #{param_name}: #{param_value}" }
+              return
+            end
+            Log.log.warn { "overwriting value for #{param_name}: #{selected[param_name]}" }
+          end
+          selected[param_name] = param_value
+          Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
         end
-        selected[param_name] = param_value
-        Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
         nil
       end
 
@@ -191,7 +219,7 @@ module Aspera
       # @return [Hash, nil]
       def lookup_preset(url:, username:)
         url = canonical_url(url)
-        Log.log.debug{"Lookup preset for #{username}@#{url}"}
+        Log.log.debug { "Lookup preset for #{username}@#{url}" }
         @config_presets.each_value do |v|
           next unless v.is_a?(Hash)
           conf_url = v['url'].is_a?(String) ? canonical_url(v['url']) : nil
@@ -208,11 +236,26 @@ module Aspera
         def deep_clone(val)
           Marshal.load(Marshal.dump(val))
         end
+
+        # Recursively merge src into dst in place (dst wins on scalar conflicts).
+        # @param dst [Hash] destination (modified in place)
+        # @param src [Hash] source
+        # @return [Hash] dst
+        def deep_merge!(dst, src)
+          src.each do |k, v|
+            if dst.key?(k) && dst[k].is_a?(Hash) && v.is_a?(Hash)
+              deep_merge!(dst[k], v)
+            else
+              dst[k] = v
+            end
+          end
+          dst
+        end
       end
 
       private
 
-      # Normalise a URL for comparison
+      # Normalize a URL for comparison
       def canonical_url(url)
         url.chomp('/').sub(%r{^(https://[^/]+):443$}, '\1')
       end
@@ -220,11 +263,11 @@ module Aspera
       # Structural validation + compatibility fixes on @config_presets
       def validate_config_presets!
         Log.dump(:available_presets, @config_presets, level: :trace1)
-        Aspera.assert_type(@config_presets, Hash){'config file YAML'}
-        Aspera.assert(@config_presets.key?(Key::CONFIG)){"Cannot find key: #{Key::CONFIG}"}
+        Aspera.assert_type(@config_presets, Hash) { 'config file YAML' }
+        Aspera.assert(@config_presets.key?(Key::CONFIG)) { "Cannot find key: #{Key::CONFIG}" }
         version = @config_presets[Key::CONFIG][Key::VERSION]
-        raise Cli::Error, 'No version found in config section.' if version.nil?
-        Log.log.debug{"conf version: #{version}"}
+        Aspera.assert(!version.nil?, type: Cli::Error) { 'No version found in config section.' }
+        Log.log.debug { "conf version: #{version}" }
         # Fix bug in 4.4 (creating key "true" in "default" preset)
         @config_presets[Key::DEFAULTS].delete(true) if @config_presets[Key::DEFAULTS].is_a?(Hash)
         # Stamp with current version

data/lib/aspera/cli/result.rb

@@ -34,7 +34,7 @@ module Aspera
       # Base implementation handles common formats: text, nagios, ruby, json, jsonpp, yaml
       # Subclasses should call super first, then handle their specific formats
       # @param formatter [Formatter] The formatter to use
-      # @return [void]
+      # @return [nil]
       def format(formatter)
         # Apply field filtering once for formats that need it
         filtered_data = formatter.filter_list_on_fields(@data)
@@ -56,7 +56,7 @@ module Aspera
             formatter.display_message(:data, formatter.special_format('null (no image)'))
             return
           end
-          Aspera.assert_type(@data, String){'image: URL or blob'}
+          Aspera.assert_type(@data, String) { 'image: URL or blob' }
           # Check if URL
           data =
             begin
@@ -72,16 +72,18 @@ module Aspera
             rescue URI::InvalidURIError
               @data
             end
-          # try base64
-          data = begin
-            Base64.strict_decode64(data)
-          rescue
-            data
+          unless data.eql?(:done)
+            # try base64
+            data = begin
+              Base64.strict_decode64(data)
+            rescue ArgumentError
+              data
+            end
+            # here, data is the image blob
+            formatter.display_message(:data, Preview::Terminal.build(data, **formatter.image_options))
           end
-          # here, data is the image blob
-          formatter.display_message(:data, Preview::Terminal.build(data, **formatter.image_options)) unless data.eql?(:done)
         else
-          Aspera.error_unexpected_value(formatter.format_type){'format'}
+          Aspera.error_unexpected_value(formatter.format_type) { 'format' }
         end
       end
     end
@@ -128,7 +130,7 @@ module Aspera
       # Status result (success, complete, etc.)
       class Status < Result
         def initialize(data)
-          Aspera.assert_type(data, String){'status result data'}
+          Aspera.assert_type(data, String) { 'status result data' }
           super(data: data)
         end
 
@@ -155,7 +157,7 @@ module Aspera
       # Text result
       class Text < Result
         def initialize(data)
-          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError){'text result data'}
+          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError) { 'text result data' }
           super(data: data)
         end
 
@@ -183,13 +185,13 @@ module Aspera
       # Image result (URL or blob)
       class Image < Result
         def initialize(data)
-          Aspera.assert_type(data, String, NilClass){'image result data'}
+          Aspera.assert_type(data, String, NilClass) { 'image result data' }
           super(data: data)
         end
 
         def format(formatter)
           # Force image format for Image results
-          formatter.set_format_type(:image)
+          formatter.format_type = :image
           super
         end
       end
@@ -197,7 +199,7 @@ module Aspera
       # Single object result (Hash)
       class SingleObject < Result
         def initialize(data, fields: nil)
-          Aspera.assert_type(data, Hash){'single object result data'}
+          Aspera.assert_type(data, Hash) { 'single object result data' }
           super(data: data, fields: fields)
         end
 
@@ -212,7 +214,7 @@ module Aspera
             # Create an Image result and format it
             Image.new(@data[fields.first]).format(formatter)
           when :table, :csv
-            Aspera.assert_type(@data, Hash){'result'}
+            Aspera.assert_type(@data, Hash) { 'result' }
             if @data.empty?
               formatter.display_message(:data, formatter.special_format('empty dict'))
             else
@@ -234,9 +236,8 @@ module Aspera
         # @param fields [Array<String>, Proc, nil] Fields to display in table/csv format
         # @param total [Integer, nil] Total number of items available (for pagination display)
         def initialize(data, fields: nil, total: nil)
-          Aspera.assert_type(data, Array){'object list result data'}
-          raise ArgumentError, 'Object list result requires Array of Hash' unless data.all?(Hash)
-          Aspera.assert_type(total, Integer, NilClass){'total'}
+          Aspera.assert_array_all(data, Hash, type: ArgumentError) { 'object list result data' }
+          Aspera.assert_type(total, Integer, NilClass) { 'total' }
           super(data: data, fields: fields)
           @total = total
         end
@@ -249,8 +250,8 @@ module Aspera
             Aspera.assert(@data.length == 1, 'image display requires a single result', type: Cli::BadArgument)
             SingleObject.new(@data.first).format(formatter)
           when :table, :csv
-            Aspera.assert_array_all(@data, Hash){'result'}
-            data = formatter.flat_hash? ? @data.map{ |obj| DotContainer.new(obj).to_dotted} : @data
+            Aspera.assert_array_all(@data, Hash) { 'result' }
+            data = formatter.flat_hash? ? @data.map { |obj| DotContainer.new(obj).to_dotted } : @data
             formatter.display_table(data, formatter.compute_fields(data, @fields), single: false)
           else
             super
@@ -263,8 +264,8 @@ module Aspera
         attr_reader :name
 
         def initialize(data, name: 'id')
-          Aspera.assert_type(data, Array){'value list result data'}
-          Aspera.assert_type(name, String){'value list name'}
+          Aspera.assert_type(data, Array) { 'value list result data' }
+          Aspera.assert_type(name, String) { 'value list name' }
           super(data: data)
           @name = name
         end
@@ -272,7 +273,17 @@ module Aspera
         def format(formatter)
           case formatter.format_type
           when :table, :csv
-            formatter.display_table(@data.map{ |i| {@name => i}}, [@name])
+            formatter.display_table(@data.map { |i| {@name => i} }, [@name])
+          when :text
+            formatter.display_message(:data, @data.join("\n"))
+          when :ruby
+            formatter.display_message(:data, PP.pp(@data, +''))
+          when :json
+            formatter.display_message(:data, JSON.generate(@data))
+          when :jsonpp
+            formatter.display_message(:data, JSON.pretty_generate(@data))
+          when :yaml
+            formatter.display_message(:data, YAML.dump(@data))
           else
             super
           end
@@ -280,6 +291,47 @@ module Aspera
       end
 
       class << self
+        # Execute a bulk operation over a list of already-resolved items and return a CLI result.
+        # This is a pure helper: it reads nothing from the CLI.
+        # @param items   [Array]   List of items to process (one element when non-bulk)
+        # @param is_bulk [Boolean] Whether the caller is in bulk mode
+        # @param command [Symbol]  Operation name (:create, :delete, …) used to build the past-tense status string
+        # @param id_result [String] Key in the result Hash used as item identifier
+        # @param fields   [Object] Fields hint passed to the Result constructor (non-bulk only, when not :default)
+        # @param bfail    [Boolean] When true, re-raise errors; when false, capture them as a status string
+        # @yieldparam item [Object] Each item in +items+
+        # @yieldreturn [Hash, Array, nil] REST response; a Hash replaces the default id-keyed result
+        # @return [Result::ObjectList, Result::SingleObject]
+        def bulk(items, is_bulk:, command:, id_result: 'id', fields: :default, bfail: true)
+          Aspera.assert(block_given?, 'missing block')
+          Log.log.warn('Empty list given for bulk operation') if items.empty?
+          Log.dump(:bulk_operation, items)
+          result_list = []
+          items.each do |item|
+            result = {id_result => item}
+            begin
+              res = yield(item)
+              result = res if res.is_a?(Hash)
+              # TODO: remove when faspio gw api fixes this
+              result = res.first if res.is_a?(Array) && res.first.is_a?(Hash)
+              # Ensure the id_result key is always present even when the API response uses a different key name
+              result[id_result] = item unless result.key?(id_result)
+              result['status'] = "#{command}#{'e' unless command.to_s.end_with?('e')}d".gsub(/yed$/, 'ied')
+            rescue StandardError => e
+              raise e if bfail
+              result['status'] = e.to_s
+            end
+            result_list.push(result)
+          end
+          display_fields = [id_result, 'status']
+          if is_bulk
+            return ObjectList.new(result_list, fields: display_fields)
+          else
+            display_fields = fields unless fields.eql?(:default)
+            return SingleObject.new(result_list.first, fields: display_fields)
+          end
+        end
+
         # Class method to automatically determine result type from data
         # @param data [Object] the data to analyze and format
         # @return [Result]
@@ -297,11 +349,11 @@ module Aspera
             unsupported_types = all_types - scalar_types
             return ValueList.new(data, name: 'list') if unsupported_types.empty?
 
-            Aspera.error_unexpected_value(unsupported_types){'list item types'}
+            Aspera.error_unexpected_value(unsupported_types) { 'list item types' }
           when String, Integer, Symbol
             Text.new(data)
           else
-            Aspera.error_unexpected_value(data.class.name){'result type'}
+            Aspera.error_unexpected_value(data.class.name) { 'result type' }
           end
         end
       end