aspera-cli 4.26.2 → 4.27.0

data/lib/aspera/cli/preset_manager.rb

@@ -5,6 +5,7 @@ require 'aspera/cli/version'
 require 'aspera/cli/info'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/yaml'
 require 'digest'
 require 'yaml'
 
@@ -39,7 +40,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
 
       # ------------------------------------------------------------------
@@ -57,12 +58,12 @@ module Aspera
         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)
+          @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}"}
           @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
@@ -82,13 +83,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 }
+        Environment.write_file_restricted(@config_file, force: true){@config_presets.to_yaml}
         @checksum_on_disk = current
         true
       end
@@ -100,10 +101,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)
+        return unless @use_plugin_defaults
+        return 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 @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
@@ -123,14 +124,14 @@ 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}"}
           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)
         ExtendedValue.instance.evaluate(current, context: 'preset')
@@ -212,7 +213,7 @@ module Aspera
 
       private
 
-      # Normalise a URL for comparison
+      # Normalize a URL for comparison
       def canonical_url(url)
         url.chomp('/').sub(%r{^(https://[^/]+):443$}, '\1')
       end
@@ -223,7 +224,7 @@ module Aspera
         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?
+        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)

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)
@@ -72,14 +72,16 @@ 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'}
         end
@@ -189,7 +191,7 @@ module Aspera
 
         def format(formatter)
           # Force image format for Image results
-          formatter.set_format_type(:image)
+          formatter.format_type = :image
           super
         end
       end
@@ -234,8 +236,7 @@ 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_array_all(data, Hash, type: ArgumentError){'object list result data'}
           Aspera.assert_type(total, Integer, NilClass){'total'}
           super(data: data, fields: fields)
           @total = total
@@ -273,6 +274,16 @@ module Aspera
           case formatter.format_type
           when :table, :csv
             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,45 @@ 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)
+              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]