aspera-cli 4.22.0 → 4.24.0

data/lib/aspera/assert.rb

@@ -1,55 +1,86 @@
 # frozen_string_literal: true
 
 module Aspera
-  class InternalError < StandardError
+  # Generic error in gem
+  class Error < StandardError
   end
 
-  class AssertError < StandardError
+  # Error that shall not happen, else it's a bug
+  class InternalError < Error
+  end
+
+  # An expected condition was not met
+  class AssertError < Error
   end
   class << self
-    # the block is executed in the context of the Aspera module
-    def assert(assertion, info = nil, exception_class: AssertError)
+    # Replace `raise`, allows sending exception, or just error log, when type is `:error`
+    # @param type [Exception,Symbol] Send to log if symbol, else raise exception
+    # @param message [String] Message for error.
+    def report_error(type, message)
+      if type.is_a?(Symbol)
+        Log.log.send(type, message)
+      else
+        raise type, message
+      end
+    end
+
+    # Assert that a condition is true, else raise exception
+    # @param assertion [Bool]       Must be true
+    # @param info      [String,nil] Fixed message in case assert fails, else use `block`
+    # @param type      [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block     [Proc]       Produces a string that desribes the problem for complex messages
+    # The block is executed in the context of the Aspera module
+    def assert(assertion, info = nil, type: AssertError)
       raise InternalError, 'bad assert: both info and block given' unless info.nil? || !block_given?
       return if assertion
       message = 'assertion failed'
       info = yield if block_given?
       message = "#{message}: #{info}" if info
       message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
-      raise exception_class, message
+      report_error(type, message)
     end
 
-    # assert that value has the given type
-    # @param value [Object] the value to check
-    # @param type [Class] the expected type
-    def assert_type(value, type, exception_class: AssertError)
-      assert(value.is_a?(type), exception_class: exception_class){"#{block_given? ? "#{yield}: " : nil}expecting #{type}, but have #{value.inspect}"}
+    # Assert that value has the given type
+    # @param value   [Object]       The value to check
+    # @param classes [Class, Array] The expected type(s)
+    # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block   [Proc]         Additional description in front of message
+    def assert_type(value, *classes, type: AssertError)
+      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting #{classes.join(', ')}, but have #{value.inspect}"}
     end
 
-    # assert that value is one of the given values
-    # @param value value to check
-    # @param values accepted values
-    # @param exception_class exception in case of no match
-    def assert_values(value, values, exception_class: AssertError)
-      assert(values.include?(value), exception_class: exception_class) do
+    # Assert that value is one of the given values
+    # @param value  [any]   value to check
+    # @param values [Array] accepted values
+    # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block  [Proc]         Additional description in front of message
+    def assert_values(value, values, type: AssertError)
+      assert(values.include?(value), type: type) do
         val_list = values.inspect
         val_list = "one of #{val_list}" if values.is_a?(Array)
-        "#{block_given? ? "#{yield}: " : nil}expecting #{val_list}, but have #{value.inspect}"
+        "#{"#{yield}: " if block_given?}expecting #{val_list}, but have #{value.inspect}"
       end
     end
 
-    # the line with this shall never be reached
+    # The value is not one of the expected values
+    # @param value  [any]              The wrong value
+    # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block  [Proc]             Additional description in front of message
+    def error_unexpected_value(value, type: InternalError)
+      report_error(type, "#{"#{yield}: " if block_given?}unexpected value: #{value.inspect}")
+    end
+
+    # The line with this shall never be reached
     def error_unreachable_line
       raise InternalError, "unreachable line reached: #{caller(2..2).first}"
     end
 
-    # The value is not one of the expected values
-    # @param value the wrong value
-    # @param exception_class exception to raise
-    # @param block additional description in front
-    def error_unexpected_value(value, exception_class: InternalError)
-      raise exception_class, "#{block_given? ? "#{yield}: " : nil}unexpected value: #{value.inspect}"
+    # Not implemented error
+    def error_not_implemented
+      raise Error, 'Feature not yet implemented'
     end
 
+    # Use in superclass to require the given method in subclass.
     def require_method!(name)
       define_method(name) do |*_args|
         raise NotImplementedError, "#{self.class} must implement the #{name} method"

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -9,20 +9,20 @@ module Aspera
     class BasicAuthPlugin < Cli::Plugin
       class << self
         def declare_options(options)
-          options.declare(:url, 'URL of application, e.g. https://faspex.example.com/aspera/faspex')
-          options.declare(:username, "User's name to log in")
+          options.declare(:url, 'URL of application, e.g. https://app.example.com/aspera/app')
+          options.declare(:username, "User's identifier")
           options.declare(:password, "User's password")
           options.parse_options!
         end
       end
 
-      def initialize(basic_options: true, **env)
-        super(**env)
+      def initialize(context:, basic_options: true)
+        super(context: context)
         BasicAuthPlugin.declare_options(options) if basic_options
       end
 
       # returns a Rest object with basic auth
-      def basic_auth_params(subpath=nil)
+      def basic_auth_params(subpath = nil)
         api_url = options.get_option(:url, mandatory: true)
         api_url = "#{api_url}/#{subpath}" unless subpath.nil?
         return {
@@ -31,10 +31,11 @@ module Aspera
             type:     :basic,
             username: options.get_option(:username, mandatory: true),
             password: options.get_option(:password, mandatory: true)
-          }}
+          }
+        }
       end
 
