facter 4.0.23

data/lib/framework/formatters/hocon_fact_formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  class HoconFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      return if user_queries.count < 1
+      return format_for_multiple_user_queries(user_queries, resolved_facts) if user_queries.count > 1
+
+      user_query = user_queries.first
+      return format_for_no_query(resolved_facts) if user_query.empty?
+      return format_for_single_user_query(user_queries.first, resolved_facts) unless user_query.empty?
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('Formatting for no user query')
+      fact_collection = FormatterHelper.retrieve_fact_collection(resolved_facts)
+      hash_to_hocon(fact_collection)
+    end
+
+    def format_for_multiple_user_queries(user_queries, resolved_facts)
+      @log.debug('Formatting for multiple user queries')
+
+      facts_to_display = FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      hash_to_hocon(facts_to_display)
+    end
+
+    def format_for_single_user_query(user_query, resolved_facts)
+      @log.debug('Formatting for single user query')
+
+      fact_value = FormatterHelper.retrieve_fact_value_for_single_query(user_query, resolved_facts)
+
+      return '' unless fact_value
+
+      fact_value.class == Hash ? hash_to_hocon(fact_value) : fact_value
+    end
+
+    def hash_to_hocon(fact_collection)
+      render_opts = Hocon::ConfigRenderOptions.new(false, false, true, false)
+      Hocon::ConfigFactory.parse_string(fact_collection.to_json).root.render(render_opts)
+    end
+  end
+end

data/lib/framework/formatters/json_fact_formatter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  class JsonFactFormatter
+    def initialize
+      @log = Facter::Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      if user_queries.count == 1 && user_queries.first.empty?
+        format_for_no_query(resolved_facts)
+      else
+        format_for_user_queries(user_queries, resolved_facts)
+      end
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('No user query provided')
+
+      fact_collection = FormatterHelper.retrieve_fact_collection(resolved_facts)
+      JSON.pretty_generate(fact_collection)
+    end
+
+    def format_for_user_queries(user_queries, resolved_facts)
+      @log.debug('User provided a query')
+
+      facts_to_display = FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      JSON.pretty_generate(facts_to_display)
+    end
+  end
+end

data/lib/framework/formatters/legacy_fact_formatter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Facter
+  class LegacyFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      return if user_queries.count < 1
+      return format_for_multiple_user_queries(user_queries, resolved_facts) if user_queries.count > 1
+
+      user_query = user_queries.first
+      return format_for_no_query(resolved_facts) if user_query.empty?
+      return format_for_single_user_query(user_queries.first, resolved_facts) unless user_query.empty?
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('Formatting for no user query')
+      fact_collection = Facter::FormatterHelper.retrieve_fact_collection(resolved_facts)
+      pretty_json = hash_to_facter_format(fact_collection)
+
+      pretty_json = remove_enclosing_accolades(pretty_json)
+      remove_comma_and_quation(pretty_json)
+    end
+
+    def format_for_multiple_user_queries(user_queries, resolved_facts)
+      @log.debug('Formatting for multiple user queries')
+
+      facts_to_display = Facter::FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+
+      facts_to_display.each { |k, v| facts_to_display[k] = v.nil? ? '' : v }
+      pretty_json = hash_to_facter_format(facts_to_display)
+      pretty_json = remove_enclosing_accolades(pretty_json)
+      pretty_json = remove_comma_and_quation(pretty_json)
+
+      @log.debug('Remove quotes from value if value is a string')
+      pretty_json.gsub(/^(\S*) => \"(.*)\"/, '\1 => \2')
+    end
+
+    def format_for_single_user_query(user_query, resolved_facts)
+      @log.debug('Formatting for single user query')
+
+      fact_value = Facter::FormatterHelper.retrieve_fact_value_for_single_query(user_query, resolved_facts)
+
+      return fact_value if fact_value.is_a?(String)
+
+      pretty_json = fact_value.nil? ? '' : hash_to_facter_format(fact_value)
+
+      @log.debug('Remove quotes from value if it is a simple string')
+      pretty_json.gsub(/^"(.*)\"/, '\1')
+    end
+
+    def hash_to_facter_format(facts_hash)
+      @log.debug('Converting hash to pretty json')
+      pretty_json = JSON.pretty_generate(facts_hash)
+
+      @log.debug('Change key value delimiter from : to =>')
+      pretty_json.gsub!(/^(.*?)(:)/, '\1 =>')
+
+      @log.debug('Remove quotes from parent nodes')
+      pretty_json.gsub!(/\"(.*)\"\ =>/, '\1 =>')
+
+      @log.debug('Remove double backslashes from paths')
+      pretty_json.gsub(/\\\\/, '\\')
+    end
+
+    def remove_enclosing_accolades(pretty_fact_json)
+      @log.debug('Removing enclosing accolades')
+      pretty_fact_json = pretty_fact_json[1..-2]
+
+      @log.debug('Remove empty lines')
+      pretty_fact_json.gsub!(/^$\n/, '')
+
+      @log.debug('Fix indentation after removing enclosed accolades')
+      pretty_fact_json = pretty_fact_json.gsub(/^\s\s(.*)$/, '\1')
+
+      @log.debug('remove comas from query results')
+      pretty_fact_json.gsub(/^},/, '}')
+    end
+
+    def remove_comma_and_quation(output)
+      @log.debug('Remove unnecessary comma and quotation marks on root facts')
+      output.split("\n").map! { |line| line =~ /^[\s]+/ ? line : line.gsub(/,$|\"/, '') }.join("\n")
+    end
+  end
+end

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,99 @@
+# 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
+        query_list = loaded_fact.map(&:name) 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 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
+      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?('.')
+
+        return false if fact_with_wildcard && !query_fact.match("^#{fact_name}$")
+
+        return false unless fact_with_wildcard || fact_name.match("^#{query_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
+        SearchedFact.new(fact_name, klass_name, filter_tokens, user_query, type)
+      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