aspera-cli 4.6.0 → 4.7.0

data/lib/aspera/cli/manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/colors'
 require 'aspera/log'
 require 'aspera/cli/extended_value'
@@ -29,11 +30,11 @@ module Aspera
       end
 
       def value
-        @object.send(@attr_symb.to_s)
+        return @object.send(@attr_symb)
       end
 
       def value=(val)
-        @object.send(@attr_symb.to_s+'=',val)
+        @object.send("#{@attr_symb}=",val)
       end
     end
 
@@ -41,14 +42,10 @@ module Aspera
     # arguments options start with '-', others are commands
     # resolves on extended value syntax
     class Manager
-      def self.time_to_string(time)
-        time.strftime("%Y-%m-%d %H:%M:%S")
-      end
-
       # boolean options are set to true/false from the following values
-      TRUE_VALUES=[:yes,true]
-      BOOLEAN_VALUES=TRUE_VALUES.clone.push(:no,false)
-      BOOLEAN_SIMPLE=[:yes,:no]
+      TRUE_VALUES=[:yes,true].freeze
+      BOOLEAN_VALUES=[TRUE_VALUES,:no,false].flatten.freeze
+      BOOLEAN_SIMPLE=[:yes,:no].freeze
       # option name separator on command line
       OPTION_SEP_LINE='-'
       # option name separator in code (symbol)
@@ -56,30 +53,37 @@ module Aspera
 
       private_constant :TRUE_VALUES,:BOOLEAN_VALUES,:BOOLEAN_SIMPLE,:OPTION_SEP_LINE,:OPTION_SEP_NAME
 
-      def enum_to_bool(enum);TRUE_VALUES.include?(enum);end
-
-      # find shortened string value in allowed symbol list
-      def self.get_from_list(shortval,descr,allowed_values)
-        # we accept shortcuts
-        matching_exact=allowed_values.select{|i| i.to_s.eql?(shortval)}
-        return matching_exact.first if matching_exact.length == 1
-        matching=allowed_values.select{|i| i.to_s.start_with?(shortval)}
-        raise cli_bad_arg("unknown value for #{descr}: #{shortval}",allowed_values) if matching.empty?
-        raise cli_bad_arg("ambigous shortcut for #{descr}: #{shortval}",matching) unless matching.length.eql?(1)
-        return enum_to_bool(matching.first) if allowed_values.eql?(BOOLEAN_VALUES)
-        return matching.first
-      end
+      class << self
+        def enum_to_bool(enum)
+          raise "Value not valid for boolean: #{enum}/#{enum.class}" unless BOOLEAN_VALUES.include?(enum)
+          return TRUE_VALUES.include?(enum)
+        end
+
+        def time_to_string(time)
+          return time.strftime('%Y-%m-%d %H:%M:%S')
+        end
+
+        # find shortened string value in allowed symbol list
+        def get_from_list(shortval,descr,allowed_values)
+          # we accept shortcuts
+          matching_exact=allowed_values.select{|i| i.to_s.eql?(shortval)}
+          return matching_exact.first if matching_exact.length == 1
+          matching=allowed_values.select{|i| i.to_s.start_with?(shortval)}
+          raise CliBadArgument,bad_arg_message_multi("unknown value for #{descr}: #{shortval}",allowed_values) if matching.empty?
+          raise CliBadArgument,bad_arg_message_multi("ambigous shortcut for #{descr}: #{shortval}",matching) unless matching.length.eql?(1)
+          return enum_to_bool(matching.first) if allowed_values.eql?(BOOLEAN_VALUES)
+          return matching.first
+        end
 
-      def self.cli_bad_arg(error_msg,choices)
-        return CliBadArgument.new(error_msg+"\nUse:\n"+choices.map{|c| "- #{c.to_s}\n"}.sort.join(''))
+        def bad_arg_message_multi(error_msg,choices)
+          return [error_msg,'Use:',choices.map{|c|"- #{c}"}.sort].flatten.join("\n")
+        end
       end
 
       attr_reader :parser
