aspera-cli 4.6.0 → 4.7.0

data/lib/aspera/cli/transfer_agent.rb

@@ -1,4 +1,5 @@
-require 'aspera/fasp/parameters'
+# frozen_string_literal: true
+require 'aspera/fasp/transfer_spec'
 require 'aspera/cli/listener/logger'
 require 'aspera/cli/listener/progress_multi'
 
@@ -12,15 +13,15 @@ module Aspera
       FILE_LIST_FROM_ARGS='@args'
       # special value for --sources : read file list from transfer spec (--ts)
       FILE_LIST_FROM_TRANSFER_SPEC='@ts'
-      DEFAULT_TRANSFER_NOTIF_TMPL=<<END_OF_TEMPLATE
-From: <%=from_name%> <<%=from_email%>>
-To: <<%=to%>>
-Subject: <%=subject%>
+      DEFAULT_TRANSFER_NOTIF_TMPL=<<~END_OF_TEMPLATE
+        From: <%=from_name%> <<%=from_email%>>
+        To: <<%=to%>>
+        Subject: <%=subject%>
 
-Transfer is: <%=global_transfer_status%>
+        Transfer is: <%=global_transfer_status%>
 
-<%=ts.to_yaml%>
-END_OF_TEMPLATE
+        <%=ts.to_yaml%>
+      END_OF_TEMPLATE
       #% (formating bug in eclipse)
       private_constant :FILE_LIST_FROM_ARGS,:FILE_LIST_FROM_TRANSFER_SPEC,:DEFAULT_TRANSFER_NOTIF_TMPL
       TRANSFER_AGENTS=[:direct,:node,:connect,:httpgw,:trsdk]
@@ -39,12 +40,12 @@ END_OF_TEMPLATE
         @opt_mgr.set_obj_attr(:ts,self,:option_transfer_spec)
         @opt_mgr.add_opt_simple(:ts,"override transfer spec values (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:ts,:optional)}")
         @opt_mgr.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{@opt_mgr.get_option(:local_resume,:optional)}")
-        @opt_mgr.add_opt_simple(:to_folder,"destination folder for downloaded files")
-        @opt_mgr.add_opt_simple(:sources,"list of source files (see doc)")
-        @opt_mgr.add_opt_simple(:transfer_info,"parameters for transfer agent")
-        @opt_mgr.add_opt_list(:src_type,[:list,:pair],"type of file list")
-        @opt_mgr.add_opt_list(:transfer,TRANSFER_AGENTS,"type of transfer agent")
-        @opt_mgr.add_opt_list(:progress,[:none,:native,:multi],"type of progress bar")
+        @opt_mgr.add_opt_simple(:to_folder,'destination folder for downloaded files')
+        @opt_mgr.add_opt_simple(:sources,'list of source files (see doc)')
+        @opt_mgr.add_opt_simple(:transfer_info,'parameters for transfer agent')
+        @opt_mgr.add_opt_list(:src_type,[:list,:pair],'type of file list')
+        @opt_mgr.add_opt_list(:transfer,TRANSFER_AGENTS,'type of transfer agent')
+        @opt_mgr.add_opt_list(:progress,[:none,:native,:multi],'type of progress bar')
         @opt_mgr.set_option(:transfer,:direct)
         @opt_mgr.set_option(:src_type,:list)
         @opt_mgr.set_option(:progress,:native) # use native ascp progress bar as it is more reliable
@@ -58,12 +59,12 @@ END_OF_TEMPLATE
 
       def option_transfer_spec_deep_merge(ts); @transfer_spec_cmdline.deep_merge!(ts); end
 
-      def set_agent_instance(instance)
+      def agent_instance=(instance)
         @agent=instance
         @agent.add_listener(Listener::Logger.new)
         # use local progress bar if asked so, or if native and non local ascp (because only local ascp has native progress bar)
