aspera-cli 4.26.0 → 4.26.2

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

@@ -198,7 +198,7 @@ module Aspera
         # @param destination [String, nil] local destination root for receive operations
         # @return [Object] transfer result returned by [`Main.result_transfer`](lib/aspera/cli/main.rb)
         def do_transfer(direction, folder_id, source_filename, destination = '/')
-          Aspera.assert(!(destination.nil? && direction.eql?(Transfer::Spec::DIRECTION_RECEIVE)))
+          Aspera.assert(!(destination.nil? && direction.eql?(Transfer::Spec::DIRECTION_RECEIVE)), 'destination must be set for receive direction')
           t_spec = @api_node.transfer_spec_gen4(folder_id, direction, {
             'paths' => [{'source' => source_filename}],
             'tags'  => {Transfer::Spec::TAG_RESERVED => {PREV_GEN_TAG => true}}
@@ -206,7 +206,7 @@ module Aspera
           # Force the destination on the transfer agent object.
           # Setting `t_spec['destination_root']` directly would later be overwritten.
           transfer.user_transfer_spec['destination_root'] = destination
-          Main.result_transfer(transfer.start(t_spec))
+          Runner.result_transfer(transfer.start(t_spec))
         end
 
         # Populate generation metadata for a source file available on the local filesystem.
@@ -323,7 +323,7 @@ module Aspera
           # create folder if needed
           FileUtils.mkdir_p(local_entry_preview_dir)
           if @access_remote
-            Aspera.assert(!entry['parent_file_id'].nil?){'missing parent_file_id in entry'}
+            Aspera.assert(!entry['parent_file_id'].nil?, 'missing parent_file_id in entry')
             #  download original file to temp folder
             do_transfer(Transfer::Spec::DIRECTION_RECEIVE, entry['parent_file_id'], entry['name'], @tmp_folder)
           end
@@ -471,7 +471,7 @@ module Aspera
               end
             @filter_block = Api::Node.file_matcher_from_argument(options)
             scan_folder_files(folder_info, scan_path)
-            return Main.result_status('scan finished')
+            return Result::Status.new('scan finished')
           when :events, :trevents
             @filter_block = Api::Node.file_matcher_from_argument(options)
             iteration_persistency = nil
@@ -489,15 +489,15 @@ module Aspera
             end
             # call processing method specified by command line command
             send(:"process_#{command}", iteration_persistency)
-            return Main.result_status("#{command} finished")
+            return Result::Status.new("#{command} finished")
           when :check
-            return Main.result_status('Tools validated')
+            return Result::Status.new('Tools validated')
           when :test
             source = options.get_next_argument('source file')
             format = options.get_next_argument('format', accept_list: Aspera::Preview::Generator::PREVIEW_FORMATS, default: :png)
             generated_file_path = preview_filename(format, options.get_option(:base))
             Aspera::Preview::Generator.new(source, generated_file_path, @gen_options, @tmp_folder).generate
-            return Main.result_status("generated: #{generated_file_path}")
+            return Result::Status.new("generated: #{generated_file_path}")
           when :show
             source = options.get_next_argument('source file')
             # terminal_options = options.get_next_argument('options', validation: Hash, default: {}).symbolize_keys
@@ -505,8 +505,8 @@ module Aspera
             Aspera::Preview::Generator.new(source, generated_file_path, @gen_options, @tmp_folder).generate
             formatter.display_status("generated: #{generated_file_path}")
             # formatter.display_status(Aspera::Preview::Terminal.build(File.read(generated_file_path), **terminal_options))
-            # return Main.result_status("generated: #{generated_file_path}")
-            return Main.result_image(UriReader.file_url(generated_file_path))
+            # return Result::Status.new("generated: #{generated_file_path}")
+            return Result::Image.new(UriReader.file_url(generated_file_path))
           else Aspera.error_unexpected_value(command)
           end
         ensure

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

@@ -165,7 +165,7 @@ module Aspera
           end
           # if user provided transfer spec has a token, we will use bypass keys
           cred_set = true if transfer.user_transfer_spec['token'].is_a?(String)
-          Aspera.assert(cred_set, type: BadArgument){'Either password, key , or transfer spec token must be provided'}
+          Aspera.assert(cred_set, 'Either password, key , or transfer spec token must be provided', type: BadArgument)
           return server_transfer_spec
         end
 
@@ -173,7 +173,7 @@ module Aspera
           case command
           when :upload, :download
             transfer_spec['direction'] = Transfer::Spec.transfer_type_to_direction(command)
-            return Main.result_transfer(transfer.start(transfer_spec))
+            return Runner.result_transfer(transfer.start(transfer_spec))
           when :sync
             # lets ignore the arguments provided by execute_sync_action, we just give the transfer spec
             return execute_sync_action{transfer_spec}
@@ -218,7 +218,7 @@ module Aspera
               end
             else Aspera.error_unexpected_value(command_nagios)
             end
-            Main.result_object_list(nagios.status_list)
+            Result::ObjectList.new(nagios.status_list)
           when *TRANSFER_COMMANDS
             return execute_transfer(command, server_transfer_spec)
           when *AsCmd::OPERATIONS
@@ -228,13 +228,13 @@ module Aspera
               result = ascmd.execute_single(command, command_arguments)
               case command
               when :mkdir, :mv, :cp, :rm
-                return Main.result_success
+                return Result::Success.new
               when :ls
-                return Main.result_object_list(result.map(&:stringify_keys), fields: %w[zmode zuid zgid size mtime name])
+                return Result::ObjectList.new(result.map(&:stringify_keys), fields: %w[zmode zuid zgid size mtime name])
               when :df
-                return Main.result_object_list(result.map(&:stringify_keys))
+                return Result::ObjectList.new(result.map(&:stringify_keys))
               when :du, :md5sum, :info
-                return Main.result_single_object(result.stringify_keys)
+                return Result::SingleObject.new(result.stringify_keys)
               end
             rescue AsCmd::Error => e
               raise Cli::BadArgument, e.extended_message

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

@@ -118,9 +118,9 @@ module Aspera
             else
               nagios.add_critical('API', health[:api].to_s)
             end
-            Main.result_object_list(nagios.status_list)
+            Result::ObjectList.new(nagios.status_list)
           when :info
-            return Main.result_single_object(basic_auth_api(NODE_API_PATH).read('info', headers: {'Content-Type'=>'application/json'}))
+            return Result::SingleObject.new(basic_auth_api(NODE_API_PATH).read('info', headers: {'Content-Type'=>'application/json'}))
           when :files
             api_shares_node = basic_auth_api(NODE_API_PATH)
             repo_command = options.get_next_command(Node::COMMANDS_SHARES)

data/lib/aspera/cli/preset_manager.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require 'aspera/cli/extended_value'
+require 'aspera/cli/version'
+require 'aspera/cli/info'
+require 'aspera/log'
+require 'aspera/assert'
+require 'digest'
+require 'yaml'
+
+module Aspera
+  module Cli
+    # Manages the YAML config file and all preset-related operations.
+    # Extracted from Plugins::Config so it can be referenced independently
+    # via Context#presets without coupling to the plugin machinery.
+    class PresetManager
+      # Reserved keys in the YAML config file
+      module Key
+        CONFIG   = 'config'
+        VERSION  = 'version'
+        DEFAULTS = 'default'
+        GLOBAL   = 'global_common_defaults'
+      end
+
+      GLOBAL_DEFAULT_KEYWORD = 'GLOBAL'
+      CONF_GLOBAL_SYM        = :config
+      # Separator for dot-notation digging into presets
+      PRESET_DIG_SEPARATOR = '.'
+
+      private_constant :PRESET_DIG_SEPARATOR
+
+      # @param config_file [String]       absolute path to the YAML config file
+      # @param use_plugin_defaults [Boolean] if false, skip default preset lookup
+      def initialize(config_file:, use_plugin_defaults: true)
+        @config_file         = config_file
+        @use_plugin_defaults = use_plugin_defaults
+        @config_presets      = {}
+        @checksum_on_disk    = nil
+        read_config_file
+      end
+
+      attr_reader :config_presets, :use_plugin_defaults
+      attr_writer :use_plugin_defaults
+
+      # ------------------------------------------------------------------
+      # File I/O
+      # ------------------------------------------------------------------
+
+      # @return [String] SHA1 of current in-memory presets
+      def checksum
+        Digest::SHA1.hexdigest(JSON.generate(@config_presets))
+      end
+
+      # 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}
+        if File.exist?(@config_file)
+          Log.log.debug{"loading #{@config_file}"}
+          @config_presets   = YAML.load_file(@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
+        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}"}
+        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('Manual Conversion is required. Next time, a new empty file will be created.')
+        end
+        raise Cli::Error, e.to_s
+      end
+
+      # 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?
+        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 }
+        @checksum_on_disk = current
+        true
+      end
+
+      # ------------------------------------------------------------------
+      # Preset read/write helpers
+      # ------------------------------------------------------------------
+
+      # @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)
+        default_name = @config_presets[Key::DEFAULTS][plugin_name_sym.to_s]
+        unless @config_presets.key?(default_name)
+          Log.log.error do
+            "Default config name [#{default_name}] specified for plugin [#{plugin_name_sym}], but it does not exist in config file.\n" \
+              "Please fix: either create preset:\n" \
+              "#{Info::CMD_NAME} config id #{default_name} init @json:'{}'\n" \
+              "or remove default:\n#{Info::CMD_NAME} config id default remove #{plugin_name_sym}"
+          end
+          raise Cli::Error, "No such preset: #{default_name}"
+        end
+        Aspera.assert_type(@config_presets[default_name], Hash, type: Cli::Error){'preset type'}
+        default_name
+      end
+
+      # Resolve and return a deep-cloned, extended copy of a named preset.
+      # Supports dot-notation (e.g. "outer.inner").
+      # @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)
+        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?
+        end
+        current = self.class.deep_clone(current) unless current.is_a?(String)
+        ExtendedValue.instance.evaluate(current, context: 'preset')
+      end
+
+      # Set a single key in a preset hash (creates the preset if absent).
+      def set_key(preset, param_name, param_value)
+        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"}
+          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
+          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}")
+        nil
+      end
+
+      # @return [String] name of the global default preset, creating it if needed
+      def global_default_preset
+        result = plugin_default_name(CONF_GLOBAL_SYM)
+        if result.nil?
+          result = Key::GLOBAL
+          set_key(Key::DEFAULTS, CONF_GLOBAL_SYM, result)
+        end
+        result
+      end
+
+      # Set param in the global defaults preset
+      def set_global_default(key, value)
+        set_key(global_default_preset, key, value)
+      end
+
+      # Create / overwrite a preset and optionally set it as plugin default.
+      def defaults_set(plugin_name, preset_name, preset_values, option_default, option_override)
+        @config_presets[Key::DEFAULTS] ||= {}
+        raise Cli::Error, "A default configuration already exists for plugin '#{plugin_name}' (use --override=yes or --default=no)" \
+          if !option_override && option_default && @config_presets[Key::DEFAULTS].key?(plugin_name)
+        raise Cli::Error, "Preset already exists: #{preset_name}  (use --override=yes or provide alternate name on command line)" \
+          if !option_override && @config_presets.key?(preset_name)
+        if option_default
+          Log.log.info("Setting config preset as default for #{plugin_name}")
+          @config_presets[Key::DEFAULTS][plugin_name.to_s] = preset_name
+        end
+        @config_presets[preset_name] = preset_values
+      end
+
+      # Find the first preset whose url+username match
+      # @return [Hash, nil]
+      def lookup_preset(url:, username:)
+        url = canonical_url(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
+          return self.class.deep_clone(v) if conf_url.eql?(url) && v['username'].eql?(username)
+        end
+        nil
+      end
+
+      # ------------------------------------------------------------------
+      # Class helpers
+      # ------------------------------------------------------------------
+
+      class << self
+        def deep_clone(val)
+          Marshal.load(Marshal.dump(val))
+        end
+      end
+
+      private
+
+      # Normalise a URL for comparison
+      def canonical_url(url)
+        url.chomp('/').sub(%r{^(https://[^/]+):443$}, '\1')
+      end
+
+      # 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}"}
+        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}"}
+        # 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
+        @config_presets[Key::CONFIG][Key::VERSION] = Cli::VERSION
+      end
+    end
+  end
+end

data/lib/aspera/cli/result.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require 'aspera/assert'
+require 'aspera/nagios'
+require 'aspera/log'
+require 'aspera/environment'
+require 'aspera/uri_reader'
+require 'aspera/preview/terminal'
+require 'aspera/dot_container'
+require 'base64'
+require 'uri'
+require 'pp'
+require 'json'
+require 'yaml'
+
+module Aspera
+  module Cli
+    # Base class for all result types
+    # Each result type is now a separate class instead of using a type field
+    class Result
+      attr_reader :data, :fields
+
+      # @param data [Object,nil] The result data
+      # @param fields [Object] Specification of fields to include
+      def initialize(data: nil, fields: nil)
+        @data = data
+        @fields = fields
+      end
+
+      # Format this result using the provided formatter
+      # This method implements the Visitor pattern, allowing each Result subclass
+      # to define how it should be formatted without the Formatter needing to know
+      # about all Result types.
+      # 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]
+      def format(formatter)
+        # Apply field filtering once for formats that need it
+        filtered_data = formatter.filter_list_on_fields(@data)
+        case formatter.format_type
+        when :text
+          formatter.display_message(:data, @data.to_s)
+        when :nagios
+          Nagios.process(@data)
+        when :ruby
+          formatter.display_message(:data, PP.pp(filtered_data, +''))
+        when :json
+          formatter.display_message(:data, JSON.generate(filtered_data))
+        when :jsonpp
+          formatter.display_message(:data, JSON.pretty_generate(filtered_data))
+        when :yaml
+          formatter.display_message(:data, YAML.dump(filtered_data))
+        when :image
+          if @data.nil?
+            formatter.display_message(:data, formatter.special_format('null (no image)'))
+            return
+          end
+          Aspera.assert_type(@data, String){'image: URL or blob'}
+          # Check if URL
+          data =
+            begin
+              # just validate
+              URI.parse(@data)
+              if Environment.instance.url_method.eql?(:text)
+                UriReader.read(@data)
+              else
+                Environment.instance.open_uri(@data)
+                formatter.display_message(:info, "Opened URL in browser: #{@data}")
+                :done
+              end
+            rescue URI::InvalidURIError
+              @data
+            end
+          # try base64
+          data = begin
+            Base64.strict_decode64(data)
+          rescue
+            data
+          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
+      end
+    end
+
+    # Special result types - each has its own class
+    class Result
+      # Base class for special results
+      # The type is automatically derived from the class name
+      class Special < Result
+        def initialize
+          # Convert class name to symbol: Empty -> :empty, Nothing -> :nothing
+          type = self.class.name.split('::').last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+          super(data: type)
+        end
+
+        def format(formatter)
+          case formatter.format_type
+          when :text, :nagios, :ruby, :json, :jsonpp, :yaml
+            formatter.display_message(:data, @data.to_s)
+          when :table, :csv
+            if @data.eql?(:nothing)
+              Log.log.debug('no result expected')
+              return
+            end
+            formatter.display_message(:info, formatter.special_format(@data.to_s))
+          else
+            super
+          end
+        end
+      end
+
+      # Empty list result
+      class Empty < Special
+      end
+
+      # Nothing expected result
+      class Nothing < Special
+      end
+
+      # Null result
+      class Null < Special
+      end
+
+      # Status result (success, complete, etc.)
+      class Status < Result
+        def initialize(data)
+          Aspera.assert_type(data, String){'status result data'}
+          super(data: data)
+        end
+
+        def format(formatter)
+          data = formatter.hide_secrets? ? formatter.hide_secrets_in_string(@data) : @data
+          case formatter.format_type
+          when :text, :nagios, :ruby, :json, :jsonpp, :yaml
+            formatter.display_message(:data, data)
+          when :table, :csv
+            formatter.display_message(:info, data)
+          else
+            super
+          end
+        end
+      end
+
+      # Success status result
+      class Success < Status
+        def initialize
+          super('complete')
+        end
+      end
+
+      # Text result
+      class Text < Result
+        def initialize(data)
+          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError){'text result data'}
+          super(data: data)
+        end
+
+        def format(formatter)
+          data = @data.is_a?(String) && formatter.hide_secrets? ? formatter.hide_secrets_in_string(@data) : @data
+          case formatter.format_type
+          when :text, :nagios
+            formatter.display_message(:data, data.to_s)
+          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))
+          when :table, :csv
+            formatter.display_message(:data, data)
+          else
+            super
+          end
+        end
+      end
+
+      # Image result (URL or blob)
+      class Image < Result
+        def initialize(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)
+          super
+        end
+      end
+
+      # Single object result (Hash)
+      class SingleObject < Result
+        def initialize(data, fields: nil)
+          Aspera.assert_type(data, Hash){'single object result data'}
+          super(data: data, fields: fields)
+        end
+
+        def format(formatter)
+          case formatter.format_type
+          when :image
+            # Extract single field for image display
+            data_array = [@data]
+            fields = formatter.compute_fields(data_array, @fields)
+            Aspera.assert(fields.length == 1, 'select a single field to display', type: Cli::BadArgument)
+            Aspera.assert(@data.key?(fields.first), 'no such field', type: Cli::BadArgument)
+            # Create an Image result and format it
+            Image.new(@data[fields.first]).format(formatter)
+          when :table, :csv
+            Aspera.assert_type(@data, Hash){'result'}
+            if @data.empty?
+              formatter.display_message(:data, formatter.special_format('empty dict'))
+            else
+              data = formatter.flat_hash? ? DotContainer.new(@data).to_dotted : @data
+              formatter.display_table([data], formatter.compute_fields([data], @fields), single: true)
+            end
+          else
+            super
+          end
+        end
+      end
+
+      # Object list result (Array of Hash)
+      # @note The +total+ parameter is used to display pagination information (e.g., "Items: 10/100")
+      class ObjectList < Result
+        attr_reader :total
+
+        # @param data [Array<Hash>] Array of hash objects to display
+        # @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'}
+          super(data: data, fields: fields)
+          @total = total
+        end
+
+        def format(formatter)
+          formatter.display_item_count(@data.length, @total)
+          case formatter.format_type
+          when :image
+            # Extract single field for image display
+            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
+            formatter.display_table(data, formatter.compute_fields(data, @fields), single: false)
+          else
+            super
+          end
+        end
+      end
+
+      # Value list result (Array of values with a name)
+      class ValueList < Result
+        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'}
+          super(data: data)
+          @name = name
+        end
+
+        def format(formatter)
+          case formatter.format_type
+          when :table, :csv
+            formatter.display_table(@data.map{ |i| {@name => i}}, [@name])
+          else
+            super
+          end
+        end
+      end
+
+      class << self
+        # Class method to automatically determine result type from data
+        # @param data [Object] the data to analyze and format
+        # @return [Result]
+        def auto(data)
+          case data
+          when NilClass
+            Null.new
+          when Hash
+            SingleObject.new(data)
+          when Array
+            all_types = data.map(&:class).uniq
+            return ObjectList.new(data) if all_types.eql?([Hash])
+
+            scalar_types = [String, Integer, Symbol]
+            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'}
+          when String, Integer, Symbol
+            Text.new(data)
+          else
+            Aspera.error_unexpected_value(data.class.name){'result type'}
+          end
+        end
+      end
+    end
+  end
+end