facter 4.0.9.pre → 4.0.10.pre

data/lib/facts/macosx/interfaces.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    class Interfaces
+      FACT_NAME = 'interfaces'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Macosx::Ipaddress.resolve(:interfaces)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value, :legacy)
+      end
+    end
+  end
+end

data/lib/facts/macosx/memory/swap/available.rb

@@ -6,12 +6,13 @@ module Facts
       module Swap
         class Available
           FACT_NAME = 'memory.swap.available'
+          ALIASES = 'swapfree'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SwapMemory.resolve(:available_bytes)
             fact_value = Facter::BytesToHumanReadable.convert(fact_value)
 
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/swap/available_bytes.rb

@@ -6,10 +6,12 @@ module Facts
       module Swap
         class AvailableBytes
           FACT_NAME = 'memory.swap.available_bytes'
+          ALIASES = 'swapfree_mb'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SwapMemory.resolve(:available_bytes)
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, fact_value ? (fact_value / (1024.0 * 1024.0)).round(2) : nil, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/swap/encrypted.rb

@@ -6,10 +6,11 @@ module Facts
       module Swap
         class Encrypted
           FACT_NAME = 'memory.swap.encrypted'
+          ALIASES = 'swapencrypted'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SwapMemory.resolve(:encrypted)
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/swap/total.rb

@@ -6,12 +6,13 @@ module Facts
       module Swap
         class Total
           FACT_NAME = 'memory.swap.total'
+          ALIASES = 'swapsize'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SwapMemory.resolve(:total_bytes)
             fact_value = Facter::BytesToHumanReadable.convert(fact_value)
 
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/swap/total_bytes.rb

@@ -6,10 +6,12 @@ module Facts
       module Swap
         class TotalBytes
           FACT_NAME = 'memory.swap.total_bytes'
+          ALIASES = 'swapsize_mb'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SwapMemory.resolve(:total_bytes)
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, fact_value ? (fact_value / (1024.0 * 1024.0)).round(2) : nil, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/system/available.rb

@@ -6,12 +6,13 @@ module Facts
       module System
         class Available
           FACT_NAME = 'memory.system.available'
+          ALIASES = 'memoryfree'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SystemMemory.resolve(:available_bytes)
             fact_value = Facter::BytesToHumanReadable.convert(fact_value)
 
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/system/available_bytes.rb

@@ -6,10 +6,12 @@ module Facts
       module System
         class AvailableBytes
           FACT_NAME = 'memory.system.available_bytes'
+          ALIASES = 'memoryfree_mb'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SystemMemory.resolve(:available_bytes)
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, fact_value ? (fact_value / (1024.0 * 1024.0)).round(2) : nil, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/system/total.rb

@@ -6,12 +6,13 @@ module Facts
       module System
         class Total
           FACT_NAME = 'memory.system.total'
+          ALIASES = 'memorysize'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SystemMemory.resolve(:total_bytes)
             fact_value = Facter::BytesToHumanReadable.convert(fact_value)
 
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/memory/system/total_bytes.rb

@@ -6,10 +6,12 @@ module Facts
       module System
         class TotalBytes
           FACT_NAME = 'memory.system.total_bytes'
+          ALIASES = 'memorysize_mb'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Macosx::SystemMemory.resolve(:total_bytes)
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, fact_value ? (fact_value / (1024.0 * 1024.0)).round(2) : nil, :legacy)]
           end
         end
       end

data/lib/facts/macosx/networking/mac.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    module Networking
+      class Mac
+        FACT_NAME = 'networking.mac'
+        ALIASES = 'macaddress'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Macosx::Ipaddress.resolve(:macaddress)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/macosx/os/hardware.rb

@@ -5,10 +5,11 @@ module Facts
     module Os
       class Hardware
         FACT_NAME = 'os.hardware'
+        ALIASES = 'hardwaremodel'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Uname.resolve(:machine)
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/os/macosx/build.rb

@@ -6,11 +6,11 @@ module Facts
       module Macosx
         class Build
           FACT_NAME = 'os.macosx.build'
+          ALIASES = 'macosx_buildversion'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::SwVers.resolve(:buildversion)
-
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/os/macosx/product.rb

@@ -6,11 +6,11 @@ module Facts
       module Macosx
         class Product
           FACT_NAME = 'os.macosx.product'
+          ALIASES = 'macosx_productname'
 
           def call_the_resolver
             fact_value = Facter::Resolvers::SwVers.resolve(:productname)
-
-            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end
         end
       end

data/lib/facts/macosx/os/macosx/version.rb

@@ -6,13 +6,17 @@ module Facts
       module Macosx
         class Version
           FACT_NAME = 'os.macosx.version'