-      def basic_auth_api(subpath=nil)
+      def basic_auth_api(subpath = nil)
         return Rest.new(**basic_auth_params(subpath))
       end
     end

data/lib/aspera/cli/error.rb

@@ -4,7 +4,7 @@ module Aspera
   module Cli
     # CLI base exception
     class Error < StandardError; end
-    # raised when an unexpected argument is provided
+    # Raised when an unexpected argument is provided.
     class BadArgument < Error; end
     class NoSuchElement < Error; end
 

data/lib/aspera/cli/extended_value.rb

@@ -41,12 +41,12 @@ module Aspera
               hash_array.push(col_titles.zip(values).to_h)
             end
           end
-          Log.log.warn('Titled CSV file without any line') if hash_array.empty?
+          Log.log.warn('Titled CSV file without any row') if hash_array.empty?
           return hash_array
         end
 
-        def assert_no_value(v, what)
-          raise "no value allowed for extended value type: #{what}" unless v.empty?
+        def assert_no_value(value, what)
+          raise "no value allowed for extended value type: #{what}" unless value.empty?
         end
       end
 
@@ -56,25 +56,25 @@ module Aspera
         # base handlers
         # other handlers can be set using set_handler, e.g. `preset` is reader in config plugin
         @handlers = {
-          val:    lambda{ |v| v},
-          base64: lambda{ |v| Base64.decode64(v)},
-          csvt:   lambda{ |v| ExtendedValue.decode_csvt(v)},
-          env:    lambda{ |v| ENV.fetch(v, nil)},
-          file:   lambda{ |v| File.read(File.expand_path(v))},
-          uri:    lambda{ |v| UriReader.read(v)},
-          json:   lambda{ |v| JSON_parse(v)},
-          lines:  lambda{ |v| v.split("\n")},
-          list:   lambda{ |v| v[1..-1].split(v[0])},
-          none:   lambda{ |v| ExtendedValue.assert_no_value(v, :none); nil}, # rubocop:disable Style/Semicolon
-          path:   lambda{ |v| File.expand_path(v)},
-          re:     lambda{ |v| Regexp.new(v, Regexp::MULTILINE)},
-          ruby:   lambda{ |v| Environment.secure_eval(v, __FILE__, __LINE__)},
-          secret: lambda{ |v| prompt = v.empty? ? 'secret' : v; $stdin.getpass("#{prompt}> ")}, # rubocop:disable Style/Semicolon
-          stdin:  lambda{ |v| ExtendedValue.assert_no_value(v, :stdin); $stdin.read}, # rubocop:disable Style/Semicolon
-          stdbin: lambda{ |v| ExtendedValue.assert_no_value(v, :stdbin); $stdin.binmode.read}, # rubocop:disable Style/Semicolon
-          yaml:   lambda{ |v| YAML.load(v)},
-          zlib:   lambda{ |v| Zlib::Inflate.inflate(v)},
-          extend: lambda{ |v| ExtendedValue.instance.evaluate_all(v)}
+          val:    lambda{ |i| i},
+          base64: lambda{ |i| Base64.decode64(i)},
+          csvt:   lambda{ |i| ExtendedValue.decode_csvt(i)},
+          env:    lambda{ |i| ENV.fetch(i, nil)},
+          file:   lambda{ |i| File.read(File.expand_path(i))},
+          uri:    lambda{ |i| UriReader.read(i)},
+          json:   lambda{ |i| JSON_parse(i)},
+          lines:  lambda{ |i| i.split("\n")},
+          list:   lambda{ |i| i[1..-1].split(i[0])},
+          none:   lambda{ |i| ExtendedValue.assert_no_value(i, :none); nil}, # rubocop:disable Style/Semicolon
+          path:   lambda{ |i| File.expand_path(i)},
+          re:     lambda{ |i| Regexp.new(i, Regexp::MULTILINE)},
+          ruby:   lambda{ |i| Environment.secure_eval(i, __FILE__, __LINE__)},
+          secret: lambda{ |i| prompt = i.empty? ? 'secret' : i; $stdin.getpass("#{prompt}> ")}, # rubocop:disable Style/Semicolon
+          stdin:  lambda{ |i| ExtendedValue.assert_no_value(i, :stdin); $stdin.read}, # rubocop:disable Style/Semicolon
+          stdbin: lambda{ |i| ExtendedValue.assert_no_value(i, :stdbin); $stdin.binmode.read}, # rubocop:disable Style/Semicolon
+          yaml:   lambda{ |i| YAML.load(i)},
+          zlib:   lambda{ |i| Zlib::Inflate.inflate(i)},
+          extend: lambda{ |i| ExtendedValue.instance.evaluate_all(i)}
         }
         @default_decoder = nil
       end
