aspera-cli 4.15.0 → 4.17.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)
+        Aspera.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)
+          Aspera.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)
+          Aspera.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,15 @@ 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})"
+        Aspera.assert(%i[single multiple].include?(expected) || (expected.is_a?(Array) && expected.all?(Symbol))) do
+          'expected must be single, multiple, or array of symbol'
+        end
+        Aspera.assert(type.nil? || type.is_a?(Class) || (type.is_a?(Array) && type.all?(Class))){'type must be Class or Array of Class'}
+        Aspera.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(', ')})"
         end
         result =
           if !@unprocessed_cmd_line_arguments.empty?
@@ -193,23 +207,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 Aspera.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 +233,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
+        Aspera.assert(attributes){"option not declared: #{option_symbol}"}
         result = nil
         case attributes[:read_write]
         when :accessor
@@ -284,12 +296,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) }
+        Aspera.assert(!@declared_options.key?(option_symbol)){"#{option_symbol} already declared"}
+        Aspera.assert(description[-1] != '.'){"#{option_symbol} ends with dot"}
+        Aspera.assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with capital"}
+        Aspera.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 +307,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)
+          Aspera.assert(types.all?(Class)){"types must be Array of Class: #{types}"}
           opt[:types] = types
           description = "#{description} (#{types.map(&:name).join(', ')})"
         end
@@ -307,8 +317,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])
+          Aspera.assert_type(handler, Hash)
+          Aspera.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 +357,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?
+          Aspera.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 Aspera.error_unexpected_value(values)
         end
         Log.log.debug{"on_args=#{on_args}"}
       end
@@ -359,8 +369,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)
+        Aspera.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 +470,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
@@ -18,6 +19,7 @@ module Aspera
       MAX_PAGES = 'pmax'
       # special identifier format: look for this name to find where supported
       REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/.freeze
+      INIT_PARAMS = %i[options transfer config formatter persistency only_manual].freeze
 
       class << self
         def declare_generic_options(options)
@@ -32,12 +34,18 @@ module Aspera
         end
       end
 
-      def initialize(env)
-        raise 'env must be Hash' unless env.is_a?(Hash)
-        @agents = env
+      attr_accessor(*INIT_PARAMS)
+
+      def initialize(options:, transfer:, config:, formatter:, persistency:, only_manual:)
+        @options = options
+        @transfer = transfer
+        @config = config
+        @formatter = formatter
+        @persistency = persistency
+        @only_manual = only_manual
         # 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)
+        Aspera.assert(respond_to?(:execute_action)){"Missing method 'execute_action' in #{self.class}"}
+        Aspera.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}")
@@ -45,6 +53,11 @@ module Aspera
         options.parser.separator('OPTIONS:')
       end
 
+      def init_params
+        # return a hash of instance variables
+        INIT_PARAMS.map{|p| [p, instance_variable_get("@#{p}".to_sym)]}.to_h
+      end
+
       # must be called AFTER the instance action, ... folder browse <call instance_identifier>
       # @param description [String] description of the identifier
       # @param as_option [Symbol] option name to use if identifier is an option
@@ -75,6 +88,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)
+        Aspera.assert(block_given?){'missing block'}
         is_bulk = options.get_option(:bulk)
         case values
         when :identifier
@@ -82,7 +96,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 +160,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 +194,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,31 +237,31 @@ 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)
+          Aspera.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)}
+            Aspera.assert_type(value, Array, exception_class: Cli::BadArgument)
+            value.each do |v|
+              Aspera.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)
+            Aspera.assert_values(value.class, type, exception_class: Cli::BadArgument)
           end
         end
         return value
       end
-
-      # shortcuts helpers for plugin environment
-      %i[options transfer config formatter persistency].each do |name|
-        define_method(name){@agents[name]}
-      end
     end # Plugin
   end # Cli
 end # Aspera

data/lib/aspera/cli/plugin_factory.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'singleton'
+module Aspera
+  module Cli
+    # option is retrieved from another object using accessor
+    class PluginFactory
+      include Singleton
+      attr_reader :lookup_folders, :plugins
+
+      RUBY_FILE_EXT = '.rb'
+      PLUGINS_MODULE = 'Plugins'
+      private_constant :RUBY_FILE_EXT
+      class << self
+        # instantiate a plugin
+        # plugins must be Capitalized
+        def plugin_class(plugin_name_sym)
+          # Module.nesting[2] is Cli::Plugins
+          return Object.const_get("#{Module.nesting[2]}::#{PLUGINS_MODULE}::#{plugin_name_sym.to_s.capitalize}")
+        end
+      end
+
+      def initialize
+        @lookup_folders = []
+        @plugins = {}
+      end
+
+      def add_plugin_info(path)
+        raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
+        plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym
+        req = path.sub(/#{RUBY_FILE_EXT}$/o, '')
+        if @plugins.key?(plugin_symbol)
+          Log.log.warn{"skipping plugin already registered: #{plugin_symbol}"}
+          return
+        end
+        @plugins[plugin_symbol] = {source: path, require_stanza: req}
+      end
+
+      def add_lookup_folder(folder)
+        @lookup_folders.unshift(folder)
+      end
+
+      # find plugins in defined paths
+      def add_plugins_from_lookup_folders
+        @lookup_folders.each do |folder|
+          next unless File.directory?(folder)
+          # TODO: add gem root to load path ? and require short folder ?
+          # $LOAD_PATH.push(folder) if i[:add_path]
+          Dir.entries(folder).select{|file|file.end_with?(RUBY_FILE_EXT)}.each do |source|
+            add_plugin_info(File.join(folder, source))
+          end
+        end
+      end
+
+      def create(plugin_name_sym, **args)
+        # TODO: check that ancestor is Plugin?
+        self.class.plugin_class(plugin_name_sym).new(**args)
+      end
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'aspera/aoc'
+require 'aspera/api/aoc'
 
 module Aspera
   module Cli
     module Plugins
-      class Alee < Aspera::Cli::BasicAuthPlugin
+      class Alee < Cli::BasicAuthPlugin
         ACTIONS = %i[entitlement].freeze
 
         def execute_action
@@ -14,11 +14,11 @@ module Aspera
           when :entitlement
             entitlement_id = options.get_option(:username, mandatory: true)
             customer_id = options.get_option(:password, mandatory: true)
-            api_metering = AoC.metering_api(entitlement_id, customer_id)
+            api_metering = Api::AoC.metering_api(entitlement_id, customer_id)
             return {type: :single_object, data: api_metering.read('entitlement')[:data]}
           end
         end
-      end # Aspera
-    end # Plugins
-  end # Cli
-end # Aspera
+      end
+    end
+  end
+end