-      attr_accessor :ask_missing_mandatory
-      attr_accessor :ask_missing_optional
+      attr_accessor :ask_missing_mandatory, :ask_missing_optional
       attr_writer :fail_on_missing_mandatory
 
-      #
       def initialize(program_name,argv=nil)
         # command line values not starting with '-'
         @unprocessed_cmd_line_arguments=[]
@@ -114,15 +118,15 @@ module Aspera
         unless argv.nil?
           @parser.separator('')
           @parser.separator('OPTIONS: global')
-          self.set_obj_attr(:interactive,self,:ask_missing_mandatory)
-          self.set_obj_attr(:ask_options,self,:ask_missing_optional)
-          self.add_opt_boolean(:interactive,'use interactive input of missing params')
-          self.add_opt_boolean(:ask_options,'ask even optional options')
-          self.parse_options!
+          set_obj_attr(:interactive,self,:ask_missing_mandatory)
+          set_obj_attr(:ask_options,self,:ask_missing_optional)
+          add_opt_boolean(:interactive,'use interactive input of missing params')
+          add_opt_boolean(:ask_options,'ask even optional options')
+          parse_options!
           process_options=true
           while !argv.empty?
             value=argv.shift
-            if process_options and value.start_with?('-')
+            if process_options && value.start_with?('-')
               if value.eql?('--')
                 process_options=false
               else
@@ -137,41 +141,6 @@ module Aspera
         Log.log.debug("add_cmd_line_options:commands/args=#{@unprocessed_cmd_line_arguments},options=#{@unprocessed_cmd_line_options}".red)
       end
 
-      def prompt_user_input(prompt,sensitive)
-        return STDIN.getpass("#{prompt}> ") if sensitive
-        print "#{prompt}> "
-        return STDIN.gets.chomp
-      end
-
-      def get_interactive(type,descr,expected=:single)
-        if !@ask_missing_mandatory
-          if expected.is_a?(Array)
-            raise self.class.cli_bad_arg("missing: #{descr}",expected)
-          end
-          raise CliBadArgument,"missing argument (#{expected}): #{descr}"
-        end
-        result=nil
-        # Note: mandatory parenthesis here !
-        sensitive = (type.eql?(:option) and @declared_options[descr.to_sym][:sensitive].eql?(true))
-        default_prompt="#{type}: #{descr}"
-        # ask interactively
-        case expected
-        when :multiple
-          result=[]
-          puts " (one per line, end with empty line)"
-          loop do
-            entry=prompt_user_input(default_prompt,sensitive)
-            break if entry.empty?
-            result.push(ExtendedValue.instance.evaluate(entry))
-          end
-        when :single
-          result=ExtendedValue.instance.evaluate(prompt_user_input(default_prompt,sensitive))
-        else # one fixed
-          result=self.class.get_from_list(prompt_user_input("#{expected.join(' ')}\n#{default_prompt}",sensitive),descr,expected)
-        end
-        return result
-      end
-
       def get_next_command(command_list); return get_next_argument('command',command_list); end
 
       # @param expected is
@@ -190,17 +159,15 @@ module Aspera
           when :multiple
             result = @unprocessed_cmd_line_arguments.shift(@unprocessed_cmd_line_arguments.length).map{|v|ExtendedValue.instance.evaluate(v)}
             # if expecting list and only one arg of type array : it is the list
-            if result.length.eql?(1) and result.first.is_a?(Array)
+            if result.length.eql?(1) && result.first.is_a?(Array)
               result=result.first
             end
           else
             result=self.class.get_from_list(@unprocessed_cmd_line_arguments.shift,descr,expected)
           end
-        else
+        elsif is_type.eql?(:mandatory)
           # no value provided
-          if is_type.eql?(:mandatory)
-            result=get_interactive(:argument,descr,expected)
-          end
+          result=get_interactive(:argument,descr,expected)
         end
         Log.log.debug("#{descr}=#{result}")
         return result
@@ -213,13 +180,9 @@ module Aspera
           raise "INTERNAL ERROR: option #{option_symbol} already declared. only accessor can be redeclared and ignored" unless @declared_options[option_symbol][:type].eql?(:accessor)
           return
         end
