aspera-cli 4.15.0 → 4.16.0

data/lib/aspera/cli/manager.rb

@@ -5,6 +5,7 @@ require 'aspera/cli/error'
 require 'aspera/colors'
 require 'aspera/secret_hider'
 require 'aspera/log'
+require 'aspera/assert'
 require 'io/console'
 require 'optparse'
 
@@ -20,7 +21,7 @@ module Aspera
         @option_name = option_name
         @has_writer = @object.respond_to?(writer_method)
         Log.log.debug{"AttrAccessor: #{@option_name}: #{@object.class}.#{@method}: writer=#{@has_writer}"}
-        raise "internal error: #{object} does not respond to #{method_name}" unless @object.respond_to?(@method)
+        assert(@object.respond_to?(@method)) {"#{object} does not respond to #{method_name}"}
       end
 
       def value
@@ -54,12 +55,13 @@ module Aspera
       # option name separator in code (symbol)
       OPTION_SEP_SYMBOL = '_'
       SOURCE_USER = 'cmdline' # cspell:disable-line
+      TYPE_INTEGER = [Integer].freeze
 
-      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :SOURCE_USER
+      private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :SOURCE_USER, :TYPE_INTEGER
 
       class << self
         def enum_to_bool(enum)
-          raise "Value not valid for boolean: [#{enum}]/#{enum.class}" unless BOOLEAN_VALUES.include?(enum)
+          assert_values(enum, BOOLEAN_VALUES){'boolean'}
           return TRUE_VALUES.include?(enum)
         end
 
@@ -73,14 +75,17 @@ module Aspera
           matching_exact = allowed_values.select{|i| i.to_s.eql?(short_value)}
           return matching_exact.first if matching_exact.length == 1
           matching = allowed_values.select{|i| i.to_s.start_with?(short_value)}
-          raise Cli::BadArgument, bad_arg_message_multi("unknown value for #{descr}: #{short_value}", allowed_values) if matching.empty?
-          raise Cli::BadArgument, bad_arg_message_multi("ambiguous shortcut for #{descr}: #{short_value}", matching) unless matching.length.eql?(1)
+          multi_choice_assert(!matching.empty?,"unknown value for #{descr}: #{short_value}", allowed_values)
+          multi_choice_assert(matching.length.eql?(1),"ambiguous shortcut for #{descr}: #{short_value}", matching) 
           return enum_to_bool(matching.first) if allowed_values.eql?(BOOLEAN_VALUES)
           return matching.first
         end
 
-        def bad_arg_message_multi(error_msg, choices)
-          return [error_msg, 'Use:'].concat(choices.map{|c|"- #{c}"}.sort).join("\n")
+        # Generates error message with list of allowed values
+        # @param error_msg [String] error message
+        # @param choices [Array] list of allowed values
+        def multi_choice_assert(assertion,error_msg, choices)
+          raise Cli::BadArgument,  [error_msg, 'Use:'].concat(choices.map{|c|"- #{c}"}.sort).join("\n") unless assertion
         end
 
         # change option name with dash to name with underscore
@@ -92,9 +97,13 @@ module Aspera
           return "--#{name.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)}"
         end
 
+        # @param what [Symbol] :option or :argument
+        # @param descr [String] description for help
+        # @param value [Object] value to check
+        # @param type_list [NilClass, Class, Array[Class]] accepted value type(s)
         def validate_type(what, descr, value, type_list)
           return nil if type_list.nil?
-          raise 'internal error: types must be a Class Array' unless type_list.is_a?(Array) && type_list.all?(Class)
+          assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}
           raise Cli::BadArgument,
             "#{what.to_s.capitalize} #{descr} is a #{value.class} but must be #{type_list.length > 1 ? 'one of ' : ''}#{type_list.map(&:name).join(',')}" unless \
             type_list.any?{|t|value.is_a?(t)}
@@ -172,10 +181,14 @@ module Aspera
       # @param default [Object] default value
       # @return value, list or nil
       def get_next_argument(descr, expected: :single, mandatory: true, type: nil, aliases: nil, default: nil)
