aspera-cli 4.5.0 → 4.8.0

data/lib/aspera/keychain/encrypted_hash.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
+require 'aspera/hash_ext'
 require 'openssl'
 
 module Aspera
   module Keychain
     class SimpleCipher
       def initialize(key)
-        @key=Digest::SHA1.hexdigest(key)[0..23]
+        @key = Digest::SHA1.hexdigest(key+('*'*23))[0..23]
         @cipher = OpenSSL::Cipher.new('DES-EDE3-CBC')
       end
 
@@ -12,7 +15,7 @@ module Aspera
         @cipher.encrypt
         @cipher.key = @key
         s = @cipher.update(value) + @cipher.final
-        s.unpack('H*').first
+        s.unpack1('H*')
       end
 
       def decrypt(value)
@@ -25,93 +28,106 @@ module Aspera
 
     # Manage secrets in a simple Hash
     class EncryptedHash
-      SEPARATOR='%'
+      SEPARATOR = '%'
+      ACCEPTED_KEYS = %i[username url secret description].freeze
       private_constant :SEPARATOR
+      attr_reader :legacy_detected
       def initialize(values)
-        raise "values shall be Hash" unless values.is_a?(Hash)
-        @all_secrets=values
+        raise 'values shall be Hash' unless values.is_a?(Hash)
+        @all_secrets = values
+      end
+
+      def identifier(options)
+        return options[:username] if options[:url].to_s.empty?
+        %i[url username].map{|s|options[s]}.join(SEPARATOR)
       end
 
       def set(options)
-        raise "options shall be Hash" unless options.is_a?(Hash)
-        unsupported=options.keys-[:username,:url,:secret,:description]
+        raise 'options shall be Hash' unless options.is_a?(Hash)
+        unsupported = options.keys - ACCEPTED_KEYS
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        username=options[:username]
-        raise "options shall have username" if username.nil?
-        url=options[:url]
-        raise "options shall have username" if url.nil?
-        secret=options[:secret]
-        raise "options shall have secret" if secret.nil?
-        key=[url,username].join(SEPARATOR)
+        username = options[:username]
+        raise 'options shall have username' if username.nil?
+        url = options[:url]
+        raise 'options shall have username' if url.nil?
+        secret = options[:secret]
+        raise 'options shall have secret' if secret.nil?
+        key = identifier(options)
         raise "secret #{key} already exist, delete first" if @all_secrets.has_key?(key)
-        obj={username: username, url: url, secret: SimpleCipher.new(key).encrypt(secret)}
-        obj[:description]=options[:description] if options.has_key?(:description)
-        @all_secrets[key]=obj
+        obj = {username: username, url: url, secret: SimpleCipher.new(key).encrypt(secret)}
+        obj[:description] = options[:description] if options.has_key?(:description)
+        @all_secrets[key] = obj.stringify_keys
         nil
       end
 
       def list
-        result=[]
-        @all_secrets.each do |k,v|
-          case v
-          when String
-            o={username: k, url: '', description: ''}
-          when Hash
-            o=v.clone
-            o.delete(:secret)
-            o[:description]||=''
-          else raise "error"
-          end
-          o[:description]=v[:description] if v.is_a?(Hash) and v[:description].is_a?(String)
-          result.push(o)
+        result = []
+        legacy_detected=false
+        @all_secrets.each do |name,value|
+          normal = # normalized version
+            case value
+            when String
+              legacy_detected=true
+              {username: name, url: '', secret: value}
+            when Hash then value.symbolize_keys
+            else raise 'error secret must be String (legacy) or Hash (new)'
+            end
+          normal[:description] = '' unless normal.has_key?(:description)
+          extraneous_keys=normal.keys - ACCEPTED_KEYS
+          Log.log.error("wrongs keys in secret hash: #{extraneous_keys.map(&:to_s).join(',')}") unless extraneous_keys.empty?
+          result.push(normal)
         end
+        Log.log.warn('Legacy vault format detected in config file, please refer to documentation to convert to new format.') if legacy_detected
         return result
       end
 
       def delete(options)