-        @declared_options[option_symbol]={:type=>type}
+        @declared_options[option_symbol]={type: type}
         # by default passwords and secrets are sensitive, else specify when declaring the option
-        set_is_sensitive(option_symbol) if !%w{password secret key}.select{|i| option_symbol.to_s.end_with?(i)}.empty?
-      end
-
-      def set_is_sensitive(option_symbol)
-        @declared_options[option_symbol][:sensitive]=true
+        @declared_options[option_symbol][:sensitive]=true if !%w[password secret key].select{|i| option_symbol.to_s.end_with?(i)}.empty?
       end
 
       # define option with handler
@@ -227,29 +190,26 @@ module Aspera
         Log.log.debug("set attr obj #{option_symbol} (#{object},#{attr_symb})")
         declare_option(option_symbol,:accessor)
         @declared_options[option_symbol][:accessor]=AttrAccessor.new(object,attr_symb)
-        set_option(option_symbol,default_value,"default obj attr") if !default_value.nil?
+        set_option(option_symbol,default_value,'default obj attr') if !default_value.nil?
       end
 
       # set an option value by name, either store value or call handler
-      def set_option(option_symbol,value,where="default")
-        if ! @declared_options.has_key?(option_symbol)
+      def set_option(option_symbol,value,where='default')
+        if !@declared_options.has_key?(option_symbol)
           Log.log.debug("set unknown option: #{option_symbol}")
-          raise "ERROR: cannot set undeclared option"
+          raise 'ERROR: cannot set undeclared option'
           #declare_option(option_symbol)
         end
         value=ExtendedValue.instance.evaluate(value)
-        Log.log.debug("set_option(#{where}) #{option_symbol}=#{value}")
-        if @declared_options[option_symbol][:values].eql?(BOOLEAN_VALUES)
-          value=enum_to_bool(value)
-        end
-        Log.log.debug("set #{option_symbol}=#{value} (#{@declared_options[option_symbol][:type]}) : #{where}".blue)
+        value=Manager.enum_to_bool(value) if @declared_options[option_symbol][:values].eql?(BOOLEAN_VALUES)
+        Log.log.debug("set #{option_symbol}=#{value} (#{@declared_options[option_symbol][:type]}) : #{where}")
         case @declared_options[option_symbol][:type]
         when :accessor
           @declared_options[option_symbol][:accessor].value=value
         when :value
           @declared_options[option_symbol][:value]=value
         else # nil or other
-          raise "error"
+          raise 'error'
         end
       end
 
@@ -265,28 +225,25 @@ module Aspera
           when :value
             result=@declared_options[option_symbol][:value]
           else
-            raise "unknown type"
+            raise 'unknown type'
           end
           Log.log.debug("get #{option_symbol} (#{@declared_options[option_symbol][:type]}) : #{result}")
         end
         # do not fail for manual generation if option mandatory but not set
-        result||='' unless @fail_on_missing_mandatory
-        Log.log.debug("interactive=#{@ask_missing_mandatory}")
+        result='' if result.nil? && !@fail_on_missing_mandatory
+        #Log.log.debug("interactive=#{@ask_missing_mandatory}")
         if result.nil?
           if !@ask_missing_mandatory
-            if is_type.eql?(:mandatory)
-              raise CliBadArgument,"Missing mandatory option: #{option_symbol}"
-            end
-          else # ask_missing_mandatory
-            if @ask_missing_optional or is_type.eql?(:mandatory)
-              expected=:single
-              #print "please enter: #{option_symbol.to_s}"
-              if @declared_options.has_key?(option_symbol) and @declared_options[option_symbol].has_key?(:values)
-                expected=@declared_options[option_symbol][:values]
-              end
-              result=get_interactive(:option,option_symbol.to_s,expected)
-              set_option(option_symbol,result,"interactive")
+            raise CliBadArgument,"Missing mandatory option: #{option_symbol}" if is_type.eql?(:mandatory)
+          elsif @ask_missing_optional || is_type.eql?(:mandatory)
+            # ask_missing_mandatory
+            expected=:single
+            #print "please enter: #{option_symbol.to_s}"
+            if @declared_options.has_key?(option_symbol) && @declared_options[option_symbol].has_key?(:values)
+              expected=@declared_options[option_symbol][:values]
             end
