facter 4.0.28

data/lib/framework/formatters/yaml_fact_formatter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facter
+  class YamlFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      facts_to_display = if user_queries.count == 1 && user_queries.first.empty?
+                           FormatterHelper.retrieve_fact_collection(resolved_facts)
+                         else
+                           FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+                         end
+
+      facts_to_display = Psych.parse_stream(facts_to_display.to_yaml)
+      facts_to_display.children[0].tag_directives = []
+      yaml_pretty = quote_special_strings(facts_to_display)
+
+      @log.debug('Replace ---  from yaml beginning, to keep it compatible with C facter')
+      yaml_pretty.gsub(/^---[\r\n]+/, '')
+    end
+
+    private
+
+    def quote_special_strings(fact_hash)
+      require 'psych'
+
+      fact_hash.grep(Psych::Nodes::Scalar).each do |node|
+        next unless needs_quote?(node.value)
+
+        node.plain  = false
+        node.quoted = true
+        node.style  = Psych::Nodes::Scalar::DOUBLE_QUOTED
+      end
+
+      fact_hash = unquote_keys(fact_hash)
+      fact_hash.yaml
+    end
+
+    def unquote_keys(fact_hash)
+      fact_hash.grep(Psych::Nodes::Mapping).each do |node|
+        node.children.each_slice(2) do |k, _|
+          k.plain  = true
+          k.quoted = false
+          k.style  = Psych::Nodes::Scalar::ANY
+        end
+      end
+      fact_hash
+    end
+
+    def needs_quote?(value)
+      return false if value =~ /true|false/
+      return false if value[/^[0-9]+$/]
+      return true if value =~ /y|Y|yes|Yes|YES|n|N|no|No|NO|True|TRUE|False|FALSE|on|On|ON|off|Off|OFF|:/
+      return false if value[/[a-zA-Z]/]
+      return false if value[/[0-9]+\.[0-9]+\./]
+
+      true
+    end
+  end
+end

data/lib/framework/logging/logger.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Facter
+  RED = 31
+  GREEN = 32
+  YELLOW = 33
+  CYAN = 36
+
+  DEFAULT_LOG_LEVEL = :warn
+
+  class Log
+    @@logger = nil
+    @@message_callback = nil
+    @@has_errors = false
+
+    class << self
+      def on_message(&block)
+        @@message_callback = block
+      end
+
+      def level=(log_level)
+        @@logger.level = log_level
+      end
+
+      def level
+        @@logger.level
+      end
+
+      def errors?
+        @@has_errors
+      end
+
+      def output(output)
+        return if @@logger
+
+        @@logger = Logger.new(output)
+        set_logger_format
+        @@logger.level = DEFAULT_LOG_LEVEL
+      end
+
+      def set_logger_format
+        @@logger.formatter = proc do |severity, datetime, _progname, msg|
+          datetime = datetime.strftime(@datetime_format || '%Y-%m-%d %H:%M:%S.%6N ')
+          "[#{datetime}] #{severity} #{msg} \n"
+        end
+      end
+    end
+
+    def initialize(logged_class)
+      @class_name = LoggerHelper.determine_callers_name(logged_class)
+      return unless @@logger.nil?
+
+      @@logger = Logger.new(STDOUT)
+      @@logger.level = DEFAULT_LOG_LEVEL
+    end
+
+    def debug(msg)
+      return unless debugging_active?
+
+      if msg.nil? || msg.empty?
+        empty_message_error(msg)
+      elsif @@message_callback
+        @@message_callback.call(:debug, msg)
+      else
+        msg = colorize(msg, CYAN) if Options[:color]
+        @@logger.debug(@class_name + ' - ' + msg)
+      end
+    end
+
+    def info(msg)
+      if msg.nil? || msg.empty?
+        empty_message_error(msg)
+      elsif @@message_callback
+        @@message_callback.call(:info, msg)
+      else
+        msg = colorize(msg, GREEN) if Options[:color]
+        @@logger.info(@class_name + ' - ' + msg)
+      end
+    end
+
+    def warn(msg)
+      if msg.nil? || msg.empty?
+        empty_message_error(msg)
+      elsif @@message_callback
+        @@message_callback.call(:warn, msg)
+      else
+        msg = colorize(msg, YELLOW) if Options[:color]
+        @@logger.warn(@class_name + ' - ' + msg)
+      end
+    end
+
+    def error(msg, colorize = false)
+      @@has_errors = true
+
+      if msg.nil? || msg.empty?
+        empty_message_error(msg)
+      elsif @@message_callback
+        @@message_callback.call(:error, msg)
+      else
+        msg = colorize(msg, RED) if colorize || Options[:color]
+        @@logger.error(@class_name + ' - ' + msg)
+      end
+    end
+
+    private
+
+    def colorize(msg, color)
+      return msg if OsDetector.instance.identifier.eql?(:windows)
+
+      "\e[0;#{color}m#{msg}\e[0m"
+    end
+
+    def debugging_active?
+      return true unless Facter.respond_to?(:debugging?)
+
+      Facter.debugging?
+    end
+
+    def empty_message_error(msg)
+      invoker = caller(1..1).first.slice(/.*:\d+/)
+      @@logger.warn "#{self.class}#debug invoked with invalid message #{msg.inspect}:#{msg.class} at #{invoker}"
+    end
+  end
+end