-        unless type.nil?
-          type = [type] unless type.is_a?(Array)
-          raise "INTERNAL ERROR: type must be Array of Class: #{type}" unless type.all?(Class)
-          descr = "#{descr} (#{type})"
+        assert(%i[single multiple].include?(expected) || (expected.is_a?(Array) && expected.all?(Symbol))){'expected must be single, multiple, or array of symbol'}
+        assert(type.nil? || type.is_a?(Class) || (type.is_a?(Array) && type.all?(Class))){'type must be Class or Array of Class'}
+        assert(aliases.nil? || (aliases.is_a?(Hash) && aliases.keys.all?(Symbol) && aliases.values.all?(Symbol))){'aliases must be Hash'}
+        allowed_types = type
+        unless allowed_types.nil?
+          allowed_types = [allowed_types] unless allowed_types.is_a?(Array)
+          descr = "#{descr} (#{allowed_types.join(', ')})"
+          Log.log.debug{">>>> #{descr}=#{allowed_types}"}
         end
         result =
           if !@unprocessed_cmd_line_arguments.empty?
@@ -193,23 +206,21 @@ module Aspera
             when Array
               allowed_values = [].concat(expected)
               allowed_values.concat(aliases.keys) unless aliases.nil?
-              raise "internal error: only symbols allowed: #{allowed_values}" unless allowed_values.all?(Symbol)
               self.class.get_from_list(@unprocessed_cmd_line_arguments.shift, descr, allowed_values)
-            else
-              raise 'Internal error: expected: must be single, multiple, or value array'
+            else error_unexpected_value(expected)
             end
           elsif !default.nil? then default
             # no value provided, either get value interactively, or exception
           elsif mandatory then get_interactive(:argument, descr, expected: expected)
           end
-        if result.is_a?(String) && type.eql?([Integer])
-          str_result = result
-          result = Integer(str_result, exception: false)
-          raise Cli::BadArgument, "Invalid integer: #{str_result}" if result.nil?
+        if result.is_a?(String) && allowed_types.eql?(TYPE_INTEGER)
+          int_result = Integer(result, exception: false)
+          raise Cli::BadArgument, "Invalid integer: #{result}" if int_result.nil?
+          result = int_result
         end
         Log.log.debug{"#{descr}=#{result}"}
-        result = aliases[result] if !aliases.nil? && aliases.key?(result)
-        self.class.validate_type(:argument, descr, result, type) unless result.nil? && !mandatory
+        result = aliases[result] if aliases&.key?(result)
+        self.class.validate_type(:argument, descr, result, allowed_types) unless result.nil? && !mandatory
         return result
       end
 
@@ -221,7 +232,7 @@ module Aspera
       # @param mandatory [Boolean] if true, raise error if option not set
       def get_option(option_symbol, mandatory: false, default: nil)
         attributes = @declared_options[option_symbol]
-        raise "INTERNAL ERROR: option not declared: #{option_symbol}" unless attributes
+        assert(attributes){"option not declared: #{option_symbol}"}
         result = nil
         case attributes[:read_write]
         when :accessor
@@ -284,12 +295,10 @@ module Aspera
       # @param types [Class, Array] accepted value type(s)
       # @param block [Proc] block to execute when option is found
       def declare(option_symbol, description, handler: nil, default: nil, values: nil, short: nil, coerce: nil, types: nil, deprecation: nil, &block)
-        raise "INTERNAL ERROR: #{option_symbol} already declared" if @declared_options.key?(option_symbol)
-        # raise "INTERNAL ERROR: #{option_symbol} clash with another option" if
-        # @declared_options.keys.map(&:to_s).any?{|k|k.start_with?(option_symbol.to_s) || option_symbol.to_s.start_with?(k)}
-        raise "INTERNAL ERROR: #{option_symbol} ends with dot" unless description[-1] != '.'
-        raise "INTERNAL ERROR: #{option_symbol} description does not start with capital" unless description[0] == description[0].upcase
-        raise "INTERNAL ERROR: #{option_symbol} shall use :types" if ['hash', 'extended value'].any?{|s|description.downcase.include?(s) }
+        assert(!@declared_options.key?(option_symbol)){"#{option_symbol} already declared"}
+        assert(description[-1] != '.'){"#{option_symbol} ends with dot"}
+        assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with capital"}
+        assert(!['hash', 'extended value'].any?{|s|description.downcase.include?(s) }){"#{option_symbol} shall use :types"}
         opt = @declared_options[option_symbol] = {
           read_write: handler.nil? ? :value : :accessor,
           # by default passwords and secrets are sensitive, else specify when declaring the option
@@ -297,7 +306,7 @@ module Aspera
         }
         if !types.nil?
           types = [types] unless types.is_a?(Array)