+            result=get_interactive(:option,option_symbol.to_s,expected)
+            set_option(option_symbol,result,'interactive')
           end
         end
         return result
@@ -300,17 +257,6 @@ module Aspera
         preset_hash.each{|k,v|@unprocessed_defaults.send(op,[k.to_sym,v])}
       end
 
-      # generate command line option from option symbol
-      def symbol_to_option(symbol,opt_val)
-        result='--'+symbol.to_s.gsub(OPTION_SEP_NAME,OPTION_SEP_LINE)
-        result=result+'='+opt_val unless opt_val.nil?
-        return result
-      end
-
-      def highlight_current(value)
-        STDOUT.isatty ? value.to_s.red.bold : "[#{value}]"
-      end
-
       # define an option with restricted values
       def add_opt_list(option_symbol,values,help,*on_args)
         declare_option(option_symbol,:value)
@@ -321,12 +267,12 @@ module Aspera
         value=get_option(option_symbol)
         help_values=values.map{|i|i.eql?(value)?highlight_current(i):i}.join(', ')
         if values.eql?(BOOLEAN_VALUES)
-          help_values=BOOLEAN_SIMPLE.map{|i|((i.eql?(:yes) and value) or (i.eql?(:no) and not value))?highlight_current(i):i}.join(', ')
+          help_values=BOOLEAN_SIMPLE.map{|i|(i.eql?(:yes) && value) || (i.eql?(:no) && !value) ? highlight_current(i) : i}.join(', ')
         end
         on_args.push(values)
         on_args.push("#{help}: #{help_values}")
         Log.log.debug("on_args=#{on_args}")
-        @parser.on(*on_args){|v|set_option(option_symbol,self.class.get_from_list(v.to_s,help,values),"cmdline")}
+        @parser.on(*on_args){|v|set_option(option_symbol,self.class.get_from_list(v.to_s,help,values),'cmdline')}
       end
 
       def add_opt_boolean(option_symbol,help,*on_args)
@@ -337,22 +283,22 @@ module Aspera
       def add_opt_simple(option_symbol,*on_args)
         declare_option(option_symbol,:value)
         Log.log.debug("add_opt_simple #{option_symbol}")
-        on_args.unshift(symbol_to_option(option_symbol,"VALUE"))
+        on_args.unshift(symbol_to_option(option_symbol,'VALUE'))
         Log.log.debug("on_args=#{on_args}")
-        @parser.on(*on_args) { |v| set_option(option_symbol,v,"cmdline") }
+        @parser.on(*on_args) { |v| set_option(option_symbol,v,'cmdline') }
       end
 
       # define an option with date format
       def add_opt_date(option_symbol,*on_args)
         declare_option(option_symbol,:value)
         Log.log.debug("add_opt_date #{option_symbol}")
-        on_args.unshift(symbol_to_option(option_symbol,"DATE"))
+        on_args.unshift(symbol_to_option(option_symbol,'DATE'))
         Log.log.debug("on_args=#{on_args}")
         @parser.on(*on_args) do |v|
           case v
-          when 'now'; set_option(option_symbol,Manager.time_to_string(Time.now),"cmdline")
-          when /^-([0-9]+)h/; set_option(option_symbol,Manager.time_to_string(Time.now-$1.to_i*3600),"cmdline")
-          else set_option(option_symbol,v,"cmdline")
+          when 'now' then set_option(option_symbol,Manager.time_to_string(Time.now),'cmdline')
+          when /^-([0-9]+)h/ then set_option(option_symbol,Manager.time_to_string(Time.now-(3600*Regexp.last_match(1).to_i)),'cmdline')
+          else set_option(option_symbol,v,'cmdline')
           end
         end
       end
@@ -379,15 +325,15 @@ module Aspera
       end
 
       # get all original options  on command line used to generate a config in config file
-      def get_options_table(remove_from_remaining=true)
+      def get_options_table(remove_from_remaining: true)
         result={}
         @initial_cli_options.each do |optionval|
           case optionval
           when /^--([^=]+)$/
             # ignore
           when /^--([^=]+)=(.*)$/