-        raise "options shall be Hash" unless options.is_a?(Hash)
-        unsupported=options.keys-[:username,:url]
+        raise 'options shall be Hash' unless options.is_a?(Hash)
+        unsupported = options.keys - %i[username url]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        username=options[:username]
-        raise "options shall have username" if username.nil?
-        url=options[:url]
-        key=nil
+        username = options[:username]
+        raise 'options shall have username' if username.nil?
+        url = options[:url]
+        key = nil
         if !url.nil?
-          extk=[url,username].join(SEPARATOR)
-          key=extk if @all_secrets.has_key?(extk)
+          extk = identifier(options)
+          key = extk if @all_secrets.has_key?(extk)
         end
         # backward compatibility: TODO: remove in future ? (make url mandatory ?)
-        key=username if key.nil? and @all_secrets.has_key?(username)
-        raise "no such secret" if key.nil?
+        key = username if key.nil? && @all_secrets.has_key?(username)
+        raise 'no such secret' if key.nil?
         @all_secrets.delete(key)
       end
 
       def get(options)
-        raise "options shall be Hash" unless options.is_a?(Hash)
-        unsupported=options.keys-[:username,:url]
+        raise 'options shall be Hash' unless options.is_a?(Hash)
+        unsupported = options.keys - %i[username url]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        username=options[:username]
-        raise "options shall have username" if username.nil?
-        url=options[:url]
-        val=nil
+        username = options[:username]
+        raise 'options shall have username' if username.nil?
+        url = options[:url]
+        info = nil
         if !url.nil?
-          val=@all_secrets[[url,username].join(SEPARATOR)]
+          info = @all_secrets[identifier(options)]
         end
         # backward compatibility: TODO: remove in future ? (make url mandatory ?)
-        if val.nil?
-          val=@all_secrets[username]
+        if info.nil?
+          info = @all_secrets[username]
         end
-        result=options.clone
-        case val
+        result = options.clone
+        case info
         when NilClass
-          raise "no such secret"
+          raise "no such secret: #{options[:url]} #{username}"
         when String
-          result.merge!({secret: val, description: ''})
+          result[:secret] = info
+          result[:description] = ''
         when Hash
-          key=[url,username].join(SEPARATOR)
-          plain=SimpleCipher.new(key).decrypt(val[:secret])
-          result.merge!({secret: plain, description: val[:description]})
-        else raise "error"
+          info=info.symbolize_keys
+          key = identifier(options)
+          plain = SimpleCipher.new(key).decrypt(info[:secret])
+          result[:secret] = plain
+          result[:description] = info[:description]
+        else raise 'error'
         end
         return result
       end

data/lib/aspera/keychain/macos_security.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'security'
 
 # enhance the gem to support other keychains
@@ -5,7 +7,7 @@ module Security
   class Keychain
     class << self
       def by_name(name)
-        keychains_from_output(`security list-keychains`).select{|kc|kc.filename.end_with?("/#{name}.keychain-db")}.first
+        keychains_from_output('security list-keychains').find{|kc|kc.filename.end_with?("/#{name}.keychain-db")}
       end
     end
   end
@@ -15,18 +17,18 @@ module Security
       # add some login to original method
       alias_method :orig_flags_for_options, :flags_for_options
       def flags_for_options(options = {})
-        keychain=options.delete(:keychain)
-        url=options.delete(:url)
+        keychain = options.delete(:keychain)
+        url = options.delete(:url)
         if !url.nil?
-          uri=URI.parse(url)
+          uri = URI.parse(url)
           raise 'only https' unless uri.scheme.eql?('https')
-          options[:r]='htps'
+          options[:r] = 'htps'
           raise 'host required in URL' if uri.host.nil?
-          options[:s]=uri.host
-          options[:p]=uri.path unless ['','/'].include?(uri.path)
-          options[:P]=uri.port unless uri.port.eql?(443) and !url.include?(':443/')
+          options[:s] = uri.host
+          options[:p] = uri.path unless ['','/'].include?(uri.path)
+          options[:P] = uri.port unless uri.port.eql?(443) && !url.include?(':443/')
         end
-        flags=[orig_flags_for_options(options)]
+        flags = [orig_flags_for_options(options)]
         flags.push(keychain.filename) unless keychain.nil?
         flags.join(' ')
       end
@@ -39,40 +41,36 @@ module Aspera
     # keychain based on macOS keychain, using `security` cmmand line
     class MacosSecurity
       def initialize(name=nil)
