(CAT-376) Clean up code

- Small improvement to how rule is passed

Author: david22swan

lib/puppet/provider/firewall/firewall.rb

@@ -489,12 +489,12 @@ def self.get_rules(context, basic, protocols = ['IPv4', 'IPv6'])
         table_name = table[0].scan($table_name_regex)[0][0]
         table[0].scan($rules_regex).each do |rule|
           raw_rules = if basic
-                        Puppet::Provider::Firewall::Firewall.rule_to_name(context, rule, table_name, protocol)
+                        Puppet::Provider::Firewall::Firewall.rule_to_name(context, rule[0], table_name, protocol)
                       else
-                        Puppet::Provider::Firewall::Firewall.rule_to_hash(context, rule, table_name, protocol)
+                        Puppet::Provider::Firewall::Firewall.rule_to_hash(context, rule[0], table_name, protocol)
                       end
           # Process the returned values so that it is correct for our purposes
-          rules << Puppet::Provider::Firewall::Firewall.process_get(context, raw_rules, rule, counter)
+          rules << Puppet::Provider::Firewall::Firewall.process_get(context, raw_rules, rule[0], counter)
           counter += 1
         end
       end
@@ -512,12 +512,12 @@ def self.rule_to_name(_context, rule, table_name, protocol)
     rule_hash[:protocol] = protocol
 
     name_regex = Regexp.new("#{$resource_map[:name]}\\s(?:\"([^\"]*)|([^\"\\s]*))")
-    name_value = rule[0].scan(name_regex)[0]
+    name_value = rule.scan(name_regex)[0]
     # Combine the returned values and remove and trailing or leading whitespace
     rule_hash[:name] = [name_value[0], name_value[1]].join(' ').strip if name_value
 
     chain_regex = Regexp.new("#{$resource_map[:chain]}\\s(\\S+)")
-    rule_hash[:chain] = rule[0].scan(chain_regex)[0][0]
+    rule_hash[:chain] = rule.scan(chain_regex)[0][0]
 
     rule_hash
   end
@@ -530,12 +530,12 @@ def self.rule_to_hash(_context, rule, table_name, protocol)
     rule_hash[:ensure] = 'present'
     rule_hash[:table] = table_name
     rule_hash[:protocol] = protocol
-    rule_hash[:line] = rule[0]
+    rule_hash[:line] = rule
     # Add the ensure parameter first
     $resource_map.each do |key, value|
       if $known_booleans.include?(key)
         # check for flag with regex, add a space/line end to ensure accuracy with the more simplistic flags; i.e. `-f`, `--random`
-        rule_hash[key] = if rule[0].match(Regexp.new("#{value}(\\s|$)"))
+        rule_hash[key] = if rule.match(Regexp.new("#{value}(\\s|$)"))
                            true
                          else
                            false
@@ -548,57 +548,57 @@ def self.rule_to_hash(_context, rule, table_name, protocol)
         # When :name/:string/:string_hex/:bytecode, return everything inside the double quote pair following the key value
         # When only a single word comment is returned no quotes are given, so we must check for this as well
         # First find if flag is present, add a space to ensure accuracy with the more simplistic flags; i.e. `-i`
-        if rule[0].match(Regexp.new("#{value}\\s"))
+        if rule.match(Regexp.new("#{value}\\s"))
           value_regex = Regexp.new("(?:(!\\s))?#{value}\\s(?:\"([^\"]*)|([^\"\\s]*))")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           # Combine the returned values and remove and trailing or leading whitespace
           key_value[1] = [key_value[0], key_value[1], key_value[2]].join('')
           rule_hash[key] = key_value[1] if key_value[1]
         end
       when :sport, :dport
         split_value_regex = value[0].split(%r{ })
         negated_multi_regex = [split_value_regex[0], split_value_regex[1], '!', split_value_regex[2]].join(' ')