-            name=$1
-            value=$2
+            name=Regexp.last_match(1)
+            value=Regexp.last_match(2)
             name.gsub!(OPTION_SEP_LINE,OPTION_SEP_NAME)
             value=ExtendedValue.instance.evaluate(value)
             Log.log.debug("option #{name}=#{value}")
@@ -401,46 +347,28 @@ module Aspera
       end
 
       # return options as taken from config file and command line just before command execution
-      def declared_options(all=true)
-        return @declared_options.keys.inject({}) do |h,option_symb|
+      def declared_options(only_defined: false)
+        result={}
+        @declared_options.keys.each do |option_symb|
           v=get_option(option_symb)
-          h[option_symb.to_s]=v if all or !v.nil?
-          h
+          result[option_symb.to_s]=v unless only_defined && v.nil?
         end
-      end
-
-      def apply_options_preset(preset,where,force=false)
-        unprocessed=[]
-        preset.each do |pair|
-          k,v=*pair
-          if @declared_options.has_key?(k)
-            # constrained parameters as string are revert to symbol
-            if @declared_options[k].has_key?(:values) and v.is_a?(String)
-              v=self.class.get_from_list(v,k.to_s+" in #{where}",@declared_options[k][:values])
-            end
-            set_option(k,v,where)
-          else
-            unprocessed.push(pair)
-          end
-        end
-        # keep only unprocessed values for next parse
-        preset.clear
-        preset.push(*unprocessed)
+        return result
       end
 
       # removes already known options from the list
       def parse_options!
-        Log.log.debug("parse_options!".red)
+        Log.log.debug('parse_options!'.red)
         # first conf file, then env var
-        apply_options_preset(@unprocessed_defaults,"file")
-        apply_options_preset(@unprocessed_env,"env")
+        apply_options_preset(@unprocessed_defaults,'file')
+        apply_options_preset(@unprocessed_env,'env')
         # command line override
         unknown_options=[]
         begin
           # remove known options one by one, exception if unknown
-          Log.log.debug("before parse".red)
+          Log.log.debug('before parse'.red)
           @parser.parse!(@unprocessed_cmd_line_options)
-          Log.log.debug("After parse".red)
+          Log.log.debug('After parse'.red)
         rescue OptionParser::InvalidOption => e
           Log.log.debug("InvalidOption #{e}".red)
           # save for later processing
@@ -451,6 +379,70 @@ module Aspera
         # set unprocessed options for next time
         @unprocessed_cmd_line_options=unknown_options
       end
+
+      private
+
+      def prompt_user_input(prompt,sensitive)
+        return $stdin.getpass("#{prompt}> ") if sensitive
+        print "#{prompt}> "
+        return $stdin.gets.chomp
+      end
+
+      def get_interactive(type,descr,expected=:single)
+        if !@ask_missing_mandatory
+          raise CliBadArgument,self.class.bad_arg_message_multi("missing: #{descr}",expected) if expected.is_a?(Array)
+          raise CliBadArgument,"missing argument (#{expected}): #{descr}"
+        end
+        result=nil
+        sensitive = type.eql?(:option) && @declared_options[descr.to_sym][:sensitive]
+        default_prompt="#{type}: #{descr}"
+        # ask interactively
+        case expected
+        when :multiple
+          result=[]
+          puts(' (one per line, end with empty line)')
+          loop do
+            entry=prompt_user_input(default_prompt,sensitive)
+            break if entry.empty?
+            result.push(ExtendedValue.instance.evaluate(entry))
+          end
+        when :single
+          result=ExtendedValue.instance.evaluate(prompt_user_input(default_prompt,sensitive))
+        else # one fixed
+          result=self.class.get_from_list(prompt_user_input("#{expected.join(' ')}\n#{default_prompt}",sensitive),descr,expected)
+        end
+        return result
+      end
+
+      # generate command line option from option symbol
+      def symbol_to_option(symbol,opt_val)
+        result='--'+symbol.to_s.gsub(OPTION_SEP_NAME,OPTION_SEP_LINE)
+        result=result+'='+opt_val unless opt_val.nil?
+        return result
+      end
+
+      def highlight_current(value)
+        $stdout.isatty ? value.to_s.red.bold : "[#{value}]"
+      end
+
+      def apply_options_preset(preset,where)
+        unprocessed=[]
+        preset.each do |pair|
+          k,v=*pair
+          if @declared_options.has_key?(k)
+            # constrained parameters as string are revert to symbol
+            if @declared_options[k].has_key?(:values) && v.is_a?(String)
+              v=self.class.get_from_list(v,k.to_s+" in #{where}",@declared_options[k][:values])
+            end
+            set_option(k,v,where)
+          else
+            unprocessed.push(pair)
+          end
+        end
+        # keep only unprocessed values for next parse
+        preset.clear
+        preset.push(*unprocessed)
+      end
     end
   end
 end

