refactor: 🎨 refactoring

Author: tristanrobert

fog-proxmox.gemspec

@@ -40,6 +40,7 @@ Gem::Specification.new do |spec|
   spec.rubygems_version = '~> 2.6'
 
   spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'bundler-audit', '~> 0.6'
   spec.add_development_dependency 'debase', '~> 0.2.2'
   spec.add_development_dependency 'debride', '~> 1.8'
   spec.add_development_dependency 'fasterer', '~> 0.3'
@@ -55,7 +56,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov', '0.17'
   spec.add_development_dependency 'vcr', '~> 4.0'
   spec.add_development_dependency 'webmock', '~> 3.5'
-  spec.add_development_dependency 'bundler-audit', '~> 0.6'
 
   spec.add_dependency 'fog-core',  '~> 2.1'
   spec.add_dependency 'fog-json',  '~> 1.2'

lib/fog/proxmox/compute/models/server.rb

@@ -228,7 +228,7 @@ def list(content)
           volumes
         end
 
-        protected 
+        protected
 
         def initialize_config(new_attributes = {})
           options = { service: service, vmid: vmid }
@@ -247,7 +247,7 @@ def initialize_tasks
 
         def node
           Fog::Proxmox::Compute::Node.new(service: service, node: node_id)
-        end 
+        end
       end
     end
   end

lib/fog/proxmox/hash.rb

@@ -23,13 +23,13 @@ module Proxmox
     module Hash
 
       def self.stringify(hash)
-        filtered = hash.reject { |_key,value| value.to_s.empty? }
+        filtered = hash.reject { |_key, value| value.nil? }
         a = filtered.to_a.collect { |item| item.join('=') }
         a.join(',')
       end
 
       def self.flatten(hash)
-        filtered = hash.reject { |_key,value| value.to_s.empty? }
+        filtered = hash.reject { |_key, value| value.nil? }
         a = filtered.to_a.collect { |item| item.join(': ') }
         a.join(',')
       end

lib/fog/proxmox/helpers/disk_helper.rb

@@ -44,12 +44,12 @@ def self.flatten(disk)
           value += 'none'
         end
         opts = disk[:options] if disk[:options]
-        main_a = [:id,:volid,:storage,:size]
-        opts = disk.reject { |key,_value| main_a.include? key } unless opts
+        main_a = [:id, :volid, :storage, :size]
+        opts ||= disk.reject { |key, _value| main_a.include? key }
         options = ''
         options += Fog::Proxmox::Hash.stringify(opts) if opts
-        if id == 'ide2' && !self.cdrom?(options)
-          options += ',' if !options.empty?
+        if id == 'ide2' && !cdrom?(options)
+          options += ',' unless options.empty?
           options += 'media=cdrom'
         end
         value += ',' if !options.empty? && !value.empty?
@@ -69,27 +69,26 @@ def self.extract(id)
         id.scan(/(\w+)(\d+)/).first
       end
 