-        if rule[0].match(value[0])
+        if rule.match(value[0])
           # First check against the multiport value, if found split and return as an array
           value_regex = Regexp.new("#{value[0]}\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           rule_hash[key] = key_value[0].split(%r{,})
-        elsif rule[0].match(negated_multi_regex)
+        elsif rule.match(negated_multi_regex)
           # Next check against a negated multiport value, if found split and return as an array with the first value negated
           value_regex = Regexp.new("#{negated_multi_regex}\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
 
           # Add '!' to the beginning of the first value to show it as negated
           split_value = key_value[0].split(%r{,})
           split_value[0] = "! #{split_value[0]}"
           rule_hash[key] = split_value
-        elsif rule[0].match(value[1])
+        elsif rule.match(value[1])
           # If no multi value matches, check against the regular value instead
           value_regex = Regexp.new("(?:(!)\\s)?#{value[1]}\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           # If it is negated, combine the retrieved '!' with the actual value to make one string
           key_value[1] = [key_value[0], key_value[1]].join(' ') unless key_value[0].nil?
           rule_hash[key] = key_value[1]
         end
       when :tcp_flags
         # First find if flag is present, add a space to ensure accuracy with the more simplistic flags; i.e. `-i`
-        if rule[0].match(Regexp.new("#{value}\\s"))
+        if rule.match(Regexp.new("#{value}\\s"))
           value_regex = Regexp.new("(?:(!)\\s)?#{value}\\s(\\S+)\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           # If a negation is found combine it with the first retrieved value, then combine both values
           key_value[1] = [key_value[0], key_value[1]].join(' ') unless key_value[0].nil?
           rule_hash[key] = [key_value[1], key_value[2]].join(' ')
         end
       when :src_type, :dst_type, :ipset, :match_mark, :mss, :connmark
         split_regex = value.split(%r{ })
-        if rule[0].match(Regexp.new("#{split_regex[1]}\\s(?:(!)\\s)?#{split_regex[2]}\\s"))
+        if rule.match(Regexp.new("#{split_regex[1]}\\s(?:(!)\\s)?#{split_regex[2]}\\s"))
           # The exact information retrieved changes dependeing on the key
           value_regex = Regexp.new("#{split_regex[1]}\\s(?:(!)\\s)?#{split_regex[2]}\\s(\\S+)\\s?(--limit-iface-(?:in|out))?") if [:src_type, :dst_type].include?(key)
           value_regex = Regexp.new("#{split_regex[1]}\\s(?:(!)\\s)?#{split_regex[2]}\\s(\\S+\\s\\S+)") if [:ipset].include?(key)
           value_regex = Regexp.new("#{split_regex[1]}\\s(?:(!)\\s)?#{split_regex[2]}\\s(\\S+)") if [:match_mark, :mss, :connmark].include?(key)
           # Since multiple values can be recovered, we must loop through each instance
           type_value = []
-          key_value = rule[0].scan(value_regex)
+          key_value = rule.scan(value_regex)
           key_value.length.times do |i|
             type_value.append(key_value[i].join(' ').strip) if key_value[i]
           end
@@ -607,9 +607,9 @@ def self.rule_to_hash(_context, rule, table_name, protocol)
           rule_hash[key] = type_value if type_value.length > 1
         end
       when :state, :ctstate, :ctstatus, :month_days, :week_days
-        if rule[0].match(Regexp.new("#{value}\\s"))
+        if rule.match(Regexp.new("#{value}\\s"))
           value_regex = Regexp.new("(?:(!)\\s)?#{value}\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)
+          key_value = rule.scan(value_regex)
           split_value = key_value[0][1].split(%r{,})
           # If negated add to first value
           split_value[0] = [key_value[0][0], split_value[0]].join(' ') unless key_value[0][0].nil?
@@ -628,24 +628,24 @@ def self.rule_to_hash(_context, rule, table_name, protocol)
           proto = 1
         end
 
-        if rule[0].match(Regexp.new("#{value[proto]}\\s"))
+        if rule.match(Regexp.new("#{value[proto]}\\s"))
           value_regex = Regexp.new("#{value[proto]}\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           rule_hash[key] = key_value[0]
         end
       when :recent
-        if rule[0].match(Regexp.new("#{value}\\s"))
+        if rule.match(Regexp.new("#{value}\\s"))
           value_regex = Regexp.new("#{value}\\s(!\\s)?--(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           # If it has, combine the retrieved '!' with the actual value to make one string
           key_value[1] = [key_value[0], key_value[1]].join('') unless key_value[0].nil?
           rule_hash[key] = key_value[1] if key_value
         end
       when :rpfilter
-        if rule[0].match(Regexp.new("#{value}\\s--"))
+        if rule.match(Regexp.new("#{value}\\s--"))
           # Since the values are their own flags we can simply look for them directly
           value_regex = Regexp.new("(?:\s--(invert|validmark|loose|accept-local))")
-          key_value = rule[0].scan(value_regex)
+          key_value = rule.scan(value_regex)
           return_value = []
           key_value.each do |value|
             return_value << value[0]
@@ -658,9 +658,9 @@ def self.rule_to_hash(_context, rule, table_name, protocol)
             :ctorigsrcport, :ctorigdstport, :ctreplsrcport, :ctrepldstport, :ctexpire, :cgroup, :hop_limit
         # Values where negation is prior to the flag
         # First find if flag is present, add a space to ensure accuracy with the more simplistic flags; i.e. `-i`
-        if rule[0].match(Regexp.new("#{value}\\s"))
+        if rule.match(Regexp.new("#{value}\\s"))
           value_regex = Regexp.new("(?:(!)\\s)?#{value}\\s(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           # If it has, combine the retrieved '!' with the actual value to make one string
           key_value[1] = [key_value[0], key_value[1]].join(' ') unless key_value[0].nil?
           rule_hash[key] = key_value[1] if key_value
@@ -676,9 +676,9 @@ def self.rule_to_hash(_context, rule, table_name, protocol)
         # :hashlimit_htable_gcinterval, :zone, :helper, :condition
         # Default return, retrieve first complete block following the key value
         # First find if flag is present, add a space to ensure accuracy with the more simplistic flags; i.e. `-j`, `--to`
-        if rule[0].match(Regexp.new("#{value}\\s"))
+        if rule.match(Regexp.new("#{value}\\s"))
           value_regex = Regexp.new("#{value}(?:\\s(!)\\s|\\s{1,2})(\\S+)")
-          key_value = rule[0].scan(value_regex)[0]
+          key_value = rule.scan(value_regex)[0]
           # If it has, combine the retrieved '!' with the actual value to make one string
           key_value[1] = [key_value[0], key_value[1]].join(' ') unless key_value[0].nil?
           # If value is meant to return as an integer/float ensure it does
@@ -719,7 +719,7 @@ def self.process_get(_context, rule_hash, rule, counter)
     # rule in iptables does not have a matching comment.
     if !rule_hash.key?(:name)
       num = 9000 + counter
-      rule_hash[:name] = "#{num} #{Digest::SHA256.hexdigest(rule[0])}"
+      rule_hash[:name] = "#{num} #{Digest::SHA256.hexdigest(rule)}"
     elsif !rule_hash[:name].match(%r{(^\d+(?:[ \t-]\S+)+$)})
       num = 9000 + counter
       rule_hash[:name] = "#{num} #{rule_hash[:name]}"