openfact 5.0.0.rc0

data/lib/facter/framework/formatters/hocon_fact_formatter.rb

@@ -0,0 +1,51 @@
+# 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?
+
+      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.instance_of?(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/facter/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/facter/framework/formatters/legacy_fact_formatter.rb

@@ -0,0 +1,101 @@
+# 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?
+
+      format_for_single_user_query(user_queries.first, resolved_facts)
+    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)
+      pretty_json = remove_comma_and_quotation(pretty_json)
+      handle_newlines(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_quotation(pretty_json)
+      pretty_json = handle_newlines(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!(/":\s/, '" => ')
+
+      @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 handle_newlines(pretty_fact_json)
+      @log.debug('Convert newline characters to actual newlines')
+      pretty_fact_json.gsub('\n', "\n")
+    end
+
+    def remove_comma_and_quotation(output)
+      # quotation marks that come after \ are not removed
+      @log.debug('Remove unnecessary comma and quotation marks on root facts')
+      output.split("\n")
+            .map! { |line| /^\s+/.match?(line) ? line : line.gsub(/,$|(?<!\\)"/, '').gsub('\\"', '"') }.join("\n")
+    end
+  end
+end

data/lib/facter/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 /true|false/.match?(value)
+      return false if value[/^[0-9]+$/]
+      return true if /y|Y|yes|Yes|YES|n|N|no|No|NO|True|TRUE|False|FALSE|on|On|ON|off|Off|OFF|:/.match?(value)
+      return false if value[/[a-zA-Z]/]
+      return false if value[/[0-9]+\.[0-9]+/]
+
+      true
+    end
+  end
+end

data/lib/facter/framework/logging/logger.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'set'
+
+module Facter
+  RED     = "\e[31m"
+  GREEN   = "\e[32m"
+  YELLOW  = "\e[33m"
+  CYAN    = "\e[36m"
+  RESET   = "\e[0m"
+
+  DEFAULT_LOG_LEVEL = :warn
+
+  class Log
+    @@logger = nil
+    @@message_callback = nil
+    @@has_errors = false
+    @@debug_messages = Set.new
+    @@warn_messages = Set.new
+    @@timing = false
+
+    class << self
+      def clear_messages
+        @@debug_messages.clear
+        @@warn_messages.clear
+      end
+
+      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
+
+      # Print an exception message, and optionally a backtrace if trace is set
+
+      # Print timing information
+      #
+      # @param string [String] the time to print
+      # @return [void]
+      #
+      # @api private
+      def show_time(string)
+        return unless string && timing?
+
+        if @@message_callback
+          @@message_callback.call(:info, string)
+        else
+          warn("#{GREEN}#{string}#{RESET}")
+        end
+      end
+
+      # Enable or disable logging of timing information
+      #
+      # @param bool [true, false]
+      # @return [void]
+      #
+      # @api private
+      def timing(bool)
+        @@timing = bool
+      end
+
+      # Returns whether timing output is turned on
+      #
+      # @api private
+      def timing?
+        @@timing
+      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 @@message_callback && Options[:allow_external_loggers]
+        @@message_callback.call(:debug, msg)
+      else
+        msg = colorize(msg, CYAN) if Options[:color]
+        @@logger.debug("#{@class_name} - #{msg}")
+      end
+    end
+
+    def debugonce(msg)
+      return unless debugging_active?
+
+      message_string = msg.to_s
+      return if @@debug_messages.include? message_string
+
+      @@debug_messages << message_string
+      debug(message_string)
+    end
+
+    def info(msg)
+      if msg.nil? || msg.empty?
+        empty_message_error(msg)
+      elsif @@message_callback && Options[:allow_external_loggers]
+        @@message_callback.call(:info, msg)
+      else
+        msg = colorize(msg, GREEN) if Options[:color]
+        @@logger.info("#{@class_name} - #{msg}")
+      end
+    end
+
+    def warn(msg)
+      if @@message_callback && Options[:allow_external_loggers]
+        @@message_callback.call(:warn, msg)
+      else
+        msg = colorize(msg, YELLOW) if Options[:color]
+        @@logger.warn("#{@class_name} - #{msg}")
+      end
+    end
+
+    def warnonce(message)
+      message_string = message.to_s
+      return if @@warn_messages.include? message_string
+
+      @@warn_messages << message_string
+      warn(message_string)
+    end
+
+    def error(msg, colorize = false) # rubocop:disable Style/OptionalBooleanParameter
+      @@has_errors = true
+
+      if @@message_callback && Options[:allow_external_loggers]
+        @@message_callback.call(:error, msg)
+      else
+        msg = colorize(msg, RED) if colorize || Options[:color]
+        @@logger.error("#{@class_name} - #{msg}")
+      end
+    end
+
+    def log_exception(exception)
+      msg = exception.message
+      msg += "\n#{exception.backtrace.join("\n")}" if Options[:trace]
+
+      error(msg, true)
+    end
+
+    private
+
+    def colorize(msg, color)
+      "#{color}#{msg}#{RESET}"
+    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/facter/framework/logging/logger_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class LoggerHelper
+  class << self
+    def determine_callers_name(sender_self)
+      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
+    end
+  end
+end

data/lib/facter/framework/parsers/query_parser.rb

@@ -0,0 +1,110 @@
+# 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.
+      #
+      # @param query_list [Array] The list of facts to search for
+      # @param loaded_facts [Array] All of the fact definitions for the current operating system
+      #
+      # @return [Array<SearchedFact>] a list of searchable facts that resolve the user's query
+      def parse(query_list, loaded_facts)
+        matched_facts = []
+        @query_list = query_list
+
+        return no_user_query(loaded_facts) unless query_list.any?
+
+        query_list.each do |query|
+          found_facts = search_for_facts(query, loaded_facts)
+          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_facts)
+        resolvable_fact_list = []
+        query = query.to_s
+        query_tokens = query.end_with?('.*') ? [query] : query.split('.')
+        size = query_tokens.size
+
+        # Try to match the most specific query_tokens to the least, returning the first match
+        size.times do |i|
+          query_token_range = 0..size - i - 1
+          query_fact = query_tokens[query_token_range].join('.')
+          resolvable_fact_list = get_facts_matching_tokens(query_tokens, query_fact, loaded_facts)
+
+          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_fact, loaded_facts)
+        resolvable_fact_list = []
+
+        loaded_facts.each do |loaded_fact|
+          next unless found_fact?(loaded_fact.name, query_fact)
+
+          searched_fact = construct_loaded_fact(query_tokens, loaded_fact)
+          resolvable_fact_list << searched_fact
+        end
+
+        @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}" if resolvable_fact_list.any?
+        resolvable_fact_list
+      end
+
+      def found_fact?(fact_name, query_fact)
+        # This is the case where the fact_name contains a wildcard like
+        # blockdevice_.*_model and we're querying for the legacy fact
+        # specifically using 'blockdevice_sba_model' and we don't want the query
+        # 'blockdevice.sba.model' to match
+        fact_with_wildcard = fact_name.include?('.*') && !query_fact.include?('.')
+
+        if fact_with_wildcard
+          # fact_name contains wildcard, so we're intentially not escaping.
+          query_fact.match("^#{fact_name}$")
+        else
+          processed_equery_fact = query_fact.gsub('\\', '\\\\\\\\')
+          # Must escape metacharacters (like dots) to ensure the correct fact is found
+          fact_name.match("^#{Regexp.escape(processed_equery_fact)}($|\\.)")
+        end
+      end
+
+      def construct_loaded_fact(query_tokens, loaded_fact)
+        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, user_query, type)
+        sf.file = loaded_fact.file
+
+        sf
+      end
+    end
+  end
+end

data/lib/facter/models/fact_collection.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Facter
+  class FactCollection < Hash
+    def initialize
+      super
+      @log = Log.new(self)
+    end
+
+    def to_yaml
+      deep_to_h.to_yaml
+    end
+
+    # Transorms a list of {Facter::ResolvedFact} into a nested collection.
+    # @param facts [Array<Facter::ResolvedFact>]
+    #
+    # @return [FactCollection]
+    #
+    # @api private
+    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 dig_fact(user_query)
+      value(user_query)
+    rescue KeyError, TypeError
+      nil
+    end
+
+    # Collection#fetch implementation for nested collections.
+    # @param user_query [String] the search terms, separated by "."
+    #
+    # @return [String]
+    #
+    # @example for fact_collection = { "os": { "name": "Darwin" } }
+    #   fact_collection.fetch("os.name") #=> "Darwin"
+    #
+    # @api private
+    def value(user_query)
+      fetch(user_query) do
+        split_user_query = Facter::Utils.split_user_query(user_query)
+        split_user_query.reduce(self) do |memo, key|
+          raise KeyError unless memo.respond_to?(:fetch)
+
+          memo.fetch(key) { memo.fetch(key.to_s) }
+        end
+      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 deep_to_h(collection = self)
+      collection.each_pair.with_object({}) do |(key, value), hash|
+        hash[key] = value.is_a?(FactCollection) ? deep_to_h(value) : value
+      end
+    end
+
+    def bury_fact(fact)
+      split_fact_name = extract_fact_name(fact)
+      bury(*split_fact_name << fact.value)
+    rescue NoMethodError
+      @log.error("#{fact.type.to_s.capitalize} fact `#{fact.name}` cannot be added to collection."\
+          ' The format of this fact is incompatible with other'\
+          " facts that belong to `#{fact.name.split('.').first}` group")
+    end
+
+    def extract_fact_name(fact)
+      case fact.type
+      when :legacy
+        [fact.name]
+      when :custom, :external
+        Options[:force_dot_resolution] == true ? fact.name.split('.') : [fact.name]
+      else
+        fact.name.split('.')
+      end
+    end
+  end
+end

data/lib/facter/models/loaded_fact.rb

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