-        if @opt_mgr.get_option(:progress,:mandatory).eql?(:multi) or
-        (@opt_mgr.get_option(:progress,:mandatory).eql?(:native) and ! instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
+        if @opt_mgr.get_option(:progress,:mandatory).eql?(:multi) ||
+        (@opt_mgr.get_option(:progress,:mandatory).eql?(:native) && !instance.class.to_s.eql?('Aspera::Fasp::AgentDirect'))
           @agent.add_listener(@progress_listener)
         end
       end
@@ -76,20 +77,20 @@ END_OF_TEMPLATE
         agent_options=@opt_mgr.get_option(:transfer_info,:optional)
         raise CliBadArgument,"the transfer agent configuration shall be Hash, not #{agent_options.class} (#{agent_options}), use either @json:<json> or @preset:<parameter set name>" unless [Hash,NilClass].include?(agent_options.class)
         # special case
-        if agent_type.eql?(:node) and agent_options.nil?
+        if agent_type.eql?(:node) && agent_options.nil?
           param_set_name=@config.get_plugin_default_config_name(:node)
           raise CliBadArgument,"No default node configured, Please specify --#{:transfer_info.to_s.gsub('_','-')}" if param_set_name.nil?
           agent_options=@config.preset_by_name(param_set_name)
         end
         # special case
-        if agent_type.eql?(:direct) and @opt_mgr.get_option(:progress,:mandatory).eql?(:native)
+        if agent_type.eql?(:direct) && @opt_mgr.get_option(:progress,:mandatory).eql?(:native)
           agent_options={} if agent_options.nil?
           agent_options[:quiet]=false
         end
         agent_options=agent_options.symbolize_keys if agent_options.is_a?(Hash)
         # get agent instance
         new_agent=Kernel.const_get("Aspera::Fasp::Agent#{agent_type.capitalize}").new(agent_options)
-        set_agent_instance(new_agent)
+        self.agent_instance=new_agent
         return nil
       end
 
@@ -103,8 +104,8 @@ END_OF_TEMPLATE
         return dest_folder unless dest_folder.nil?
         # default: / on remote, . on local
         case direction.to_s
-        when 'send';dest_folder='/'
-        when 'receive';dest_folder='.'
+        when Fasp::TransferSpec::DIRECTION_SEND then dest_folder='/'
+        when Fasp::TransferSpec::DIRECTION_RECEIVE then dest_folder='.'
         else raise "wrong direction: #{direction}"
         end
         return dest_folder
@@ -112,7 +113,7 @@ END_OF_TEMPLATE
 
       # This is how the list of files to be transfered is specified
       # get paths suitable for transfer spec from command line
-      # @return {:source=>(mandatory), :destination=>(optional)}
+      # @return {source: (mandatory), destination: (optional)}
       # computation is done only once, cache is kept in @transfer_paths
       def ts_source_paths
         # return cache if set
@@ -123,25 +124,25 @@ END_OF_TEMPLATE
         file_list=@opt_mgr.get_option(:sources,:optional)
         case file_list
         when nil,FILE_LIST_FROM_ARGS
-          Log.log.debug("getting file list as parameters")
+          Log.log.debug('getting file list as parameters')
           # get remaining arguments
-          file_list=@opt_mgr.get_next_argument("source file list",:multiple)
-          raise CliBadArgument,"specify at least one file on command line or use --sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) or file_list.empty?
+          file_list=@opt_mgr.get_next_argument('source file list',:multiple)
+          raise CliBadArgument,"specify at least one file on command line or use --sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) || file_list.empty?
         when FILE_LIST_FROM_TRANSFER_SPEC
-          Log.log.debug("assume list provided in transfer spec")
+          Log.log.debug('assume list provided in transfer spec')
           special_case_direct_with_list=@opt_mgr.get_option(:transfer,:mandatory).eql?(:direct) and Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
-          raise CliBadArgument,"transfer spec on command line must have sources" if @transfer_paths.nil? and !special_case_direct_with_list
+          raise CliBadArgument,'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
           # here we assume check of sources is made in transfer agent
           return @transfer_paths
         when Array
-          Log.log.debug("getting file list as extended value")
-          raise CliBadArgument,"sources must be a Array of String" if !file_list.select{|f|!f.is_a?(String)}.empty?
+          Log.log.debug('getting file list as extended value')
+          raise CliBadArgument,'sources must be a Array of String' if !file_list.reject{|f|f.is_a?(String)}.empty?
         else
           raise CliBadArgument,"sources must be a Array, not #{file_list.class}"
         end
         # here, file_list is an Array or String
         if !@transfer_paths.nil?
-          Log.log.warn("--sources overrides paths from --ts")
+          Log.log.warn('--sources overrides paths from --ts')
         end
         case @opt_mgr.get_option(:src_type,:mandatory)
         when :list
@@ -150,7 +151,7 @@ END_OF_TEMPLATE
         when :pair
           raise CliBadArgument,"When using pair, provide an even number of paths: #{file_list.length}" unless file_list.length.even?
           @transfer_paths=file_list.each_slice(2).to_a.map{|s,d|{'source'=>s,'destination'=>d}}
-        else raise "Unsupported src_type"
+        else raise 'Unsupported src_type'
         end
         Log.log.debug("paths=#{@transfer_paths}")
         return @transfer_paths
@@ -163,14 +164,14 @@ END_OF_TEMPLATE
       # other options are carried to specific agent
       def start(transfer_spec,tr_opts)
         # check parameters
-        raise "transfer_spec must be hash" unless transfer_spec.is_a?(Hash)
-        raise "tr_opts must be hash" unless tr_opts.is_a?(Hash)
+        raise 'transfer_spec must be hash' unless transfer_spec.is_a?(Hash)
+        raise 'tr_opts must be hash' unless tr_opts.is_a?(Hash)
         # process :src option
         case transfer_spec['direction']
-        when 'receive'
+        when Fasp::TransferSpec::DIRECTION_RECEIVE
           # init default if required in any case
           @transfer_spec_cmdline['destination_root']||=destination_folder(transfer_spec['direction'])
-        when 'send'
+        when Fasp::TransferSpec::DIRECTION_SEND
           case tr_opts[:src]
           when :direct
             # init default if required
@@ -194,9 +195,10 @@ END_OF_TEMPLATE
 
         transfer_spec.merge!(@transfer_spec_cmdline)
         # create transfer agent
-        self.set_agent_by_options
+        set_agent_by_options
         Log.log.debug("transfer agent is a #{@agent.class}")
         @agent.start_transfer(transfer_spec,tr_opts)
+        # list of : :success or error message
         result=@agent.wait_for_transfers_completion
         @progress_listener.reset
         Fasp::AgentBase.validate_status_list(result)
@@ -219,7 +221,7 @@ END_OF_TEMPLATE
       # @return :success if all sessions statuses returned by "start" are success
       # else return the first error exception object
       def self.session_status(statuses)
-        error_statuses=statuses.select{|i|!i.eql?(:success)}
+        error_statuses=statuses.reject{|i|i.eql?(:success)}
         return :success if error_statuses.empty?
         return error_statuses.first
       end
@@ -228,7 +230,6 @@ END_OF_TEMPLATE
       def shutdown
         @agent.shutdown if @agent.respond_to?(:shutdown)
       end
-
     end
   end
 end

data/lib/aspera/cli/version.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module Aspera
   module Cli
-    VERSION = "4.6.0"
+    VERSION = '4.7.0'
   end
 end

data/lib/aspera/colors.rb

@@ -1,43 +1,51 @@
+# frozen_string_literal: true
 # simple vt100 colors
 class String
-  private
-  def self.vtcmd(code);"\e[#{code}m";end
+  class<<self
+    private
+
+    def vtcmd(code);"\e[#{code}m";end
+  end
   # see https://en.wikipedia.org/wiki/ANSI_escape_code
   # symbol is the method name added to String
   # it adds control chars to set color (and reset at the end).
   VTSTYLES = {
-    :bold=>1,
-    :italic=>3,
-    :underline=>4,
-    :blink=>5,
-    :reverse_color=>7,
-    :black=>30,
-    :red=>31,
-    :green=>32,
-    :brown=>33,
-    :blue=>34,
-    :magenta=>35,
-    :cyan=>36,
-    :gray=>37,
-    :bg_black=>40,
-    :bg_red=>41,
-    :bg_green=>42,
-    :bg_brown=>43,
-    :bg_blue=>44,
-    :bg_magenta=>45,
-    :bg_cyan=>46,
-    :bg_gray=>47,
+    bold: 1,
+    italic: 3,
+    underline: 4,
+    blink: 5,
+    reverse_color: 7,
+    black: 30,
+    red: 31,
+    green: 32,
+    brown: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    gray: 37,
+    bg_black: 40,
+    bg_red: 41,
+    bg_green: 42,
+    bg_brown: 43,
+    bg_blue: 44,
+    bg_magenta: 45,
+    bg_cyan: 46,
+    bg_gray: 47
   }
   private_constant :VTSTYLES
   # defines methods to String, one per entry in VTSTYLES
   VTSTYLES.each do |name,code|
-    begin_seq=vtcmd(code)
-    end_seq=vtcmd((code >= 10) ? 0 : code+20+(code.eql?(1)?1:0))
-    if STDERR.tty?
+    if $stderr.tty?
+      begin_seq=vtcmd(code)
+      end_code=
+      if code >= 10 then 0
+      elsif code.eql?(1) then 22
+      else code+20
+      end
+      end_seq=vtcmd(end_code)
       define_method(name){"#{begin_seq}#{self}#{end_seq}"}
     else
       define_method(name){self}
     end
-    public name
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 module Aspera
   # helper class to build command line from a parameter list (key-value hash)
   # constructor takes hash: { 'param1':'value1', ...}
   # process_param is called repeatedly with all known parameters
   # add_env_args is called to get resulting param list and env var (also checks that all params were used)
   class CommandLineBuilder
-    # transform yes/no to trye/false
+    # transform yes/no to true/false
     def self.yes_to_true(value)
       case value
-      when 'yes'; return true
-      when 'no'; return false
+      when 'yes' then return true
+      when 'no' then return false
       end
       raise "unsupported value: #{value}"
     end
@@ -22,13 +23,13 @@ module Aspera
         options[:mandatory]||=false
         options[:desc]||=''
         # by default : string, unless it's without arg
-        if ! options.has_key?(:accepted_types)
+        if !options.has_key?(:accepted_types)
           options[:accepted_types]=options[:cltype].eql?(:opt_without_arg) ? :bool : :string
         end
         # single type is placed in array
         options[:accepted_types]=[options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
-        if !options.has_key?(:option_switch) and options.has_key?(:cltype) and [:opt_without_arg,:opt_with_arg].include?(options[:cltype])
-          options[:option_switch]='--'+param_name.to_s.gsub('_','-')
+        if !options.has_key?(:clswitch) && options.has_key?(:cltype) && [:opt_without_arg,:opt_with_arg].include?(options[:cltype])
+          options[:clswitch]='--'+param_name.to_s.gsub('_','-')
         end
       end
     end
@@ -36,7 +37,7 @@ module Aspera
     private
 
     # clvarname : command line variable name
-    def env_name(param_name,options)
+    def env_name(_param_name,options)
       return options[:clvarname]
     end
 
@@ -46,7 +47,7 @@ module Aspera
 
     # @param param_hash
     def initialize(param_hash,params_definition)
-      @param_hash=param_hash  # keep reference so that it can be modified by caller before calling `process_params`
+      @param_hash=param_hash # keep reference so that it can be modified by caller before calling `process_params`
       @params_definition=params_definition
       @result_env={}
       @result_args=[]
@@ -86,42 +87,53 @@ module Aspera
     # @param options : options for type
     def process_param(param_name,action=nil)
       options=@params_definition[param_name]
-      action=options[:cltype] if action.nil?
       # should not happen
-      raise "Internal error: ask processing of param #{param_name}" if options.nil?
+      if options.nil?
+        Log.log.warn("Unknown parameter #{param_name}")
+        return
+      end
+      action=options[:cltype] if action.nil?
       # check mandatory parameter (nil is valid value)
-      raise Fasp::Error.new("mandatory parameter: #{param_name}") if options[:mandatory] and !@param_hash.has_key?(param_name)
+      raise Fasp::Error, "Missing mandatory parameter: #{param_name}" if options[:mandatory] && !@param_hash.has_key?(param_name)
       parameter_value=@param_hash[param_name]
+
       #parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
+
+      # Check parameter type
       expected_classes=options[:accepted_types].map do |s|
         case s
-        when :string; String
-        when :array; Array
-        when :hash; Hash
-        when :int; Integer
-        when :bool; [TrueClass,FalseClass]
+        when :string then String
+        when :array then Array
+        when :hash then Hash
+        when :int then Integer
+        when :bool then [TrueClass,FalseClass]
         else raise "INTERNAL: unexpected value: #{s}"
         end
       end.flatten
-      # check provided type
-      raise Fasp::Error.new("#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, ") unless parameter_value.nil? or expected_classes.include?(parameter_value.class)
+      raise Fasp::Error,"#{param_name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, " unless parameter_value.nil? || expected_classes.include?(parameter_value.class)
       @used_param_names.push(param_name) unless action.eql?(:defer)
 
       # process only non-nil values
       return nil if parameter_value.nil?
 
-      if options.has_key?(:translate_values)
+      # check that value is of an accepted type (string, int bool)
+      raise "Value #{parameter_value} is not allowed for #{param_name}" if options.has_key?(:enum) && !options[:enum].include?(parameter_value)
+
+      # convert some values if value on command line needs processing from value in structure
+      case options[:clconvert]
+      when Hash
         # translate using conversion table
-        new_value=options[:translate_values][parameter_value]
-        raise "unsupported value: #{parameter_value}" if new_value.nil?
+        new_value=options[:clconvert][parameter_value]
+        raise "unsupported value: #{parameter_value}, expect: #{options[:clconvert].keys.join(', ')}" if new_value.nil?
         parameter_value=new_value
-      end
-      raise "unsupported value: #{parameter_value}" unless options[:accepted_values].nil? or options[:accepted_values].include?(parameter_value)
-      if options[:encode]
-        # :encode has name of class with encoding method
-        newvalue=Kernel.const_get(options[:encode]).send("encode_#{param_name}",parameter_value)
-        raise Fasp::Error.new("unsupported #{param_name}: #{parameter_value}") if newvalue.nil?
+      when String
+        # :clconvert has name of class and encoding method
+        convclass,convmethod=options[:clconvert].split('.')
+        newvalue=Kernel.const_get(convclass).send(convmethod,parameter_value)
+        raise Fasp::Error, "unsupported #{param_name}: #{parameter_value}" if newvalue.nil?
         parameter_value=newvalue
+      when NilClass
+      else raise "not expected type for clconvert #{options[:clconvert].class} for #{param_name}"
       end
 
       case action
@@ -135,19 +147,21 @@ module Aspera
       when :opt_without_arg # if present and true : just add option without value
         add_param=false
         case parameter_value
-        when false# nothing to put on command line, no creation by default
-        when true; add_param=true
-        else raise Fasp::Error.new("unsupported #{param_name}: #{parameter_value}")
+        when false then nil # nothing to put on command line, no creation by default
+        when true then add_param=true
+        else raise Fasp::Error, "unsupported #{param_name}: #{parameter_value}"
         end
-        add_param=!add_param if options[:add_on_false]
-        add_command_line_options([options[:option_switch]]) if add_param
+        add_param= !add_param if options[:add_on_false]
+        add_command_line_options([options[:clswitch]]) if add_param
       when :opt_with_arg # transform into command line option with value
         #parameter_value=parameter_value.to_s if parameter_value.is_a?(Integer)
         parameter_value=[parameter_value] unless parameter_value.is_a?(Array)
         # if transfer_spec value is an array, applies option many times
-        parameter_value.each{|v|add_command_line_options([options[:option_switch],v])}
+        parameter_value.each{|v|add_command_line_options([options[:clswitch],v])}
+      when NilClass
+        Log.log.debug("Ignoring parameter: #{param_name}")
       else
-        raise "Error"
+        raise "ERROR: unknown action: #{action}/#{action.class}"
       end
     end
   end

data/lib/aspera/cos_node.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/log'
 require 'aspera/rest'
 require 'xmlsimple'
@@ -11,25 +12,28 @@ module Aspera
       @auth_url=auth_url
       @api_key=api_key
       s3_api=Aspera::Rest.new({
-        :base_url       => storage_endpoint,
-        :not_auth_codes => ['401','403'], # error codes when not authorized
-        :headers        => {'ibm-service-instance-id' => instance_id},
-        :auth           => {
-        :type      => :oauth2,
-        :base_url  => @auth_url,
-        :grant     => :ibm_apikey,
-        :api_key   => @api_key
-        }})
+        base_url:        storage_endpoint,
+        not_auth_codes:  ['401','403'], # error codes when not authorized
+        headers:         {'ibm-service-instance-id' => instance_id},
+        auth:            {
+        type:              :oauth2,
+        base_url:          @auth_url,
+        crtype:            :generic,
+        generic:            {
+        grant_type:          'urn:ibm:params:oauth:grant-type:apikey',
+        response_type:       'cloud_iam',
+        apikey:              @api_key
+      }}})
       # read FASP connection information for bucket