-        if name.nil?
-          @keychain=Security::Keychain.default_keychain
-        else
-          @keychain=Security::Keychain.by_name(name)
-        end
+        @keychain = name.nil? ? Security::Keychain.default_keychain : Security::Keychain.by_name(name)
         raise "no such keychain #{name}" if @keychain.nil?
       end
 
       def set(options)
         raise 'options shall be Hash' unless options.is_a?(Hash)
-        unsupported=options.keys-[:username,:url,:secret,:description]
+        unsupported = options.keys - %i[username url secret description]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        username=options[:username]
+        username = options[:username]
         raise 'options shall have username' if username.nil?
-        url=options[:url]
+        url = options[:url]
         raise 'options shall have url' if url.nil?
-        secret=options[:secret]
+        secret = options[:secret]
         raise 'options shall have secret' if secret.nil?
         raise 'set not implemented'
-        self
       end
 
       def get(options)
         raise 'options shall be Hash' unless options.is_a?(Hash)
-        unsupported=options.keys-[:username,:url]
+        unsupported = options.keys - %i[username url]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        username=options[:username]
+        username = options[:username]
         raise 'options shall have username' if username.nil?
-        url=options[:url]
+        url = options[:url]
         raise 'options shall have url' if url.nil?
-        info=Security::InternetPassword.find(keychain: @keychain, url: url, account: username)
+        info = Security::InternetPassword.find(keychain: @keychain, url: url, account: username)
         raise 'not found' if info.nil?
-        result=options.clone
-        result.merge!({secret: info.password, description: info.attributes['icmt']})
+        result = options.clone
+        result[:secret] = info.password
+        result[:description] = info.attributes['icmt']
         return result
       end
 
@@ -82,12 +80,12 @@ module Aspera
 
       def delete(options)
         raise 'options shall be Hash' unless options.is_a?(Hash)
-        unsupported=options.keys-[:username,:url]
+        unsupported = options.keys - %i[username url]
         raise "unsupported options: #{unsupported}" unless unsupported.empty?
-        username=options[:username]
+        username = options[:username]
         raise 'options shall have username' if username.nil?
-        url=options[:url]
-        raise 'delete not implemented'
+        url = options[:url]
+        raise "delete not implemented #{url}"
       end
     end
   end

data/lib/aspera/log.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'aspera/colors'
+require 'aspera/secret_hider'
 require 'logger'
 require 'pp'
 require 'json'
@@ -11,10 +14,10 @@ module Aspera
     # class methods
     class << self
       # levels are :debug,:info,:warn,:error,fatal,:unknown