data/lib/framework/logging/logger_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class LoggerHelper
+  class << self
+    def determine_callers_name(sender_self)
+      class_name = case sender_self
+                   when String
+                     sender_self
+                   when Class
+                     sender_self.name
+                   when Module
+                     sender_self.name
+                   else # when class is singleton
+                     sender_self.class.name
+                   end
+      class_name
+    end
+  end
+end

data/lib/framework/parsers/query_parser.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Facter
+  class QueryParser
+    @log = Log.new(self)
+    class << self
+      # Searches for facts that could resolve a user query.
+      # There are 4 types of facts:
+      #   root facts
+      #     e.g. networking
+      #   child facts
+      #     e.g. networking.dhcp
+      #   composite facts
+      #     e.g. networking.interfaces.en0.bindings.address
+      #   regex facts (legacy)
+      #     e.g. impaddress_end160
+      #
+      # Because a root fact will always be resolved by a collection of child facts,
+      # we can return one or more child facts for each parent.
+      #
+      # query -  is the user input used to search for facts
+      # loaded_fact - is a list with all facts for the current operating system
+      #
+      # Returns a list of SearchedFact objects that resolve the users query.
+      def parse(query_list, loaded_fact)
+        matched_facts = []
+        @log.debug "User query is: #{query_list}"
+        @query_list = query_list
+
+        return no_user_query(loaded_fact) unless query_list.any?
+
+        query_list.each do |query|
+          @log.debug "Query is #{query}"
+          found_facts = search_for_facts(query, loaded_fact)
+          matched_facts << found_facts
+        end
+
+        matched_facts.flatten(1)
+      end
+
+      def no_user_query(loaded_facts)
+        searched_facts = []
+        loaded_facts.each do |loaded_fact|
+          searched_facts << SearchedFact.new(loaded_fact.name, loaded_fact.klass, [], '', loaded_fact.type)
+        end
+        searched_facts
+      end
+
+      def search_for_facts(query, loaded_fact_hash)
+        resolvable_fact_list = []
+        query = query.to_s
+        query_tokens = query.end_with?('.*') ? [query] : query.split('.')
+        size = query_tokens.size
+
+        size.times do |i|
+          query_token_range = 0..size - i - 1
+          resolvable_fact_list = get_facts_matching_tokens(query_tokens, query_token_range, loaded_fact_hash)
+
+          return resolvable_fact_list if resolvable_fact_list.any?
+        end
+
+        resolvable_fact_list << SearchedFact.new(query, nil, [], query, :nil) if resolvable_fact_list.empty?
+
+        resolvable_fact_list
+      end
+
+      def get_facts_matching_tokens(query_tokens, query_token_range, loaded_fact_hash)
+        @log.debug "Checking query tokens #{query_tokens[query_token_range].join('.')}"
+        resolvable_fact_list = []
+
+        loaded_fact_hash.each do |loaded_fact|
+          query_fact = query_tokens[query_token_range].join('.')
+
+          next unless found_fact?(loaded_fact.name, query_fact)
+
+          searched_fact = construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
+          resolvable_fact_list << searched_fact
+        end
+
+        @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}"
+        resolvable_fact_list
+      end
+
+      def found_fact?(fact_name, query_fact)
+        fact_with_wildcard = fact_name.include?('.*') && !query_fact.include?('.')
+
+        processed_equery_fact = query_fact.gsub('\\', '\\\\\\\\')
+
+        return false if fact_with_wildcard && !query_fact.match("^#{fact_name}$")
+
+        return false unless fact_with_wildcard || fact_name.match("^#{processed_equery_fact}($|\\.)")
+
+        true
+      end
+
+      def construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
+        filter_tokens = construct_filter_tokens(query_tokens, query_token_range)
+        user_query = @query_list.any? ? query_tokens.join('.') : ''
+        fact_name = loaded_fact.name.to_s
+        klass_name = loaded_fact.klass
+        type = loaded_fact.type
+        sf = SearchedFact.new(fact_name, klass_name, filter_tokens, user_query, type)
+        sf.file = loaded_fact.file
+
+        sf
+      end
+
+      def construct_filter_tokens(query_tokens, query_token_range)
+        (query_tokens - query_tokens[query_token_range]).map do |token|
+          token =~ /^[0-9]+$/ ? token.to_i : token
+        end
+      end
+    end
+  end
+end

