facter 4.0.9.pre → 4.0.10.pre

data/lib/custom_facts/core/execution/posix.rb

@@ -13,11 +13,11 @@ module LegacyFacter
 
         def which(bin)
           if absolute_path?(bin)
-            return bin if File.executable?(bin) && File.file?(bin)
+            return bin if File.executable?(bin) && FileTest.file?(bin)
           else
             search_paths.each do |dir|
               dest = File.join(dir, bin)
-              return dest if File.executable?(dest) && File.file?(dest)
+              return dest if File.executable?(dest) && FileTest.file?(dest)
             end
           end
           nil

data/lib/custom_facts/core/resolvable.rb

@@ -5,7 +5,7 @@ require 'timeout'
 # The resolvable mixin defines behavior for evaluating and returning fact
 # resolutions.
 #
-# Classes including this mixin should implement at #name method describing
+# Classes including this mixin should implement a #name method describing
 # the value being resolved and a #resolve_value that actually executes the code
 # to resolve the value.
 module LegacyFacter

data/lib/custom_facts/core/suitable.rb

@@ -20,6 +20,7 @@ module LegacyFacter
       # @api public
       def has_weight(weight)
         @weight = weight
+        self
       end
 
       # Sets the conditions for this resolution to be used.  This method accepts
@@ -69,7 +70,7 @@ module LegacyFacter
       #     evaluates to `false` or `nil` then the confined fact will not be
       #     evaluated.
       #   @example Confine the fact to systems with a specific file.
-      #       confine { File.exist? '/bin/foo' }
+      #       confine { File.readable? '/bin/foo' }
       def confine(confines = nil, &block)
         case confines
         when Hash

data/lib/custom_facts/util/fact.rb

@@ -11,7 +11,7 @@ module LegacyFacter
     class Fact
       # The name of the fact
       # @return [String]
-      attr_accessor :name
+      attr_reader :name
 
       # @return [String]
       # @deprecated
@@ -161,7 +161,7 @@ module LegacyFacter
       end
 
       def sort_by_weight(resolutions)
-        resolutions.sort { |a, b| b.weight.to_i <=> a.weight.to_i }
+        resolutions.sort { |a, b| b.weight <=> a.weight }
       end
 
       def find_first_real_value(resolutions)
@@ -171,7 +171,7 @@ module LegacyFacter
           rescue Facter::ResolveCustomFactError
             break
           end
-          @used_resolution_weight = resolve.weight || 0
+          @used_resolution_weight = resolve.weight
           return value unless value.nil?
         end
         nil

data/lib/custom_facts/util/loader.rb

@@ -25,7 +25,7 @@ module LegacyFacter
           # Load individual files
           file = File.join(dir, filename)
 
-          load_file(file) if File.file?(file)
+          load_file(file) if FileTest.file?(file)
         end
       end
 
@@ -42,7 +42,7 @@ module LegacyFacter
           # dir is already an absolute path
           Dir.glob(File.join(dir, '*.rb')).each do |path|
             # exclude dirs that end with .rb
-            load_file(path) if File.file?(path)
+            load_file(path) if FileTest.file?(path)
           end
         end
 

data/lib/custom_facts/util/parser.rb

@@ -131,7 +131,7 @@ module LegacyFacter
 
       class ScriptParser < Base
         def parse_results
-          parse_executable_output(LegacyFacter::Core::Execution.exec(quote(filename)))
+          parse_executable_output(Facter::Core::Execution.exec(quote(filename)))
         end
 
         private
@@ -143,9 +143,9 @@ module LegacyFacter
 
       register(ScriptParser) do |filename|
         if LegacyFacter::Util::Config.windows?
-          extension_matches?(filename, %w[bat cmd com exe]) && File.file?(filename)
+          extension_matches?(filename, %w[bat cmd com exe]) && FileTest.file?(filename)
         else
-          File.executable?(filename) && File.file?(filename) && !extension_matches?(filename, %w[bat cmd com exe])
+          File.executable?(filename) && FileTest.file?(filename) && !extension_matches?(filename, %w[bat cmd com exe])
         end
       end
 