-      xml_result_text=s3_api.call({:operation=>'GET',:subpath=>bucket_name,:headers=>{'Accept'=>'application/xml'},:url_params=>{'faspConnectionInfo'=>nil}})[:http].body
+      xml_result_text=s3_api.call({operation: 'GET',subpath: bucket_name,headers: {'Accept'=>'application/xml'},url_params: {'faspConnectionInfo'=>nil}})[:http].body
       ats_info=XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
       Aspera::Log.dump('ats_info',ats_info)
       super({
-        :base_url => ats_info['ATSEndpoint'],
-        :auth     => {
-        :type     => :basic,
-        :username => ats_info['AccessKey']['Id'],
-        :password => ats_info['AccessKey']['Secret']}})
+        base_url:  ats_info['ATSEndpoint'],
+        auth:      {
+        type:      :basic,
+        username:  ats_info['AccessKey']['Id'],
+        password:  ats_info['AccessKey']['Secret']}})
       # prepare transfer spec addition
       @add_ts={'tags'=>{'aspera'=>{'node'=>{'storage_credentials'=>{
         'type'  => 'token',
@@ -42,12 +46,16 @@ module Aspera
     def generate_token
       # OAuth API to get delegated token
       delegated_oauth=Oauth.new({
-        :type       => :oauth2,
-        :base_url   => @auth_url,
-        :grant      => :delegated_refresh,
-        :api_key    => @api_key,
-        :token_field=> TOKEN_FIELD
-      })
+        type:        :oauth2,
+        base_url:    @auth_url,
+        token_field: TOKEN_FIELD,
+        crtype:            :generic,
+        generic:            {
+        grant_type:          'urn:ibm:params:oauth:grant-type:apikey',
+        response_type:       'delegated_refresh_token',
+        apikey:              @api_key,
+        receiver_client_ids: 'aspera_ats'
+      }})
       # get delagated token to be placed in rest call header and in transfer tags
       @add_ts['tags']['aspera']['node']['storage_credentials']['token'][TOKEN_FIELD]=delegated_oauth.get_authorization().gsub(/^Bearer /,'')
       @params[:headers]={'X-Aspera-Storage-Credentials'=>JSON.generate(@add_ts['tags']['aspera']['node']['storage_credentials'])}

data/lib/aspera/data_repository.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/log'
 require 'singleton'
 
@@ -6,8 +7,8 @@ module Aspera
   class DataRepository
     include Singleton
     # get binary value from data repository
-    def get_bin(id)
-      File.read(File.join(File.expand_path(File.dirname(__FILE__)),'data',id.to_s),mode: 'rb')
+    def data(id)
+      File.read(File.join(__dir__,'data',id.to_s),mode: 'rb')
     end
   end
 end

data/lib/aspera/environment.rb

@@ -1,66 +1,71 @@
+# frozen_string_literal: true
 require 'aspera/log'
 require 'rbconfig'
 
 module Aspera
-  # detect OS, architecture, and OS specific stuff
+  # detect OS, architecture, and specific stuff
   class Environment
     OS_WINDOWS = :windows
     OS_X = :osx
     OS_LINUX = :linux
     OS_AIX = :aix
-    OS_LIST=[OS_WINDOWS,OS_X,OS_LINUX,OS_AIX]
-
-    def self.os
-      case RbConfig::CONFIG['host_os']
-      when /mswin/,/msys/,/mingw/,/cygwin/,/bccwin/,/wince/,/emc/
-        return OS_WINDOWS
-      when /darwin/,/mac os/
-        return OS_X
-      when /linux/
-        return OS_LINUX
-      when /aix/
-        return OS_AIX
-      else
-        raise "Unknown OS: #{RbConfig::CONFIG['host_os']}"
-      end
-    end
-    CPU_X86_64=:x86_64
+    OS_LIST=[OS_WINDOWS,OS_X,OS_LINUX,OS_AIX].freeze
+    CPU_X86_64=:x86_64 # rubocop:disable Naming/VariableNumber
     CPU_PPC64=:ppc64
     CPU_PPC64LE=:ppc64le
     CPU_S390=:s390
-    CPU_LIST=[CPU_X86_64,CPU_PPC64,CPU_PPC64LE,CPU_S390]
+    CPU_LIST=[CPU_X86_64,CPU_PPC64,CPU_PPC64LE,CPU_S390].freeze
 
-    def self.cpu
-      case RbConfig::CONFIG['host_cpu']
-      when /x86_64/,/x64/
-        return CPU_X86_64
-      when /powerpc/,/ppc64/
-        return CPU_PPC64LE if os.eql?(OS_LINUX)
-        return CPU_PPC64
-      when /s390/
-        return CPU_S390
-      else # other
-        raise "Unknown CPU: #{RbConfig::CONFIG['host_cpu']}"
+    class<<self
+      def ruby_version
+        return RbConfig::CONFIG['RUBY_PROGRAM_VERSION']
       end
-    end
 
-    def self.architecture
-      return "#{os}-#{cpu}"
-    end
-
-    def self.exe_extension
-      return '.exe' if os.eql?(OS_WINDOWS)
-      return ''
-    end
+      def os
+        case RbConfig::CONFIG['host_os']
+        when /mswin/,/msys/,/mingw/,/cygwin/,/bccwin/,/wince/,/emc/
+          return OS_WINDOWS
+        when /darwin/,/mac os/
+          return OS_X
+        when /linux/
+          return OS_LINUX
+        when /aix/
+          return OS_AIX
+        else
+          raise "Unknown OS: #{RbConfig::CONFIG['host_os']}"
+        end
+      end
 
-    # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
-    def self.fix_home
-      if os.eql?(OS_WINDOWS)
-        if ENV.has_key?('USERPROFILE') and Dir.exist?(ENV['USERPROFILE'])
-          ENV['HOME']=ENV['USERPROFILE']
-          Log.log.debug("Windows: set home to USERPROFILE: #{ENV['HOME']}")
+      def cpu
+        case RbConfig::CONFIG['host_cpu']
+        when /x86_64/,/x64/
+          return CPU_X86_64
+        when /powerpc/,/ppc64/
+          return CPU_PPC64LE if os.eql?(OS_LINUX)
+          return CPU_PPC64
+        when /s390/
+          return CPU_S390
+        else # other
+          raise "Unknown CPU: #{RbConfig::CONFIG['host_cpu']}"
         end
       end
+
+      def architecture
+        return "#{os}-#{cpu}"
+      end
+
+      def exe_extension
+        return '.exe' if os.eql?(OS_WINDOWS)
+        return ''
+      end
+
+      # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
+      # so, tell Ruby the right way
+      def fix_home
+        return unless os.eql?(OS_WINDOWS) && ENV.has_key?('USERPROFILE') && Dir.exist?(ENV['USERPROFILE'])
+        ENV['HOME']=ENV['USERPROFILE']
+        Log.log.debug("Windows: set home to USERPROFILE: #{ENV['HOME']}")
+      end
     end
   end
 end