data/lib/aspera/cli/plugin.rb

@@ -1,51 +1,57 @@
+# frozen_string_literal: true
 module Aspera
   module Cli
     # base class for plugins modules
     class Plugin
       # operation without id
-      GLOBAL_OPS=[:create,:list]
+      GLOBAL_OPS=[:create,:list].freeze
       # operation on specific instance
-      INSTANCE_OPS=[:modify,:delete,:show]
-      ALL_OPS=[GLOBAL_OPS,INSTANCE_OPS].flatten
+      INSTANCE_OPS=[:modify,:delete,:show].freeze
+      ALL_OPS=[GLOBAL_OPS,INSTANCE_OPS].flatten.freeze
       # max number of items for list command
       MAX_ITEMS='max'
       # max number of pages for list command
       MAX_PAGES='pmax'
 
-      @@done=false
+      # global for inherited classes
+      @@options_created=false # rubocop:disable Style/ClassVars
 
       def initialize(env)
         @agents=env
         raise StandardError,"execute_action shall be redefined by subclass #{self.class}" unless respond_to?(:execute_action)
-        raise StandardError,"ACTIONS shall be redefined by subclass" unless self.class.constants.include?(:ACTIONS)
+        raise StandardError,'ACTIONS shall be redefined by subclass' unless self.class.constants.include?(:ACTIONS)
         unless env[:skip_option_header]
-          self.options.parser.separator ""
-          self.options.parser.separator "COMMAND: #{self.class.name.split('::').last.downcase}"
-          self.options.parser.separator "SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map{ |p| p.to_s}.join(' ')}"
-          self.options.parser.separator "OPTIONS:"
-        end
-        unless @@done
-          self.options.add_opt_simple(:value,"extended value for create, update, list filter")
-          self.options.add_opt_simple(:property,"name of property to set")
-          self.options.add_opt_simple(:id,"resource identifier (#{INSTANCE_OPS.join(",")})")
-          self.options.parse_options!
-          @@done=true
+          options.parser.separator ''
+          options.parser.separator "COMMAND: #{self.class.name.split('::').last.downcase}"
+          options.parser.separator "SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map(&:to_s).join(' ')}"
+          options.parser.separator 'OPTIONS:'
         end
+        return if @@options_created
+        options.add_opt_simple(:value,'extended value for create, update, list filter')
+        options.add_opt_simple(:property,'name of property to set')
+        options.add_opt_simple(:id,"resource identifier (#{INSTANCE_OPS.join(',')})")
+        options.parse_options!
+        @@options_created=true # rubocop:disable Style/ClassVars
       end
 
       # must be called AFTER the instance action
-      def instance_identifier()
-        res_id=self.options.get_option(:id)
-        res_id=self.options.get_next_argument('identifier') if res_id.nil?
+      def instance_identifier
+        res_id=options.get_option(:id)
+        res_id=options.get_next_argument('identifier') if res_id.nil?
         return res_id
       end
 