-      def levels; Logger::Severity.constants.sort{|a,b|Logger::Severity.const_get(a)<=>Logger::Severity.const_get(b)}.map{|c|c.downcase.to_sym};end
+      def levels; Logger::Severity.constants.sort{|a,b|Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{|c|c.downcase.to_sym};end
 
       # where logs are sent to
-      def logtypes; [:stderr,:stdout,:syslog];end
+      def logtypes; %i[stderr stdout syslog];end
 
       # get the logger object of singleton
       def log; instance.logger;end
@@ -23,28 +26,36 @@ module Aspera
       # @param name string or symbol
       # @param format either pp or json format
       def dump(name,object,format=:json)
-        self.log.debug() do
-          result=case format
-          when :json
-            JSON.pretty_generate(object) rescue PP.pp(object,'')
-          when :ruby
-            PP.pp(object,'')
-          else
-            raise "wrong parameter, expect pp or json"
-          end
+        log.debug do
+          result =
+            case format
+            when :json
+              JSON.pretty_generate(object) rescue PP.pp(object,+'')
+            when :ruby
+              PP.pp(object,+'')
+            else
+              raise 'wrong parameter, expect pp or json'
+            end
           "#{name.to_s.green} (#{format})=\n#{result}"
         end
       end
-    end
 
-    attr_reader :logger_type
-    attr_reader :logger
+      def capture_stderr
+        real_stderr = $stderr
+        $stderr = StringIO.new
+        yield
+        log.debug($stderr.string)
+      ensure
+        $stderr = real_stderr
+      end
+    end # class
+
+    attr_reader :logger_type, :logger
     attr_writer :program_name
-    attr_accessor :log_passwords
 
     # set log level of underlying logger given symbol level
     def level=(new_level)
-      @logger.level=Logger::Severity.const_get(new_level.to_sym.upcase)
+      @logger.level = Logger::Severity.const_get(new_level.to_sym.upcase)
     end
 
     # get symbol of debug level of underlying logger
@@ -53,49 +64,39 @@ module Aspera
         return name.downcase.to_sym if @logger.level.eql?(Logger::Severity.const_get(name))
       end
       # should not happen
-      raise "error"
+      raise "INTERNAL ERROR: unexpected level #{@logger.level}"
     end
 
     # change underlying logger, but keep log level
     def logger_type=(new_logtype)
-      current_severity_integer=@logger.level unless @logger.nil?
-      current_severity_integer=ENV['AS_LOG_LEVEL'] if current_severity_integer.nil? and ENV.has_key?('AS_LOG_LEVEL')
-      current_severity_integer=Logger::Severity::WARN if current_severity_integer.nil?
+      current_severity_integer = @logger.level unless @logger.nil?
+      current_severity_integer = ENV['AS_LOG_LEVEL'] if current_severity_integer.nil? && ENV.has_key?('AS_LOG_LEVEL')
+      current_severity_integer = Logger::Severity::WARN if current_severity_integer.nil?
       case new_logtype
       when :stderr
-        @logger = Logger.new(STDERR)
+        @logger = Logger.new($stderr)
       when :stdout
-        @logger = Logger.new(STDOUT)
+        @logger = Logger.new($stdout)
       when :syslog
         require 'syslog/logger'
         @logger = Syslog::Logger.new(@program_name)
       else
         raise "unknown log type: #{new_logtype.class} #{new_logtype}"
       end
-      @logger.level=current_severity_integer
-      @logger_type=new_logtype
-      original_formatter = @logger.formatter || Logger::Formatter.new
+      @logger.level = current_severity_integer
+      @logger_type = new_logtype
       # update formatter with password hiding
-      @logger.formatter=proc do |severity, datetime, progname, msg|
-        unless @log_passwords
-          msg=msg.gsub(/("[^"]*(password|secret|private_key)[^"]*"=>")([^"]+)(")/){"#{$1}***#{$4}"}
-          msg=msg.gsub(/("[^"]*(secret)[^"]*"=>{)([^}]+)(})/){"#{$1}***#{$4}"}
-          msg=msg.gsub(/((secrets)={)([^}]+)(})/){"#{$1}***#{$4}"}
-        end
-        original_formatter.call(severity, datetime, progname, msg)
-      end
+      @logger.formatter = SecretHider.log_formatter(@logger.formatter)
     end
 
     private
 
     def initialize
-      @logger=nil
-      @program_name='aspera'
-      @log_passwords=false
+      @logger = nil
+      @program_name = 'aspera'
       # this sets @logger and @logger_type (self needed to call method instead of local var)
-      self.logger_type=:stderr
-      raise "error logger shall be defined" if @logger.nil?
+      self.logger_type = :stderr
+      raise 'error logger shall be defined' if @logger.nil?
     end
-
   end
 end

data/lib/aspera/nagios.rb

@@ -1,34 +1,36 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Aspera
   class Nagios
     # nagios levels
-    LEVELS=[:ok,:warning,:critical,:unknown,:dependent]
-    ADD_PREFIX='add_'
+    LEVELS = %i[ok warning critical unknown dependent].freeze
+    ADD_PREFIX = 'add_'
+    # date offset levels
+    DATE_WARN_OFFSET = 2
+    DATE_CRIT_OFFSET = 5
+    private_constant :LEVELS,:ADD_PREFIX,:DATE_WARN_OFFSET,:DATE_CRIT_OFFSET
+
     # add methods to add nagios error levels, each take component name and message
     LEVELS.each_index do |code|
-      name="#{ADD_PREFIX}#{LEVELS[code]}".to_sym
-      define_method(name){|comp,msg|@data.push({:code=>code,:comp=>comp,:msg=>msg})}
-      public name
+      name = "#{ADD_PREFIX}#{LEVELS[code]}".to_sym
+      define_method(name){|comp,msg|@data.push({code: code,comp: comp,msg: msg})}
     end