+          ALIASES = %w[macosx_productversion macosx_productversion_major macosx_productversion_minor].freeze
 
           def call_the_resolver
             fact_value = Facter::Resolvers::SwVers.resolve(:productversion)
             versions = fact_value.split('.')
             ver = { 'full' => fact_value, 'major' => "#{versions[0]}.#{versions[1]}", 'minor' => versions[-1] }
 
-            Facter::ResolvedFact.new(FACT_NAME, ver)
+            [Facter::ResolvedFact.new(FACT_NAME, ver),
+             Facter::ResolvedFact.new(ALIASES[0], fact_value, :legacy),
+             Facter::ResolvedFact.new(ALIASES[1], ver['major'], :legacy),
+             Facter::ResolvedFact.new(ALIASES[2], ver['minor'], :legacy)]
           end
         end
       end

data/lib/facts/macosx/os/release.rb

@@ -5,14 +5,20 @@ module Facts
     module Os
       class Release
         FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Uname.resolve(:kernelrelease)
-          release_strings = fact_value.split('.')
-          Facter::ResolvedFact.new(FACT_NAME,
-                                   full: fact_value,
-                                   major: release_strings[0],
-                                   minor: release_strings[1])
+          versions = fact_value.split('.')
+          release = {
+            'full' => fact_value,
+            'major' => versions[0],
+            'minor' => versions[1]
+          }
+
+          [Facter::ResolvedFact.new(FACT_NAME, release),
+           Facter::ResolvedFact.new(ALIASES.first, versions[0], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/processors/count.rb

@@ -5,10 +5,11 @@ module Facts
     module Processors
       class Count
         FACT_NAME = 'processors.count'
+        ALIASES = 'processorcount'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Macosx::Processors.resolve(:logicalcount)
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/processors/isa.rb

@@ -5,10 +5,11 @@ module Facts
     module Processors
       class Isa
         FACT_NAME = 'processors.isa'
+        ALIASES = 'hardwareisa'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Uname.resolve(:processor)
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/processors/models.rb

@@ -5,10 +5,15 @@ module Facts
     module Processors
       class Models
         FACT_NAME = 'processors.models'
+        ALIASES = 'processor.*'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Macosx::Processors.resolve(:models)
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          facts = [Facter::ResolvedFact.new(FACT_NAME, fact_value)]
+          fact_value.each_with_index do |value, index|
+            facts.push(Facter::ResolvedFact.new("processor#{index}", value, :legacy))
+          end
+          facts
         end
       end
     end

data/lib/facts/macosx/processors/physicalcount.rb

@@ -5,10 +5,11 @@ module Facts
     module Processors
       class Physicalcount
         FACT_NAME = 'processors.physicalcount'
+        ALIASES = 'physicalprocessorcount'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Macosx::Processors.resolve(:physicalcount)
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/{augeas.rb → puppet_version.rb}

@@ -2,11 +2,12 @@
 
 module Facts
   module Macosx
-    class Augeas
-      FACT_NAME = 'augeas.version'
+    class PuppetVersion
+      FACT_NAME = 'puppetversion'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Augeas.resolve(:augeas_version)
+        fact_value = Facter::Resolvers::PuppetVersionResolver.resolve(:puppetversion)
+
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

data/lib/facts/macosx/ruby/platform.rb

@@ -5,11 +5,11 @@ module Facts
     module Ruby
       class Platform
         FACT_NAME = 'ruby.platform'
+        ALIASES = 'rubyplatform'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Ruby.resolve(:platform)
-
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/ruby/sitedir.rb

@@ -5,11 +5,11 @@ module Facts
     module Ruby
       class Sitedir
         FACT_NAME = 'ruby.sitedir'
+        ALIASES = 'rubysitedir'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Ruby.resolve(:sitedir)
-
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end

data/lib/facts/macosx/ssh.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    class Ssh
+      FACT_NAME = 'ssh'
+
+      def call_the_resolver
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        ssh_facts = {}
+        result.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
+        Facter::ResolvedFact.new(FACT_NAME, ssh_facts)
+      end
+
+      private
+
+      def create_ssh_fact(ssh)
+        { ssh.name.to_sym =>
+              { fingerprints: { sha1: ssh.fingerprint.sha1,
+                                sha256: ssh.fingerprint.sha256 },
+                key: ssh.key,
+                type: ssh.type } }
+      end
+    end
+  end
+end

data/lib/facts/macosx/sshalgorithmkey.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end

data/lib/facts/macosx/sshfp_algorithm.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Macosx
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end

data/lib/facts/macosx/system_profiler/boot_mode.rb

@@ -5,10 +5,11 @@ module Facts
     module SystemProfiler
       class BootMode
         FACT_NAME = 'system_profiler.boot_mode'
+        ALIASES = 'sp_boot_mode'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::SystemProfiler.resolve(:boot_mode)
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end
       end
     end