aspera-cli 4.27.5 → 4.28.0

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

@@ -60,6 +60,15 @@ module Aspera
               rescue => e
                 e
               end
+            # Native JSON health check endpoint (no auth required)
+            result[:system] =
+              begin
+                Rest::Client
+                  .new(base_url: url)
+                  .read('health_check')
+              rescue => e
+                e
+              end
             result
           end
 
@@ -79,10 +88,12 @@ module Aspera
         # @param app_url [String] Tested URL
         # @return [Hash] :preset_value, :test_args
         def wizard(wizard, app_url)
+          username = options.get_option(:username, mandatory: true)
           return {
+            preset_ids:   [username],
             preset_value: {
               url:      app_url,
-              username: options.get_option(:username, mandatory: true),
+              username: username,
               password: options.get_option(:password, mandatory: true)
             },
             test_args:    'files browse /'
@@ -99,10 +110,14 @@ module Aspera
 
         # common to users and groups
         USR_GRP_SETTINGS = %i[transfer_settings app_authorizations share_permissions].freeze
+        # transfer_settings supports delete (resets to global inheritance); app_authorizations and share_permissions do not
+        TRANSFER_SETTINGS_OPS = %i[show modify delete].freeze
         # share_permissions is read-only (Rails only exposes index+show)
         SHARE_PERMISSIONS_OPS = %i[list show].freeze
-        # group users: Rails only exposes index+show+update+destroy (no create)
+        # group users (all): Rails only exposes index+show+update+destroy (no create)
         GROUP_USERS_OPS = (Operations::ALL - %i[create]).freeze
+        # local group users: same operations (no create), via data/local_groups/{id}/local_users
+        LOCAL_GROUP_USERS_OPS = GROUP_USERS_OPS
         # Arguments of group users commands, by operation
         GROUP_USERS_ARGS = {
           show:   [{name: :user_id, type: :identifier}],
@@ -117,10 +132,25 @@ module Aspera
         command :files,    description: 'Browse and transfer files on Shares', aliases: [:repository],
           mount: {plugin: Node, instance: :shares_node_plugin, only: Node::COMMANDS_SHARES}
         command :admin,    description: 'Administer Shares', setup: :setup_admin
+        command :share,    description: 'Shares accessible to current user'
+
+        commands_under :share do
+          command :list, description: 'List shares accessible to the current user',
+            action: ->(**) { entity_list(api: basic_auth_api(ADMIN_API_PATH), entity: 'shares', items_key: 'shares') }
+          command :event, description: 'Transfer notification events on a share'
+          commands_under :event do
+            command :create,
+              description: 'Notify Shares of a completed transfer (triggers email alerts)',
+              arguments: [
+                {name: :share_id, type: :identifier, lookup: :lookup_share_id_user},
+                {name: :event, type: Hash}
+              ]
+          end
+        end
 
         commands_under :admin do
           commands_under :node do
-            crud_commands entity: 'data/nodes', api: :@api_shares_admin
+            crud_commands entity: 'data/nodes', api: :@api_shares_admin, lookup: %w[name]
           end
           commands_under :ldap_config, description: 'LDAP configuration' do
             crud_commands entity: 'data/ldap_configs', api: :@api_shares_admin
@@ -136,13 +166,30 @@ module Aspera
               body_component: Schema::Registry::SHARES,
               operations: %i[show create modify]
           end
+          commands_under :directory do
+            command :list, description: 'List configured authentication directories',
+              action: ->(**) { entity_list(api: @api_shares_admin, entity: 'directories') }
+            command :show,
+              description: 'Get details of an authentication directory',
+              arguments: [{name: :directory_id, type: :identifier}]
+            command :users,
+              description: 'Search users in a directory',
+              arguments: [{name: :directory_id, type: :identifier}]
+            command :groups,
+              description: 'Search groups in a directory',
+              arguments: [{name: :directory_id, type: :identifier}]
+          end
+          command :authenticate,
+            description: 'Validate credentials and optionally check a permission',
+            arguments: [{name: :credentials, type: Hash}]
           # user / group: sub-commands per location, generated for both entity types
           %i[user group].each do |entity_type|
             commands_under entity_type do
-              command :all,   description: "#{entity_type.capitalize}s from all sources"
-              command :local, description: "Local #{entity_type}s"
-              command :ldap,  description: "LDAP #{entity_type}s"
-              command :saml,  description: "SAML #{entity_type}s"
+              command :all,    description: "#{entity_type.capitalize}s from all sources"
+              command :local,  description: "Local #{entity_type}s"
+              command :ldap,   description: "LDAP #{entity_type}s"
+              command :saml,   description: "SAML #{entity_type}s"
+              command :search, description: "Search #{entity_type}s across all directories"
 
               user_fields = %w[id user_id username first_name last_name email] if entity_type.eql?(:user)
               # all: list/show/delete only (no create, no modify — users/groups/:all has no update route)
@@ -154,23 +201,34 @@ module Aspera
                   operations:     Operations::ALL - %i[create modify],
                   lookup:         lookup_method_all,
                   display_fields: user_fields && (user_fields + %w[directory_user])
+                # share_permissions are read-only: tell where they are granted
+                grant_hint = "read-only, grant with: admin share #{entity_type}_permissions"
                 USR_GRP_SETTINGS.each do |setting|
-                  # share_permissions: Rails only exposes index+show (read-only)
-                  setting_ops = setting.eql?(:share_permissions) ? SHARE_PERMISSIONS_OPS : %i[show modify]
+                  # choose the operations set for this setting
+                  setting_ops =
+                    case setting
+                    when :share_permissions then SHARE_PERMISSIONS_OPS
+                    when :transfer_settings then TRANSFER_SETTINGS_OPS
+                    else %i[show modify]
+                    end
                   command setting,
-                    description: "Manage #{entity_noun(setting, singular: false)} for a #{entity_type}",
+                    description: setting.eql?(:share_permissions) ? "Permissions of a #{entity_type} on shares (#{grant_hint})" : "Manage #{entity_noun(setting, singular: false)} for a #{entity_type}",
                     arguments: [{name: :"#{entity_type}_id", type: :identifier, lookup: lookup_method_all}]
                   commands_under setting do
                     setting_ops.each do |op|
-                      # share_permissions > show needs a permission identifier (list does not), modify needs data
+                      # share_permissions > show needs a share identifier (list does not), modify needs data
                       op_args =
                         case op
-                        when :show then setting.eql?(:share_permissions) ? [{name: :permission_id, type: :identifier, lookup: :lookup_share_id}] : nil
+                        when :show   then setting.eql?(:share_permissions) ? [{name: :share_id, type: :identifier, lookup: :lookup_share_id}] : nil
                         when :modify then [{name: setting, type: Hash}]
                         end
-                      command op,
-                        description: "#{op.capitalize} #{entity_noun(setting, singular: false)} for a #{entity_type}",
-                        arguments: op_args
+                      op_description =
+                        case [setting, op]
+                        when %i[share_permissions list] then "List permissions of a #{entity_type} on shares (#{grant_hint})"
+                        when %i[share_permissions show] then "Show permission of a #{entity_type} on a share (#{grant_hint})"
+                        else "#{op.capitalize} #{entity_noun(setting, singular: false)} for a #{entity_type}"
+                        end
+                      command op, description: op_description, arguments: op_args
                     end
                   end
                 end
@@ -197,11 +255,16 @@ module Aspera
                   body_component: Schema::Registry::SHARES
                 if entity_type.eql?(:group)
                   command :users,
-                    description: 'Manage users of a group',
+                    description: 'Manage users of a local group',
                     arguments: [{name: :group_id, type: :identifier, lookup: :lookup_shares_group_local_id}]
                   commands_under :users do
-                    GROUP_USERS_OPS.each do |op|
-                      command op, description: "#{op.capitalize} users of a group", arguments: GROUP_USERS_ARGS[op]
+                    LOCAL_GROUP_USERS_OPS.each do |op|
+                      local_op_args =
+                        case op
+                        when :show, :delete then [{name: :user_id, type: :identifier}]
+                        when :modify then [{name: :user_id, type: :identifier}, {name: :user, type: Hash}]
+                        end
+                      command op, description: "#{op.capitalize} users of a local group", arguments: local_op_args
                     end
                   end
                 end
@@ -218,6 +281,24 @@ module Aspera
                 command :import, description: "Import a SAML #{entity_type}",
                   arguments: [{name: entity_type, type: Hash, bulk: true}]
               end
+
+              # search: list + show by URN + (groups only) members
+              # The cross-directory search endpoints return a collection object {"resource_type":"collection","members":[...]}
+              # entity_plural captured at class-load time in the closure
+              entity_plural_search = entity_type.eql?(:user) ? 'users' : 'groups'
+              commands_under :search do
+                command :list,
+                  description: "Search #{entity_type}s across all directories (use --query={q: '...'} to filter)",
+                  action: ->(**) { entity_list(api: @api_shares_admin, entity: entity_plural_search, items_key: 'members') }
+                command :show,
+                  description: "Get directory #{entity_type} details by URN",
+                  arguments: [{name: :"#{entity_type}_urn", type: :identifier}]
+                if entity_type.eql?(:group)
+                  command :members,
+                    description: 'Search members in a directory group',
+                    arguments: [{name: :group_urn, type: :identifier}]
+                end
+              end
             end
           end
         end
@@ -233,7 +314,7 @@ module Aspera
             lookup_method = :"lookup_shares_#{entity_type}_#{location}_id"
             define_method(lookup_method) do |field, value, **|
               path = admin_entity_path(entity_type, location)
-              Rest::List.lookup_entity_generic(entity: entity_type, field: field, value: value) { @api_shares_admin.read(path) }['id']
+              Rest::List.lookup_entity_generic(field: field, value: value, entity: entity_type) { @api_shares_admin.read(path) }['id']
             end
             private lookup_method
           end
@@ -259,10 +340,12 @@ module Aspera
         {user_permissions: :user, group_permissions: :group}.each do |perm_type, entity_type|
           commands_under [:admin, :share, perm_type] do
             crud_commands entity: :"share_#{perm_type}",
-              api:     :@api_shares_admin,
-              name:    entity_noun(perm_type),
-              id_name: :"#{entity_type}_id",
-              lookup:  :"lookup_shares_#{entity_type}_all_id"
+              api:            :@api_shares_admin,
+              name:           entity_noun(perm_type),
+              id_name:        :"#{entity_type}_id",
+              lookup:         :"lookup_shares_#{entity_type}_all_id",
+              body_component: Schema::Registry::SHARES,
+              schema_entity:  "data/shares/{share_id}/#{perm_type}"
           end
         end
 
@@ -297,7 +380,14 @@ module Aspera
 
         # Lookup a share id by field/value using the admin API.
         def lookup_share_id(field, value, **)
-          Rest::List.lookup_entity_generic(entity: 'share', field: field, value: value) { @api_shares_admin.read('data/shares') }['id']
+          Rest::List.lookup_entity_generic(field: field, value: value, entity: 'share') { @api_shares_admin.read('data/shares') }['id']
+        end
+
+        # Lookup a share id by field/value using the user-level API (for share event create).
+        def lookup_share_id_user(field, value, **)
+          data = basic_auth_api(ADMIN_API_PATH).read('shares')
+          data = data['shares'] if data.is_a?(Hash)
+          Rest::List.lookup_entity_generic(field: field, value: value, entity: 'share') { data }['id']
         end
 
         # --- health ---
@@ -317,6 +407,25 @@ module Aspera
           else
             nagios.add_critical('API', health[:api].to_s)
           end
+          if health[:system].is_a?(Hash)
+            sys = health[:system]
+            # one status item for the license (standard or entitlement)
+            if sys['valid_license'] || sys['entitled']
+              nagios.add_ok('license', sys['entitled'] ? 'entitled' : 'valid')
+            else
+              nagios.add_critical('license', 'invalid')
+            end
+            # one status item per configured node
+            (sys['nodes'] || []).each do |node|
+              if node['status'].to_s.casecmp('active').zero?
+                nagios.add_ok("node #{node['id']}", node['status'])
+              else
+                nagios.add_critical("node #{node['id']}", node['status'])
+              end
+            end
+          else
+            nagios.add_critical('system', health[:system].to_s)
+          end
           Result::ObjectList.new(nagios.status_list)
         end
 
@@ -336,10 +445,10 @@ module Aspera
         # @param setting     [Symbol] one of USR_GRP_SETTINGS
         # @param op          [Symbol] CRUD operation
         # entity_id: resolved via arguments:(:identifier) on the setting node
-        # permission_id: (share_permissions show) and data: (modify) resolved via arguments: on the leaf
-        def admin_entity_setting(entity_type, location, setting, op, entity_id:, permission_id: nil, data: nil)
+        # share_id: (share_permissions show) and data: (modify) resolved via arguments: on the leaf
+        def admin_entity_setting(entity_type, location, setting, op, entity_id:, share_id: nil, data: nil)
           entity_path = "#{admin_entity_path(entity_type, location)}/#{entity_id}/#{setting}"
-          send(:"entity_#{op}", api: @api_shares_admin, entity: entity_path, id: permission_id, is_singleton: !setting.eql?(:share_permissions), data: data)
+          send(:"entity_#{op}", api: @api_shares_admin, entity: entity_path, id: share_id, is_singleton: !setting.eql?(:share_permissions), data: data)
         end
 
         # Shared handler for :users (group only)
@@ -353,25 +462,45 @@ module Aspera
 
         # Generate action_admin_<user|group>_<location>_<verb> for all combinations
         %i[user group].each do |entity_type|
-          # all: list/show/delete only (no create, no modify — no update route on /users and /groups)
+          # all: list/show/delete only — nested settings (transfer_settings, app_authorizations, share_permissions) only under :all
           # local: full CRUD only — no nested settings under local_users/local_groups
           ENTITY_LOCATIONS.each do |location|
             unless location.eql?(:local)
               USR_GRP_SETTINGS.each do |setting|
-                # share_permissions: Rails only exposes index+show (read-only)
-                setting_ops = setting.eql?(:share_permissions) ? SHARE_PERMISSIONS_OPS : %i[show modify]
+                # choose the operations set for this setting
+                setting_ops =
+                  case setting
+                  when :share_permissions then SHARE_PERMISSIONS_OPS
+                  when :transfer_settings then TRANSFER_SETTINGS_OPS
+                  else %i[show modify]
+                  end
                 setting_ops.each do |op|
                   define_action_method([:admin, entity_type, location, setting, op]) do |**kwargs|
-                    admin_entity_setting(entity_type, location, setting, op, entity_id: kwargs[:"#{entity_type}_id"], permission_id: kwargs[:permission_id], data: kwargs[setting])
+                    admin_entity_setting(entity_type, location, setting, op, entity_id: kwargs[:"#{entity_type}_id"], share_id: kwargs[:share_id], data: kwargs[setting])
                   end
                 end
               end
             end
             next unless entity_type.eql?(:group)
-            # group users: no create route (Rails only exposes index+show+update+destroy)
-            GROUP_USERS_OPS.each do |op|
-              define_action_method([:admin, entity_type, location, :users, op]) do |group_id:, user_id: nil, user: nil, **|
-                admin_entity_users(entity_type, location, op, group_id: group_id, user_id: user_id, data: user)
+            if location.eql?(:all)
+              # all group users: no create route (Rails only exposes index+show+update+destroy)
+              GROUP_USERS_OPS.each do |op|
+                define_action_method([:admin, entity_type, :all, :users, op]) do |group_id:, user_id: nil, user: nil, **|
+                  admin_entity_users(entity_type, :all, op, group_id: group_id, user_id: user_id, data: user)
+                end
+              end
+            else
+              # local group local_users: list/show/modify/delete (via data/local_groups/{id}/local_users)
+              LOCAL_GROUP_USERS_OPS.each do |op|
+                define_action_method([:admin, entity_type, :local, :users, op]) do |group_id:, user_id: nil, user: nil, **|
+                  send(
+                    :"entity_#{op}",
+                    api:    @api_shares_admin,
+                    entity: "data/local_groups/#{group_id}/local_users",
+                    id:     user_id,
+                    data:   user
+                  )
+                end
               end
             end
           end
@@ -397,6 +526,47 @@ module Aspera
               @api_shares_admin.create("#{path}/import", entity_parameters)
             end
           end
+
+          # search: list + show + (groups) members — cross-directory endpoints under /api/v1/users|groups
+          # URNs contain ':' and '=' and must be percent-encoded in the URL path segment.
+          entity_plural = entity_type.eql?(:user) ? 'users' : 'groups'
+          define_action_method(%i[admin].push(entity_type, :search, :show)) do |**kwargs|
+            urn = URI.encode_www_form_component(kwargs[:"#{entity_type}_urn"])
+            Result::SingleObject.new(@api_shares_admin.read("#{entity_plural}/#{urn}"))
+          end
+          next unless entity_type.eql?(:group)
+          define_action_method(%i[admin group search members]) do |group_urn:, **|
+            encoded = URI.encode_www_form_component(group_urn)
+            entity_list(api: @api_shares_admin, entity: "groups/#{encoded}/members", items_key: 'members')
+          end
+        end
+
+        # admin > directory > show / users / groups
+        # directory_id is a URN — must be percent-encoded in the URL path segment.
+        define_action_method(%i[admin directory show]) do |directory_id:, **|
+          enc = URI.encode_www_form_component(directory_id)
+          Result::SingleObject.new(@api_shares_admin.read("directories/#{enc}"))
+        end
+
+        define_action_method(%i[admin directory users]) do |directory_id:, **|
+          enc = URI.encode_www_form_component(directory_id)
+          entity_list(api: @api_shares_admin, entity: "directories/#{enc}/users", items_key: 'members')
+        end
+
+        define_action_method(%i[admin directory groups]) do |directory_id:, **|
+          enc = URI.encode_www_form_component(directory_id)
+          entity_list(api: @api_shares_admin, entity: "directories/#{enc}/groups", items_key: 'members')
+        end
+
+        # admin > authenticate
+        define_action_method(%i[admin authenticate]) do |credentials:, **|
+          Result::SingleObject.new(@api_shares_admin.create('authenticate', credentials))
+        end
+
+        # share > event > create
+        define_action_method(%i[share event create]) do |share_id:, event:, **|
+          basic_auth_api(ADMIN_API_PATH).create("shares/#{share_id}/events", event)
+          Result::Status.new('event created')
         end
       end
     end

data/lib/aspera/cli/preset_actions.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'aspera/assert'
+require 'aspera/secret_hider'
+require 'aspera/cli/security'
 require 'aspera/cli/preset_manager'
 
 module Aspera
@@ -13,10 +15,8 @@ module Aspera
       CONF_OVERVIEW_KEYS = %w[preset parameter value].freeze
 
       def action_preset_overview(**)
-        cp = presets.config_presets
-        # Display process modifies the value (hide secrets): we do not want to save removed secrets
-        data = PresetManager.deep_clone(cp)
-        formatter.hide_secrets(data)
+        # Secrets hidden by key name here: the key becomes the value of column `parameter`
+        data = formatter.hide_secrets(presets.config_presets)
         result = []
         data.each do |config, preset|
           preset.each do |parameter, value|
@@ -83,7 +83,7 @@ module Aspera
           incr += 1
         end
         Log.log.info { "Securing #{preset_name}.#{option_name} -> vault label: #{vault_label}" }
-        vault.set({label: vault_label, password: value})
+        vault.set({label: vault_label, password: value}) # HashiCorpIgnore
         preset[option_name] = "@vault:#{vault_label}.password"
       end
 
@@ -93,7 +93,7 @@ module Aspera
         name = preset_name(name)
         cp = presets.config_presets
         raise Cli::BadArgument, "no such preset: #{name}" unless cp.key?(name)
-        Result::SingleObject.new(PresetManager.deep_clone(cp[name]))
+        Result::SingleObject.new(cp[name])
       end
 
       def action_preset_delete(name:, **)
@@ -117,7 +117,11 @@ module Aspera
         value = cp[name][param_name]
         raise Cli::BadArgument, "no such option in preset #{name}: #{param_name}" if value.nil?
         case value
-        when Numeric, String then return Result::Text.new(ExtendedValue.instance.evaluate(value.to_s, context: 'preset'))
+        when Numeric, String
+          value = ExtendedValue.instance.evaluate(value.to_s, context: 'preset')
+          # A secret has no key name in a text result: declared, so that it is hidden
+          SecretHider.instance.add_secret_values(value) if SecretHider.instance.secret?(param_name, value)
+          return Result::Text.new(value)
         end
         Result::SingleObject.new(value)
       end
@@ -132,6 +136,10 @@ module Aspera
 
       def action_preset_set(name:, param_name:, param_value:, **)
         name = preset_name(name, create: true)
+        # Key names are not secrets: converted, or split with dot-notation, a secret would not be hidden in results
+        Security.instance.check_secret_processing('preset parameter name', hint: 'give a name that is not a secret') do
+          SecretHider.instance.contains_secret?(param_name)
+        end
         param_name = Parser.option_line_to_name(param_name)
         presets.set_key(name, param_name, Parser.smart_convert(param_value))
         secure_preset_option(presets.config_presets[name], name, param_name)

data/lib/aspera/cli/preset_manager.rb

@@ -6,6 +6,7 @@ require 'aspera/cli/version'
 require 'aspera/cli/info'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/secret_hider'
 require 'aspera/yaml'
 require 'digest'
 require 'yaml'
@@ -66,7 +67,8 @@ module Aspera
         if File.exist?(@config_file)
           Log.log.debug { "loading #{@config_file}" }
           begin
-            @config_presets = Yaml.safe_load(File.read(@config_file))
+            # Before checksum: the conversion alone does not save the file
+            @config_presets = self.class.stringify_secrets(nil, Yaml.safe_load(File.read(@config_file)))
           rescue Psych::SyntaxError
             Log.log.error { "YAML error in config file: #{@config_file}" }
             raise
@@ -91,6 +93,8 @@ module Aspera
           end
           raise Cli::Error, e.to_s
         end
+        # Hidden wherever they appear (logs, results), also when copied under another key name
+        SecretHider.instance.add_secrets_in(@config_presets)
       end
 
       # Save to disk only if content changed since last load/save.
@@ -152,7 +156,10 @@ module Aspera
         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')
+        current = ExtendedValue.instance.evaluate(current, context: 'preset')
+        # A secret read alone has no key name: declared, so that it is hidden wherever it appears
+        SecretHider.instance.add_secret_values(current) if SecretHider.instance.secret?(names.last, current)
+        current
       end
 
       # Set a single key in a preset hash (creates the preset if absent).
@@ -161,6 +168,7 @@ module Aspera
       def set_key(preset, param_name, param_value)
         Aspera.assert_type(param_name, String, Symbol) { 'parameter' }
         param_name = param_name.to_s
+        param_value = self.class.stringify_secrets(param_name.split(DotContainer::SEPARATOR).last, param_value)
         selected = @config_presets[preset]
         if selected.nil?
           Log.log.debug { "Unknown preset name: #{preset}, initializing" }
@@ -276,6 +284,20 @@ module Aspera
           end
           dst
         end
+
+        # A secret is a String: a number under a secret key name (e.g. password `12345678`, unquoted in YAML or set on command line)
+        # is converted, else it is not identified as a secret, and is shown in results
+        # @param key   [String, nil] Key name of value
+        # @param value [Object]      Value: containers are modified in place
+        # @return [Object] Value, or its String if it is a secret
+        def stringify_secrets(key, value)
+          case value
+          when Hash then value.each { |k, v| value[k] = stringify_secrets(k, v) }
+          when Array then value.map! { |v| stringify_secrets(nil, v) }
+          when Numeric then value = value.to_s if SecretHider.instance.secret?(key, value.to_s)
+          end
+          value
+        end
       end
 
       private

data/lib/aspera/cli/prompt.rb

@@ -7,13 +7,15 @@ module Aspera
   module Cli
     # Console input
     module Prompt
+      extend self
+
       # Prompt user for console input
       # The prompt is displayed on `stderr`, like for sensitive input, so that `stdout` contains only results.
       # @param prompt [String]  prompt string to display
       # @param sensitive [Boolean] whether to hide typed input
       # @return [String] user input stripped of trailing newline
       def prompt_user_input(prompt, sensitive: false)
-        return $stdin.getpass("#{prompt}> ") if sensitive
+        return $stdin.getpass("#{prompt}> ") if sensitive && $stdin.tty?
         $stderr.print("#{prompt}> ")
         line = $stdin.gets
         Aspera.assert_type(line, String) { 'Unexpected end of standard input' }

data/lib/aspera/cli/result.rb

@@ -29,6 +29,12 @@ module Aspera
         @fields = fields
       end
 
+      # @param data [Object] New data
+      # @return [Result] Copy of this result, with other data (e.g. with secrets hidden)
+      def with_data(data)
+        dup.tap { |r| r.data = data }
+      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
@@ -81,6 +87,13 @@ module Aspera
 
       # Formats rendering the data structure itself
       STRUCTURED_FORMATS = %i[ruby json jsonpp yaml].freeze
+      # Types of a single value result (Text), or of items of a value list
+      SCALAR_TYPES = [String, Integer, Float, Symbol, TrueClass, FalseClass].freeze
+
+      protected
+
+      # Used by `with_data`
+      attr_writer :data
 
       private
 
@@ -174,8 +187,9 @@ module Aspera
 
       # Text result
       class Text < Result
+        # @param data [String, Numeric, Symbol, Boolean] The value, hidden if it is a secret declared to `SecretHider`
         def initialize(data)
-          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError) { 'text result data' }
+          Aspera.assert_type(data, *SCALAR_TYPES, type: ArgumentError) { 'text result data' }
           super(data: data)
         end
 
@@ -351,12 +365,11 @@ module Aspera
             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
+            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
+          when *SCALAR_TYPES
             Text.new(data)
           else
             Aspera.error_unexpected_value(data.class.name) { 'result type' }