@@ -154,9 +154,9 @@ module LegacyFacter
         # Returns a hash of facts from powershell output
         def parse_results
           powershell =
-            if File.exist?("#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe")
+            if File.readable?("#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe")
               "#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe"
-            elsif File.exist?("#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe")
+            elsif File.readable?("#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe")
               "#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe"
             else
               'powershell.exe'
@@ -164,13 +164,13 @@ module LegacyFacter
 
           shell_command =
             "\"#{powershell}\" -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
-          output = LegacyFacter::Core::Execution.exec(shell_command)
+          output = Facter::Core::Execution.exec(shell_command)
           parse_executable_output(output)
         end
       end
 
       register(PowershellParser) do |filename|
-        LegacyFacter::Util::Config.windows? && extension_matches?(filename, 'ps1') && File.file?(filename)
+        LegacyFacter::Util::Config.windows? && extension_matches?(filename, 'ps1') && FileTest.file?(filename)
       end
 
       # A parser that is used when there is no other parser that can handle the file

data/lib/custom_facts/util/resolution.rb

@@ -16,9 +16,7 @@ module Facter
       attr_accessor :code
       attr_writer :value
 
-      attr_reader :weight
-
-      extend LegacyFacter::Core::Execution
+      extend Facter::Core::Execution
 
       class << self
         # Expose command execution methods that were extracted into

data/lib/custom_facts/version.rb

@@ -79,7 +79,7 @@ module LegacyFacter
   # @return [String] the version -- for example: "1.6.14-6-gea42046" or nil if the VERSION
   #   file does not exist.
   def self.read_version_file(path)
-    File.read(path).chomp if File.exist?(path)
+    File.read(path).chomp if File.readable?(path)
   end
   private_class_method :read_version_file
 end

data/lib/facter.rb

@@ -13,18 +13,47 @@ module Facter
   @options = Options.instance
   Log.add_legacy_logger(STDOUT)
   @logger = Log.new(self)
+  @already_searched = {}
 
   class << self
+    def clear_messages
+      @logger.debug('clear_messages is not implemented')
+    end
+
+    # Alias method for Facter.fact()
+    # @param name [string] fact name
+    #
+    # @return [LegacyFacter::Util::Fact, nil] The fact object, or nil if no fact
+    #   is found.
+    #
+    # @api public
     def [](name)
       fact(name)
     end
 
+    # Add custom facts to fact collection
+    # @param name [String] Custom fact name
+    # @param options = {} [Hash] optional parameters for the fact - attributes
+    #   of {Facter::Util::Fact} and {Facter::Util::Resolution} can be
+    #   supplied here
+    # @param block [Proc] a block defining a fact resolution
+    #
+    # @return [LegacyFacter::Util::Fact] the fact object, which includes any previously
+    #   defined resolutions
+    #
+    # @api public
     def add(name, options = {}, &block)
       options[:fact_type] = :custom
       LegacyFacter.add(name, options, &block)
     end
 
+    # Clears all cached values and removes all facts from memory.
+    #
+    # @return [nil]
+    #
+    # @api public
     def clear
+      @already_searched = {}
       LegacyFacter.clear
     end
 
@@ -36,6 +65,12 @@ module Facter
       fact_collection.dig(*splitted_user_query)
     end
 
+    # Prints out a debug message when debug option is set to true
+    # @param msg [String] Message to be printed out
+    #
+    # @return [nil]
+    #
+    # @api public
     def debug(msg)
       return unless debugging?
 
@@ -47,10 +82,21 @@ module Facter
       Facter::Log.on_message(&block)
     end
 
+    # Check whether debuging is enabled
+    #
+    # @return [bool]
+    #
+    # @api public
     def debugging?
       Options[:debug]
     end
 
+    # Enable or disable debugging
+    # @param debug_bool [bool] State which debugging should have
+    #
+    # @return [type] [description]
+    #
+    # @api public
     def debugging(debug_bool)
       @options.priority_options[:debug] = debug_bool
       @options.refresh