-      def entity_command(command,rest_api,res_class_path,display_fields,id_symb,id_default=nil,use_subkey=false)
-        raise "not id" unless :id.eql?(id_symb)
+      # @param command [Symbol] command to execute: create show list modify delete
+      # @param rest_api [Rest] api to use
+      # @param res_class_path [String] sub path in URL to resource relative to base url
+      # @param display_fields [Array] fields to display by default
+      # @param id_default [String] default identifier to use for existing entity commands (show, modify)
+      # @param use_subkey [bool] true if the result is in a subkey of the json
+      def entity_command(command,rest_api,res_class_path,display_fields: nil,id_default: nil,use_subkey: false)
         if INSTANCE_OPS.include?(command)
           begin
             one_res_id=instance_identifier()
-          rescue => e
+          rescue StandardError => e
             raise e if id_default.nil?
             one_res_id=id_default
           end
@@ -53,17 +59,17 @@ module Aspera
         end
         # parameters mandatory for create/modify
         if [:create,:modify].include?(command)
-          parameters=self.options.get_option(:value,:mandatory)
+          parameters=options.get_option(:value,:mandatory)
         end
         # parameters optional for list
         if [:list].include?(command)
-          parameters=self.options.get_option(:value,:optional)
+          parameters=options.get_option(:value,:optional)
         end
         case command
         when :create
-          return {:type => :single_object, :data=>rest_api.create(res_class_path,parameters)[:data], :fields=>display_fields}
+          return {type: :single_object, data: rest_api.create(res_class_path,parameters)[:data], fields: display_fields}
         when :show
-          return {:type => :single_object, :data=>rest_api.read(one_res_path)[:data], :fields=>display_fields}
+          return {type: :single_object, data: rest_api.read(one_res_path)[:data], fields: display_fields}
         when :list
           resp=rest_api.read(res_class_path,parameters)
           data=resp[:data]
@@ -72,26 +78,25 @@ module Aspera
             data=data[res_class_path]
           end
           data=data[res_class_path] if use_subkey
-          return {:type => :object_list, :data=>data, :fields=>display_fields}
+          return {type: :object_list, data: data, fields: display_fields}
         when :modify
-          property=self.options.get_option(:property,:optional)
+          property=options.get_option(:property,:optional)
           parameters={property => parameters} unless property.nil?
           rest_api.update(one_res_path,parameters)
           return Main.result_status('modified')
         when :delete
           rest_api.delete(one_res_path)
-          return Main.result_status("deleted")
+          return Main.result_status('deleted')
         else
           raise "unknown action: #{command}"
         end
-        raise "internal error should not reach here"
       end
 
       # implement generic rest operations on given resource path
-      def entity_action(rest_api,res_class_path,display_fields,id_symb,id_default=nil,use_subkey=false)
+      def entity_action(rest_api,res_class_path,**opts)
         #res_name=res_class_path.gsub(%r{^.*/},'').gsub(%r{s$},'').gsub('_',' ')
-        command=self.options.get_next_command(ALL_OPS)
-        return entity_command(command,rest_api,res_class_path,display_fields,id_symb,id_default,use_subkey)
+        command=options.get_next_command(ALL_OPS)
+        return entity_command(command,rest_api,res_class_path,**opts)
       end
 
       # shortcuts for plugin environment
@@ -104,7 +109,6 @@ module Aspera
       def format; return @agents[:formater];end
 
       def persistency; return @agents[:persistency];end
-
     end # Plugin
   end # Cli
 end # Aspera

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/rest'
 require 'aspera/aoc'
 
@@ -5,17 +6,16 @@ module Aspera
   module Cli
     module Plugins
       class Alee < BasicAuthPlugin
-
-        ACTIONS=[ :entitlement ]
+        ACTIONS=[:entitlement]
 
         def execute_action
-          command=self.options.get_next_command(ACTIONS)
+          command=options.get_next_command(ACTIONS)
           case command
           when :entitlement
-            entitlement_id = self.options.get_option(:username,:mandatory)
-            customer_id = self.options.get_option(:password,:mandatory)
+            entitlement_id = options.get_option(:username,:mandatory)
+            customer_id = options.get_option(:password,:mandatory)
             api_metering=AoC.metering_api(entitlement_id,customer_id)
-            return {:type=>:single_object, :data=>api_metering.read('entitlement')[:data]}
+            return {type: :single_object, data: api_metering.read('entitlement')[:data]}
           end
         end
       end # Aspera