-          raise "INTERNAL ERROR: types must be Array of Class: #{types}" unless types.all?(Class)
+          assert(types.all?(Class)){"types must be Array of Class: #{types}"}
           opt[:types] = types
           description = "#{description} (#{types.map(&:name).join(', ')})"
         end
@@ -307,8 +316,8 @@ module Aspera
         end
         Log.log.debug{"declare: #{option_symbol}: #{opt[:read_write]}".green}
         if opt[:read_write].eql?(:accessor)
-          raise 'internal error' unless handler.is_a?(Hash)
-          raise 'internal error' unless handler.keys.sort.eql?(%i[m o])
+          assert_type(handler, Hash)
+          assert(handler.keys.sort.eql?(%i[m o]))
           Log.log.debug{"set attr obj #{option_symbol} (#{handler[:o]},#{handler[:m]})"}
           opt[:accessor] = AttrAccessor.new(handler[:o], handler[:m], option_symbol)
         end
@@ -347,11 +356,11 @@ module Aspera
             set_option(option_symbol, time_string, SOURCE_USER)
           end
         when :none
-          raise "internal error: missing block for #{option_symbol}" if block.nil?
+          assert(!block.nil?){"missing block for #{option_symbol}"}
           on_args.push(symbol_to_option(option_symbol, nil))
           on_args.push("-#{short}") if short.is_a?(String)
           @parser.on(*on_args, &block)
-        else raise "internal error: Unknown type for values: #{values} / #{values.class}"
+        else error_unexpected_value(values)
         end
         Log.log.debug{"on_args=#{on_args}"}
       end
@@ -359,8 +368,8 @@ module Aspera
       # Adds each of the keys of specified hash as an option
       # @param preset_hash [Hash] hash of options to add
       def add_option_preset(preset_hash, op: :push)
+        assert_type(preset_hash, Hash)
         Log.log.debug{"add_option_preset=#{preset_hash}"}
-        raise "internal error: default expects Hash: #{preset_hash.class}" unless preset_hash.is_a?(Hash)
         # incremental override
         preset_hash.each{|k, v|@unprocessed_defaults.send(op, [k.to_sym, v])}
       end
@@ -460,8 +469,8 @@ module Aspera
 
       def get_interactive(type, descr, expected: :single)
         if !@ask_missing_mandatory
-          raise Cli::BadArgument, self.class.bad_arg_message_multi("missing: #{descr}", expected) if expected.is_a?(Array)
-          raise Cli::BadArgument, "missing argument (#{expected}): #{descr}"
+          raise Cli::BadArgument, "missing argument (#{expected}): #{descr}" unless expected.is_a?(Array)
+          self.class.multi_choice_assert(false,"missing: #{descr}", expected)
         end
         result = nil
         sensitive = type.eql?(:option) && @declared_options[descr.to_sym].is_a?(Hash) && @declared_options[descr.to_sym][:sensitive]

data/lib/aspera/cli/plugin.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/cli/extended_value'
+require 'aspera/assert'
 
 module Aspera
   module Cli
@@ -33,11 +34,11 @@ module Aspera
       end
 
       def initialize(env)
-        raise 'env must be Hash' unless env.is_a?(Hash)
+        assert_type(env, Hash)
         @agents = env
         # check presence in descendant of mandatory method and constant
-        raise StandardError, "Missing method 'execute_action' in #{self.class}" unless respond_to?(:execute_action)
-        raise StandardError, 'ACTIONS shall be redefined by subclass' unless self.class.constants.include?(:ACTIONS)
+        assert(respond_to?(:execute_action)){"Missing method 'execute_action' in #{self.class}"}
+        assert(self.class.constants.include?(:ACTIONS)){'ACTIONS shall be redefined by subclass'}
         # manual header for all plugins
         options.parser.separator('')
         options.parser.separator("COMMAND: #{self.class.name.split('::').last.downcase}")