-      # Convert API Proxmox parameter string into attribute hash value 
+      # Convert API Proxmox parameter string into attribute hash value
       def self.extract_option(name, disk_value)
         values = disk_value.scan(/#{name}=(\w+)/)
         name_value = values.first if values
         name_value&.first
       end
 
-      # Convert API Proxmox volume/disk parameter string into volume/disk attributes hash value 
+      # Convert API Proxmox volume/disk parameter string into volume/disk attributes hash value
       def self.extract_storage_volid_size(disk_value)
-        #volid definition: <VOLUME_ID>:=<STORAGE_ID>:<storage type dependent volume name>
+        # volid definition: <VOLUME_ID>:=<STORAGE_ID>:<storage type dependent volume name>
         values_a = disk_value.scan(/^(([\w-]+)[:]{0,1}([\w\/\.-]+))/)
         no_cdrom = !disk_value.match(CDROM_REGEXP)
         creation = disk_value.split(',')[0].match(/^(([\w-]+)[:]{1}([\d]+))$/)
         values = values_a.first if values_a
         if no_cdrom
+          storage = values[1]
           if creation
-            storage = values[1]
             volid = nil
             size = values[2].to_i
           else
-            storage = values[1]
             volid = values[0]
             size = extract_size(disk_value)
           end
@@ -102,37 +101,37 @@ def self.extract_storage_volid_size(disk_value)
       end
 
       def self.to_bytes(size)
-        val=size.match(/\d+(\w?)/)
-        m=0
-        case val[1] 
-          when "K" then m=1
-          when "M" then m=2
-          when "G" then m=3
-          when "T" then m=4
-          when "P" then m=5
+        val = size.match(/\d+(\w?)/)
+        m = 0
+        case val[1]
+          when "K" then m = 1
+          when "M" then m = 2
+          when "G" then m = 3
+          when "T" then m = 4
+          when "P" then m = 5
         end
-        val[0].to_i*1024**m
+        val[0].to_i * 1024**m
       end
 
       def self.modulo_bytes(size)
         size / 1024
       end
 
       def self.to_human_bytes(size)
-        units = ['Kb','Mb','Gb','Tb','Pb']
+        units = ['Kb', 'Mb', 'Gb', 'Tb', 'Pb']
         i = 0
         human_size = size.to_s + 'b'
         while i < 5 && size >= 1024
-          size = self.modulo_bytes(size)
+          size = modulo_bytes(size)
           human_size = size.to_s + units[i]
-          i+=1            
+          i += 1
         end
         human_size
       end
 
       def self.extract_size(disk_value)
-        size=extract_option('size', disk_value)
-	      size ? self.to_bytes(size) : "1G"
+        size = extract_option('size', disk_value)
+        size ? to_bytes(size) : "1G"
       end
 
       def self.disk?(id)

lib/fog/proxmox/helpers/nic_helper.rb

@@ -23,7 +23,6 @@ module Fog
   module Proxmox
     # module NicHelper mixins
     module NicHelper
-
       NICS_REGEXP = /^(net)(\d+)/
 
       def self.extract_mac_address(nic_value)
@@ -47,24 +46,24 @@ def self.nic_update_regexp
       end
 
       def self.has_model?(nic_value)
-        nic_value.match?(self.model_regexp)
+        nic_value.match?(model_regexp)
       end
 
       def self.has_name?(nic_value)
-        nic_value.match?(self.name_regexp)
+        nic_value.match?(name_regexp)
       end
 
       def self.has_ip?(nic_value)
-        nic_value.match?(self.ip_regexp)
+        nic_value.match?(ip_regexp)
       end
 
       def self.extract_nic_id(nic_value)
-        if self.has_model?(nic_value)
-          nic_value.scan(self.model_regexp).first.first
-        elsif self.has_name?(nic_value)
-          nic_value.scan(self.name_regexp).first.first
+        if has_model?(nic_value)
+          nic_value.scan(model_regexp).first.first
+        elsif has_name?(nic_value)
+          nic_value.scan(name_regexp).first.first
         else
-          nic_value.scan(self.nic_update_regexp).first.first
+          nic_value.scan(nic_update_regexp).first.first
         end
       end
 
@@ -88,7 +87,7 @@ def self.set_mac(nic_id, nic_hash)
         mac_keys = [:macaddr, :hwaddr]
         nic_value = ''
         if (nic_hash.keys & mac_keys).empty?
-          nic_value = self.nic_name(nic_hash) + "=" + nic_id
+          nic_value = nic_name(nic_hash) + "=" + nic_id
         else
           mac_value = nic_hash[mac_keys[0]] if nic_hash.key?(mac_keys[0])
           mac_value ||= nic_hash[mac_keys[1]] if nic_hash.key?(mac_keys[1])
@@ -97,26 +96,25 @@ def self.set_mac(nic_id, nic_hash)
         nic_value
       end
 
-      # Convert nic attributes hash into API Proxmox parameters string 
+      # Convert nic attributes hash into API Proxmox parameters string
       def self.flatten(nic_hash)
-        nic_id = nic_hash[self.nic_name(nic_hash).to_sym]
-        nic_value = self.set_mac(nic_id, nic_hash)
-        options = nic_hash.reject { |key, _value| [self.nic_name(nic_hash).to_sym,:id,:macaddr,:hwaddr].include? key.to_sym }
-        nic_value += ',' unless options.empty?
-        nic_value += Fog::Proxmox::Hash.stringify(options) unless options.empty?
+        nic_id = nic_hash[nic_name(nic_hash).to_sym]
+        nic_value = set_mac(nic_id, nic_hash)
+        options = nic_hash.reject { |key, _value| [nic_name(nic_hash).to_sym, :id, :macaddr, :hwaddr].include? key.to_sym }
+        nic_value += ',' + Fog::Proxmox::Hash.stringify(options) unless options.empty?
         { "#{nic_hash[:id]}": nic_value }
       end
 
-      def self.collect_nics(attributes)        
+      def self.collect_nics(attributes)
         attributes.select { |key| nic?(key.to_s) }
       end
-    
+
       def self.nic?(id)
         NICS_REGEXP.match(id) ? true : false
       end
 
       def self.extract_ip(nic_value)
-        if ip = self.ip_regexp.match(nic_value)
+        ip_regexp.match(nic_value) do |ip|
           ip[2]
         end
       end