-    # date offset levels
-    DATE_WARN_OFFSET=2
-    DATE_CRIT_OFFSET=5
-    private_constant :LEVELS,:ADD_PREFIX,:DATE_WARN_OFFSET,:DATE_CRIT_OFFSET
 
     attr_reader :data
     def initialize
-      @data=[]
+      @data = []
     end
 
     # comparte remote time with local time
-    def check_time_offset( remote_date, component )
+    def check_time_offset(remote_date, component)
       # check date if specified : 2015-10-13T07:32:01Z
       rtime = DateTime.strptime(remote_date)
       diff_time = (rtime - DateTime.now).abs
-      diff_disp=diff_time.round(-2)
+      diff_disp = diff_time.round(-2)
       Log.log.debug("DATE: #{remote_date} #{rtime} diff=#{diff_disp}")
-      msg="offset #{diff_disp} sec"
+      msg = "offset #{diff_disp} sec"
       if diff_time >= DATE_CRIT_OFFSET
         add_critical(component,msg)
       elsif diff_time >= DATE_WARN_OFFSET
@@ -38,30 +40,30 @@ module Aspera
       end
     end
 
-    def check_product_version( component, product, version )
+    def check_product_version(component, _product, version)
       add_ok(component,"version #{version}")
       # TODO check on database if latest version
     end
 
     # translate for display
     def result
-      raise "missing result" if @data.empty?
-      {:type=>:object_list,:data=>@data.map{|i|{'status'=>LEVELS[i[:code]].to_s,'component'=>i[:comp],'message'=>i[:msg]}}}
+      raise 'missing result' if @data.empty?
+      {type: :object_list,data: @data.map{|i|{'status' => LEVELS[i[:code]].to_s,'component' => i[:comp],'message' => i[:msg]}}}
     end
 
     # process results of a analysis and display status and exit with code
     def self.process(data)
-      raise "INTERNAL ERROR, result must be list and not empty" unless data.is_a?(Array) and !data.empty?
-      ['status','component','message'].each{|c|raise "INTERNAL ERROR, result must have #{c}" unless data.first.has_key?(c)}
-      res_errors = data.select{|s|!s['status'].eql?('ok')}
+      raise 'INTERNAL ERROR, result must be list and not empty' unless data.is_a?(Array) && !data.empty?
+      %w[status component message].each{|c|raise "INTERNAL ERROR, result must have #{c}" unless data.first.has_key?(c)}
+      res_errors = data.reject{|s|s['status'].eql?('ok')}
       # keep only errors in case of problem, other ok are assumed so
       data = res_errors unless res_errors.empty?
       # first is most critical
-      data.sort!{|a,b|LEVELS.index(a['status'].to_sym)<=>LEVELS.index(b['status'].to_sym)}
+      data.sort!{|a,b|LEVELS.index(a['status'].to_sym) <=> LEVELS.index(b['status'].to_sym)}
       # build message: if multiple components: concatenate
       #message = data.map{|i|"#{i['component']}:#{i['message']}"}.join(', ').gsub("\n",' ')
-      message = data.map{|i|i['component']}.uniq.map{|comp|comp+':'+data.select{|d|d['component'].eql?(comp)}.map{|d|d['message']}.join(',')}.join(', ').gsub("\n",' ')
-      status=data.first['status'].upcase
+      message = data.map{|i|i['component']}.uniq.map{|comp|comp + ':' + data.select{|d|d['component'].eql?(comp)}.map{|d|d['message']}.join(',')}.join(', ').tr("\n",' ')
+      status = data.first['status'].upcase
       # display status for nagios
       puts("#{status} - [#{message}]\n")
       # provide exit code to nagios

data/lib/aspera/node.rb

@@ -1,7 +1,10 @@
-require 'aspera/fasp/default'
+# frozen_string_literal: true
+
+require 'aspera/fasp/transfer_spec'
 require 'aspera/rest'
 require 'aspera/oauth'
 require 'aspera/log'
+require 'aspera/environment'
 require 'zlib'
 require 'base64'
 
@@ -9,32 +12,36 @@ module Aspera
   # Provides additional functions using node API.
   class Node < Rest
     # permissions