@@ -58,52 +104,83 @@ module Facter
       debug_bool
     end
 
-    def fact(name)
-      fact = Facter::Util::Fact.new(name)
-      val = value(name)
-      fact.add({}) { setcode { val } }
-      fact
-    end
-
-    def log_errors(missing_names)
-      missing_names.each do |missing_name|
-        @logger.error("fact \"#{missing_name}\" does not exist.", true)
-      end
-    end
+    # Returns a fact object by name.  If you use this, you still have to
+    # call {Facter::Util::Fact#value `value`} on it to retrieve the actual
+    # value.
+    #
+    # @param name [String] the name of the fact
+    #
+    # @return [LegacyFacter::Util::Fact, nil] The fact object, or nil if no fact
+    #   is found.
+    #
+    # @api public
+    def fact(user_query)
+      user_query = user_query.to_s
+      resolve_fact(user_query)
 
-    def method_missing(name, *args, &block)
-      @logger.error(
-        "--#{name}-- not implemented but required \n" \
-        'with params: ' \
-        "#{args.inspect} \n" \
-        'with block: ' \
-        "#{block.inspect}  \n" \
-        "called by:  \n" \
-        "#{caller} \n"
-      )
-      nil
+      @already_searched[user_query]
     end
 
+    # Reset search paths for custom and external facts
+    # If config file is set custom and external facts will be reloaded
+    #
+    # @return [nil]
+    #
+    # @api public
     def reset
       LegacyFacter.reset
+      LegacyFacter.search(*Options.custom_dir)
+      LegacyFacter.search_external(Options.external_dir)
+      nil
     end
 
+    # Register directories to be searched for custom facts. The registered directories
+    # must be absolute paths or they will be ignored.
+    #
+    # @param dirs [Array<String>] An array of searched directories
+    #
+    # @return [void]
+    #
+    # @api public
     def search(*dirs)
       LegacyFacter.search(*dirs)
     end
 
+    # Registers directories to be searched for external facts.
+    #
+    # @param dirs [Array<String>] An array of searched directories
+    #
+    # @return [void]
+    #
+    # @api public
     def search_external(dirs)
       LegacyFacter.search_external(dirs)
     end
 
+    # Returns the registered search directories.for external facts.
+    #
+    # @return [Array<String>] An array of searched directories
+    #
+    # @api public
     def search_external_path
       LegacyFacter.search_external_path
     end
 
+    # Returns the registered search directories for custom facts.
+    #
+    # @return [Array<String>] An array of the directories searched
+    #
+    # @api public
     def search_path
       LegacyFacter.search_path
     end
 
+    # Gets a hash mapping fact names to their values
+    # The hash contains core facts, legacy facts, custom facts and external facts (all facts that can be resolved).
+    #
+    # @return [FactCollection] the hash of fact names and values
+    #
+    # @api public
     def to_hash
       @options.priority_options[:to_hash] = true
       @options.refresh
@@ -115,6 +192,52 @@ module Facter
       FactCollection.new.build_fact_collection!(resolved_facts)
     end
 
+    # Check whether printing stack trace is enabled
+    #
+    # @return [bool]
+    #
+    # @api public
+    def trace?
+      LegacyFacter.trace?
+    end
+
+    # Enable or disable trace
+    # @param debug_bool [bool] Set trace on debug state
+    #
+    # @return [type] [description]
+    #
+    # @api public
+    def trace(bool)
+      LegacyFacter.trace(bool)
+    end
+
+    # Gets the value for a fact. Returns `nil` if no such fact exists.
+    #
+    # @param name [String] the fact name
+    # @return [String] the value of the fact, or nil if no fact is found
+    #
+    # @api public
+    def value(user_query)
+      user_query = user_query.to_s
+      resolve_fact(user_query)
+      @already_searched[user_query]&.value
+    end
+
+    # Returns Facter version
+    #
+    # @return [String] Current version
+    #
+    # @api public
+    def version
+      version_file = ::File.join(ROOT_DIR, 'VERSION')
+      ::File.read(version_file).strip
+    end
+
+    # Gets a hash mapping fact names to their values
+    #
+    # @return [Array] the hash of fact names and values
+    #
+    # @api private
     def to_user_output(cli_options, *args)
       @options.priority_options = { is_cli: true }.merge!(cli_options.map { |(k, v)| [k.to_sym, v] }.to_h)
       @options.refresh(args)