@@ -75,6 +76,7 @@ module Aspera
       # @param id_result [String] key in result hash to use as identifier
       # @param fields [Array] fields to display
       def do_bulk_operation(command:, descr:, values: Hash, id_result: 'id', fields: :default)
+        assert(block_given?){'missing block'}
         is_bulk = options.get_option(:bulk)
         case values
         when :identifier
@@ -82,7 +84,6 @@ module Aspera
         when Class
           values = value_create_modify(command: command, type: values, bulk: is_bulk)
         end
-        raise 'Internal error: missing block' unless block_given?
         # if not bulk, there is a single value
         params = is_bulk ? values : [values]
         Log.log.warn('Empty list given for bulk operation') if params.empty?
@@ -147,6 +148,7 @@ module Aspera
           return {type: :single_object, data: rest_api.read(one_res_path)[:data], fields: display_fields}
         when :list
           resp = rest_api.read(res_class_path, old_query_read_delete)
+          return Main.result_empty if resp[:http].code == '204'
           data = resp[:data]
           # TODO: not generic : which application is this for ?
           if resp[:http]['Content-Type'].start_with?('application/vnd.api+json')
@@ -180,10 +182,10 @@ module Aspera
       end
 
       # implement generic rest operations on given resource path
-      def entity_action(rest_api, res_class_path, **opts)
+      def entity_action(rest_api, res_class_path, **opts, &block)
         # res_name=res_class_path.gsub(%r{^.*/},'').gsub(%r{s$},'').gsub('_',' ')
         command = options.get_next_command(ALL_OPS)
-        return entity_command(command, rest_api, res_class_path, **opts)
+        return entity_command(command, rest_api, res_class_path, **opts, &block)
       end
 
       # query parameters in URL suitable for REST list/GET and delete/DELETE
@@ -223,22 +225,27 @@ module Aspera
 
       # Retrieves an extended value from command line, used for creation or modification of entities
       # @param command [Symbol] command name for error message
-      # @param type [Class] expected type of value, either a Class, an Array of Class, or :bulk_hash
+      # @param type [Class] expected type of value, either a Class, an Array of Class
+      # @param bulk [Boolean] if true, value must be an Array of <type>
       # @param default [Object] default value if not provided
       # TODO: when deprecation of `value` is completed: remove line with :value
-      def value_create_modify(command:, type: Hash, bulk: false, default: nil)
+      def value_create_modify(command:, description: nil, type: Hash, bulk: false, default: nil)
         value = options.get_option(:value)
         Log.log.warn("option `value` is deprecated. Use positional parameter for #{command}") unless value.nil?
-        value = options.get_next_argument("parameters for #{command}", mandatory: default.nil?) if value.nil?
+        value = options.get_next_argument(
+          "parameters for #{command}#{description.nil? ? '' : " (#{description})"}", mandatory: default.nil?,
+          type: bulk ? Array : type) if value.nil?
         value = default if value.nil?
         unless type.nil?
           type = [type] unless type.is_a?(Array)
-          raise "Internal error, check types must be a Class, not #{type.map(&:class).join(',')}" unless type.all?(Class)
+          assert(type.all?(Class)){"check types must be a Class, not #{type.map(&:class).join(',')}"}
           if bulk
-            raise Cli::BadArgument, "Value must be an Array of #{type.join(',')}" unless value.is_a?(Array)
-            raise Cli::BadArgument, "Value must be a #{type.join(',')}, not #{value.map{|i| i.class.name}.uniq.join(',')}" unless value.all?{|v|type.include?(v.class)}
+            assert_type(value, Array, exception_class: Cli::BadArgument)
+            value.each do |v|
+              assert_values(v.class, type, exception_class: Cli::BadArgument)
+            end
           else
-            raise Cli::BadArgument, "Value must be a #{type.join(',')}, not #{value.class.name}" unless type.include?(value.class)
+            assert_values(value.class, type, exception_class: Cli::BadArgument)
           end
         end
         return value