-    ACCESS_LEVELS=['delete','list','mkdir','preview','read','rename','write']
-    MATCH_EXEC_PREFIX='exec:'
+    ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
+    # prefix for ruby code for filter
+    MATCH_EXEC_PREFIX = 'exec:'
 
     # register node special token decoder
     Oauth.register_decoder(lambda{|token|JSON.parse(Zlib::Inflate.inflate(Base64.decode64(token)).partition('==SIGNATURE==').first)})
 
-    def self.set_ak_basic_token(ts,ak,secret)
-      raise "ERROR: expected xfer" unless ts['remote_user'].eql?(Fasp::Default::ACCESS_KEY_TRANSFER_USER)
-      ts['token']="Basic #{Base64.strict_encode64("#{ak}:#{secret}")}"
-    end
+    class << self
+      def set_ak_basic_token(ts,ak,secret)
+        Log.log.warn("Expected transfer user: #{Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER}, "\
+          "but have #{ts['remote_user']}") unless ts['remote_user'].eql?(Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER)
+        ts['token'] = Rest.basic_creds(ak,secret)
+      end
 
-    # for access keys: provide expression to match entry in folder
-    # if no prefix: regex
-    # if prefix: ruby code
-    # if filder is nil, then always match
-    def self.file_matcher(match_expression)
-      match_expression||="#{MATCH_EXEC_PREFIX}true"
-      if match_expression.start_with?(MATCH_EXEC_PREFIX)
-        return eval("lambda{|f|#{match_expression[MATCH_EXEC_PREFIX.length..-1]}}")
+      # for access keys: provide expression to match entry in folder
+      # if no prefix: regex
+      # if prefix: ruby code
+      # if filder is nil, then always match
+      def file_matcher(match_expression)
+        match_expression ||= "#{MATCH_EXEC_PREFIX}true"
+        if match_expression.start_with?(MATCH_EXEC_PREFIX)
+          return Environment.secure_eval("lambda{|f|#{match_expression[MATCH_EXEC_PREFIX.length..-1]}}")
+        end
+        return lambda{|f|f['name'].match(/#{match_expression}/)}
       end
-      return lambda{|f|f['name'].match(/#{match_expression}/)}
     end
 
-    def initialize(rest_params)
-      super(rest_params)
-    end
+    #    def initialize(rest_params)
+    #      super(rest_params)
+    #    end
 
     # recursively crawl in a folder.
     # subfolders a processed if the processing method returns true
@@ -52,25 +59,26 @@ module Aspera
       raise "processor must have #{opt[:method]}" unless processor.respond_to?(opt[:method])
       Log.log.debug("crawl #{opt}")
       #top_info=read("files/#{opt[:top_file_id]}")[:data]
-      folders_to_explore=[{id: opt[:top_file_id], relpath: opt[:top_file_path]}]
+      folders_to_explore = [{id: opt[:top_file_id], relpath: opt[:top_file_path]}]
       Log.dump(:folders_to_explore,folders_to_explore)
-      while !folders_to_explore.empty? do
+      while !folders_to_explore.empty?
         current_item = folders_to_explore.shift
         Log.log.debug("searching #{current_item[:relpath]}".bg_green)
         # get folder content
-        folder_contents = begin
-          read("files/#{current_item[:id]}/files")[:data]
-        rescue => e
-          Log.log.warn("#{current_item[:relpath]}: #{e.class} #{e.message}")
-          []
-        end
+        folder_contents =
+          begin
+            read("files/#{current_item[:id]}/files")[:data]
+          rescue StandardError => e
+            Log.log.warn("#{current_item[:relpath]}: #{e.class} #{e.message}")
+            []
+          end
         Log.dump(:folder_contents,folder_contents)
         folder_contents.each do |entry|
-          relative_path=File.join(current_item[:relpath],entry['name'])
+          relative_path = File.join(current_item[:relpath],entry['name'])
           Log.log.debug("looking #{relative_path}".bg_green)
           # entry type is file, folder or link
-          if processor.send(opt[:method],entry,relative_path) and entry['type'].eql?('folder')
-            folders_to_explore.push({:id=>entry['id'],:relpath=>relative_path})
+          if processor.send(opt[:method],entry,relative_path) && entry['type'].eql?('folder')
+            folders_to_explore.push({id: entry['id'],relpath: relative_path})
           end
         end
       end