@@ -85,14 +85,15 @@ module Aspera
       end
 
       # JSON Parser, with more information on error location
-      def JSON_parse(v)
-        JSON.parse(v)
+      # :reek:UncommunicativeMethodName
+      def JSON_parse(value) # rubocop:disable Naming/MethodName
+        JSON.parse(value)
       rescue JSON::ParserError => e
         m = /at line (\d+) column (\d+)/.match(e.message)
         raise if m.nil?
         line = m[1].to_i - 1
         column = m[2].to_i - 1
-        lines = v.lines
+        lines = value.lines
         raise if line >= lines.size
         error_line = lines[line].chomp
         context_col_beg = [column - 10, 0].max
@@ -145,9 +146,7 @@ module Aspera
       # parse string value as extended value
       # use default decoder if none is specified
       def evaluate_with_default(value)
-        if value.is_a?(String) && value.match(/^#{handler_regex_string}.*$/).nil? && !@default_decoder.nil?
-          value = [MARKER_START, @default_decoder, MARKER_END, value].join
-        end
+        value = [MARKER_START, @default_decoder, MARKER_END, value].join if value.is_a?(String) && value.match(/^#{handler_regex_string}.*$/).nil? && !@default_decoder.nil?
         return evaluate(value)
       end
 
@@ -157,7 +156,7 @@ module Aspera
         while (m = value.match(regex))
           sub_value = "@#{m[2]}:#{m[3]}"
           Log.log.debug{"evaluating #{sub_value}"}
-          value = m[1] + evaluate(sub_value) + m[4]
+          value = "#{m[1]}#{evaluate(sub_value)}#{m[4]}"
         end
         return value
       end