@@ -130,36 +253,43 @@ module Facter
       [fact_formatter.format(resolved_facts), status || 0]
     end
 
-    def trace?
-      LegacyFacter.trace?
-    end
+    private
 
-    def trace(bool)
-      LegacyFacter.trace(bool)
+    def add_fact_to_searched_facts(user_query, value)
+      @already_searched[user_query] ||= ResolvedFact.new(user_query, value)
+      @already_searched[user_query].value = value
     end
 
-    def value(user_query)
+    # Returns a ResolvedFact and saves the result in @already_searched array that is used as a global collection.
+    # @param user_query [String] Fact that needs resolution
+    #
+    # @return [ResolvedFact]
+    def resolve_fact(user_query)
       @options.refresh([user_query])
       user_query = user_query.to_s
       resolved_facts = Facter::FactManager.instance.resolve_facts([user_query])
       CacheManager.invalidate_all_caches
       fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
       splitted_user_query = Facter::Utils.split_user_query(user_query)
-      fact_collection.dig(*splitted_user_query)
-    end
-
-    def version
-      version_file = ::File.join(ROOT_DIR, 'VERSION')
-      ::File.read(version_file).strip
-    end
 
-    private
-
-    def log_blocked_facts
-      block_list = BlockList.instance.block_list
-      @logger.debug("blocking collection of #{block_list.join("\s")} facts") if block_list.any? && Options[:block]
+      begin
+        value = fact_collection.value(*splitted_user_query)
+        add_fact_to_searched_facts(user_query, value)
+      rescue KeyError
+        nil
+      end
     end
 
+    # Returns exit status when user query contains facts that do
+    #   not exist
+    #
+    # @param dirs [Array] Arguments sent to CLI
+    # @param dirs [Array] List of resolved facts
+    #
+    # @return [Integer, nil] Will return status 1 if user query contains
+    #  facts that are not found or resolved, otherwise it will return nil
+    #
+    # @api private
     def error_check(args, resolved_facts)
       if Options.instance[:strict]
         missing_names = args - resolved_facts.map(&:user_query).uniq
@@ -173,5 +303,51 @@ module Facter
 
       status
     end
+
+    # Prints out blocked facts before to_hash or to_user_output is called
+    #
+    # @return [nil]
+    #
+    # @api private
+    def log_blocked_facts
+      block_list = BlockList.instance.block_list
+      @logger.debug("blocking collection of #{block_list.join("\s")} facts") if block_list.any? && Options[:block]
+    end
+
+    # Used for printing errors regarding CLI user input validation
+    #
+    # @param missing_names [Array] List of facts that were requested
+    #  but not found
+    #
+    # @return [nil]
+    #
+    # @api private
+    def log_errors(missing_names)
+      missing_names.each do |missing_name|
+        @logger.error("fact \"#{missing_name}\" does not exist.", true)
+      end
+    end
+
+    # Proxy method that catches not yet implemented method calls
+    #
+    # @param name [type] [description]
+    # @param *args [type] [description]
+    # @param &block [type] [description]
+    #
+    # @return [type] [description]
+    #
+    # @api private
+    def method_missing(name, *args, &block)
+      @logger.error(
+        "--#{name}-- not implemented but required \n" \
+        'with params: ' \
+        "#{args.inspect} \n" \
+        'with block: ' \
+        "#{block.inspect}  \n" \
+        "called by:  \n" \
+        "#{caller} \n"
+      )
+      nil
+    end
   end
 end