data/lib/framework/utils/utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Utils
+    # Sort nested hash.
+    def self.sort_hash_by_key(hash, recursive = true, &block)
+      hash.keys.sort(&block).each_with_object({}) do |key, seed|
+        seed[key] = hash[key]
+        seed[key] = sort_hash_by_key(seed[key], true, &block) if recursive && seed[key].is_a?(Hash)
+
+        seed
+      end
+    end
+
+    def self.deep_copy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+
+    def self.split_user_query(user_query)
+      queries = user_query.split('.')
+      queries.map! { |query| query =~ /^[0-9]+$/ ? query.to_i : query }
+    end
+
+    def self.deep_stringify_keys(object)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[key.to_s] = deep_stringify_keys(value)
+        end
+      when Array
+        object.map { |e| deep_stringify_keys(e) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/models/fact_collection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  class FactCollection < Hash
+    def initialize
+      super
+    end
+
+    def build_fact_collection!(facts)
+      facts.each do |fact|
+        next if %i[core legacy].include?(fact.type) && fact.value.nil?
+
+        bury_fact(fact)
+      end
+
+      self
+    end
+
+    def value(*keys)
+      keys.reduce(self) do |memo, key|
+        memo.fetch(key.to_s)
+      end
+    end
+
+    def bury(*args)
+      raise ArgumentError, '2 or more arguments required' if args.count < 2
+
+      if args.count == 2
+        self[args[0]] = args[1]
+      else
+        arg = args.shift
+        self[arg] = FactCollection.new unless self[arg]
+        self[arg].bury(*args) unless args.empty?
+      end
+
+      self
+    end
+
+    private
+
+    def bury_fact(fact)
+      bury(*fact.name.split('.') + fact.filter_tokens << fact.value)
+    end
+  end
+end

data/lib/models/loaded_fact.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facter
+  class LoadedFact
+    attr_reader :name, :klass, :type
+    attr_accessor :file
+
+    def initialize(name, klass, type = nil, file = nil)
+      @name = name
+      @klass = klass
+      @type = type.nil? ? :core : type
+      @file = file
+    end
+  end
+end

data/lib/models/resolved_fact.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  class ResolvedFact
+    attr_reader :name, :type
+    attr_accessor :user_query, :filter_tokens, :value, :file
+
+    def initialize(name, value = '', type = :core, user_query = nil, filter_tokens = [])
+      @name = name
+      @value = Utils.deep_stringify_keys(value)
+      @type = type
+      @user_query = user_query
+      @filter_tokens = filter_tokens
+    end
+
+    def legacy?
+      type == :legacy
+    end
+
+    def core?
+      type == :core
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end