abide_dev_utils 0.13.0 → 0.14.1

data/lib/abide_dev_utils/ppt/facter_utils.rb

@@ -2,82 +2,281 @@
 
 require 'json'
 require 'facterdb'
+require_relative '../dot_number_comparable'
 
 module AbideDevUtils
   module Ppt
     # Methods relating to Facter
     module FacterUtils
-      class << self
-        attr_writer :current_version
+      # A set of facts for a specific Facter version
+      class FactSet
+        include AbideDevUtils::DotNumberComparable
 
-        def current_version
-          return latest_version unless defined?(@current_version)
+        attr_reader :facter_version, :facts
 
-          @current_version
+        def initialize(facter_version)
+          @facter_version = facter_version.to_s
+          @facts = []
         end
+        alias number facter_version # for DotNumberComparable
 
-        def use_version(version)
-          self.current_version = version
-          current_version
+        def load_facts(fact_file)
+          @facts << JSON.parse(File.read(fact_file))
         end
 
-        def with_version(version, reset: true)
-          return unless block_given?
+        def find_by_fact_value_tuples(*fact_val_tuples)
+          facts.each do |f|
+            results = fact_val_tuples.each_with_object([]) do |fvt, ary|
+              ary << true if f.dig(*fvt[0].delete_prefix('facts').split('.')) == fvt[1]
+            end
+            return f if results.size == fact_val_tuples.size
+          end
+          nil
+        end
+
+        def find_by_fact_value_tuple(fact_val_tuple)
+          fact_name, fact_val = fact_val_tuple
+          @facts.find { |f| f.dig(*fact_name.delete_prefix('facts').split('.')) == fact_val }
+        end
+
+        def dot_dig(dot_path)
+          result = @facts.map { |f| f.dig(*dot_path.delete_prefix('facts').split('.')) }
+          return nil if result.empty?
+
+          result
+        end
+
+        def dig(*args)
+          result = @facts.map { |f| f.dig(*args) }
+          return nil if result.empty?
+
+          result
+        end
+      end
+
+      class FactSets
+        REQUIRED_FACTERDB_VERSION = '1.21.0'
+
+        def initialize
+          check_facterdb_version
+          @fact_val_tuple_cache = {}
+          @dot_dig_cache = {}
+          @dot_dig_related_cache = {}
+        end
+
+        def fact_sets
+          @fact_sets ||= FacterDB.facterdb_fact_files.each_with_object({}) do |f, h|
+            facter_version = File.basename(File.dirname(f))
+            fact_set = h[facter_version] || FactSet.new(facter_version)
+            fact_set.load_facts(f)
+            h[facter_version] = fact_set unless h.key?(facter_version)
+          end
+        end
 
-          old_ver = current_version.dup
-          use_version(version)
-          output = yield
-          use_version(old_ver) if reset
-          output
+        def fact_set(facter_version)
+          fact_sets[facter_version]
         end
 
-        def fact_files
-          @fact_files ||= FacterDB.facterdb_fact_files.each_with_object({}) do |f, h|
-            facter_version = file_facter_version(f)
-            h[facter_version] = [] unless h.key?(facter_version)
-            h[facter_version] << f
+        def facter_versions
+          @facter_versions ||= fact_sets.keys.sort
+        end
+
+        def find_by_fact_value_tuples(*fact_val_tuples)
+          fact_sets.each do |_, fs|
+            result = fs.find_by_fact_value_tuples(*fact_val_tuples)
+            return result unless result.nil? || result.empty?
+          end
+          nil
+        end
+
+        def find_by_fact_value_tuple(fact_val_tuple)
+          ck = cache_key(*fact_val_tuple)
+          return @fact_val_tuple_cache[ck] if @fact_val_tuple_cache.key?(ck)
+
+          facter_versions.each do |v|
+            result = fact_set(v).find_by_fact_value_tuple(fact_val_tuple)
+            next if result.nil? || result.empty?
+
+            @fact_val_tuple_cache[ck] = result
+            return result
+          end
+
+          @fact_val_tuple_cache[ck] = nil
+        end
+
+        def dot_dig(dot_path, facter_version: latest_version, recurse: true)
+          ck = cache_key(dot_path, facter_version, recurse)
+          return @dot_dig_cache[ck] if @dot_dig_cache.key?(ck)
+
+          result = fact_set(facter_version).dot_dig(dot_path)
+          unless result.nil? && recurse
+            @dot_dig_cache[ck] = result
+            return result
           end
+
+          previous = previous_version(facter_version)
+          unless previous
+            @dot_dig_cache[ck] = result
+            return result
+          end
+
+          result = dot_dig(dot_path, facter_version: previous, recurse: true)
+          @dot_dig_cache[ck] = result
+          result
         end
+        alias resolve_dot_path dot_dig
 
-        def fact_sets(facter_version: current_version)
-          @fact_sets ||= fact_files[facter_version].each_with_object({}) do |fp, h|
-            h[facter_version] = [] unless h.key?(facter_version)
-            h[facter_version] << JSON.parse(File.read(fp))
+        def dot_dig_related(*dot_paths, facter_version: latest_version, recurse: true)
+          ck = cache_key(*dot_paths, facter_version, recurse)
+          return @dot_dig_related_cache[ck] if @dot_dig_related_cache.key?(ck)
+
+          result = []
+          fact_sets[facter_version].facts.map do |f|
+            result << dot_paths.map { |p| f.dig(*p.delete_prefix('facts').split('.')) }
+          end
+          unless recurse
+            @dot_dig_related_cache[ck] = result.compact.uniq
+            return @dot_dig_related_cache[ck]
           end
+
+          previous = previous_version(facter_version)
+          unless previous
+            @dot_dig_related_cache[ck] = result.compact.uniq
+            return @dot_dig_related_cache[ck]
+          end
+
+          res = result + dot_dig_related(*dot_paths, facter_version: previous, recurse: true)
+          @dot_dig_related_cache[ck] = res.compact.uniq
+          @dot_dig_related_cache[ck]
         end
+        alias resolve_related_dot_paths dot_dig_related
 
-        def file_facter_version(path)
-          File.basename(File.dirname(path))
+        private
+
+        def check_facterdb_version
+          require 'facterdb/version'
+          return if Gem::Version.new(FacterDB::Version::STRING) >= Gem::Version.new(REQUIRED_FACTERDB_VERSION)
+
+          warn "FacterDB version #{FacterDB::Version::STRING} is too old. Please upgrade to 1.21.0 or later."
+          warn 'FacterUtils may not work correctly or at all.'
+        end
+
+        def cache_key(*args)
+          args.map(&:to_s).join('_')
+        end
+
+        def latest_version
+          facter_versions.last
+        end
+
+        def previous_version(facter_version)
+          index = facter_versions.index(facter_version)
+          return unless index&.positive?
+
+          facter_versions[index - 1]
+        end
+      end
+
+      class << self
+        # attr_writer :current_version
+
+        # def current_version
+        #   return latest_version unless defined?(@current_version)
+
+        #   @current_version
+        # end
+
+        # def use_version(version)
+        #   self.current_version = version
+        #   current_version
+        # end
+
+        # def with_version(version, reset: true)
+        #   return unless block_given?
+
+        #   old_ver = current_version.dup
+        #   use_version(version)
+        #   output = yield
+        #   use_version(old_ver) if reset
+        #   output
+        # end
+
+        # def fact_files
+        #   FacterDB.facterdb_fact_files.each_with_object({}) do |f, h|
+        #     facter_version = file_facter_version(f)
+        #     h[facter_version] = [] unless h.key?(facter_version)
+        #     h[facter_version] << f
+        #   end
+        # end
+
+        # def fact_sets(facter_version: current_version)
+        #   fact_files[facter_version].each_with_object({}) do |fp, h|
+        #     h[facter_version] = [] unless h.key?(facter_version)
+        #     h[facter_version] << JSON.parse(File.read(fp))
+        #   end
+        # end
+
+        # def file_facter_version(path)
+        #   File.basename(File.dirname(path))
+        # end
+
+        # def all_versions
+        #   fact_files.keys.sort
+        # end
+
+        # def latest_version
+        #   all_versions[-1]
+        # end
+
+        def fact_sets
+          @fact_sets ||= FacterDB.facterdb_fact_files.each_with_object([]) do |f, ary|
+            facter_version = File.basename(File.dirname(f))
+            fact_set = ary.find { |fs| fs.facter_version == facter_version }
+            fact_set ||= FactSet.new(facter_version)
+            fact_set.load_facts(f)
+            ary << fact_set unless ary.include?(fact_set)
+          end
         end
 
         def all_versions
-          @all_versions ||= fact_files.keys.sort
+          @all_versions ||= fact_sets.sort.map(&:facter_version)
         end
 
         def latest_version
-          @latest_version ||= all_versions[-1]
+          @latest_version ||= all_versions.last
         end
 
-        def previous_major_version(facter_version = current_version)
-          @previous_major_version_map ||= {}
+        def with_version(version)
+          return unless block_given?
 
-          majver = facter_version.split('.')[0]
-          return @previous_major_version_map[majver] if @previous_major_version_map.key?(majver)
+          fact_set = fact_sets.find { |fs| fs.facter_version == version }
+          raise "No facts found for version #{version}" unless fact_set
+
+          yield fact_set
+        end
 
+        def previous_major_version(facter_version = latest_version)
+          majver = facter_version.split('.')[0]
           prev_majver = (majver.to_i - 1).to_s
           prev_ver = all_versions.select { |v| v.start_with?(prev_majver) }.max
           return nil if prev_ver.to_i < 1
 
-          @previous_major_version_map[majver] = prev_ver
-          @previous_major_version_map[majver]
+          prev_ver
         end
 
-        def recurse_versions(version = current_version, &block)
-          use_version(version)
-          output = yield
+        def previous_version(facter_version = latest_version)
+          reversed = all_versions.reverse
+          rev_index = reversed.index(facter_version)
+          return nil if rev_index.nil? || rev_index == reversed.length - 1
+
+          reversed[reversed.index(facter_version) + 1]
+        end
+
+        def recurse_versions(version = latest_version, &block)
+          output = yield version
           return output unless output.nil? || output.empty?
 
-          prev_ver = previous_major_version(version).dup
+          prev_ver = previous_version(version).dup
           return nil if prev_ver.nil?
 
           recurse_versions(prev_ver, &block)
@@ -89,47 +288,49 @@ module AbideDevUtils
           raise "Failed to find output while recursing versions. Locals: #{locals}"
         end
 
-        def recursive_facts_for_os(os_name, os_release_major = nil, os_hardware: 'x86_64')
-          saved_ver = current_version.dup
-          output = recurse_versions do
-            facts_for_os(os_name, os_release_major, os_hardware: os_hardware)
+        def recursive_facts_for_os(os_name, os_release_major = nil, facter_version: latest_version)
+          recurse_versions(facter_version) do |ver|
+            facts_for_os(os_name, os_release_major, facter_version: ver)
           end
-          use_version(saved_ver)
-          output
         end
 
-        def facts_for_os(os_name, os_release_major = nil, os_hardware: 'x86_64', facter_version: current_version)
-          cache_key = "#{os_name.downcase}_#{os_release_major}_#{os_hardware}"
-          return @facts_for_os[cache_key] if @facts_for_os&.key?(cache_key)
-
-          fact_file = fact_files[facter_version].find do |f|
-            name_parts = File.basename(f, '.facts').split('-')
-            name = name_parts[0]
-            relmaj = name_parts.length >= 3 ? name_parts[1] : nil
-            hardware = name_parts[-1]
-            name == os_name.downcase && relmaj == os_release_major && hardware == os_hardware
-          end
-          return if fact_file.nil? || fact_file.empty?
-
-          @facts_for_os = {} unless defined?(@facts_for_os)
-          @facts_for_os[cache_key] = JSON.parse(File.read(fact_file))
-          @facts_for_os[cache_key]
-        end
+        # def facts_for_os(os_name, os_release_major = nil, facter_version: latest_version)
+        #   fact_sets..find do |f|
+        #     f['os']['name'] == os_name && f['os']['release']['major'] == os_release_major.to_s
+        #   end
+        # end
 
-        def resolve_dot_path(dot_path, facter_version: latest_version)
+        def resolve_dot_path(dot_path, facter_version: latest_version, strict: false)
           path_array = dot_path.delete_prefix('facts.').split('.')
-          resolved = fact_sets[facter_version].map do |fs|
-            fs.dig(*path_array)
-          end
-          resolved.compact.uniq
+          resolved = if strict
+                       fact_sets[facter_version].map do |fs|
+                         fs.dig(*path_array)
+                       end
+                     else
+                       recurse_versions(facter_version) do |ver|
+                         fact_sets[ver].map { |fs| fs.dig(*path_array) }
+                       end
+                     end
+          resolved&.compact&.uniq
         end
 
-        def resolve_related_dot_paths(*dot_paths, facter_version: current_version)
+        def resolve_related_dot_paths(*dot_paths, facter_version: latest_version, strict: false)
           resolved = []
-          fact_sets[facter_version].map do |fs|
-            resolved << dot_paths.map do |p|
-              path_array = p.delete_prefix('facts.').split('.')
-              fs.dig(*path_array)
+          if strict
+            fact_sets[facter_version].map do |fs|
+              resolved << dot_paths.map do |p|
+                path_array = p.delete_prefix('facts.').split('.')
+                fs.dig(*path_array)
+              end
+            end
+          else
+            recurse_versions(facter_version) do |ver|
+              fact_sets[ver].map do |fs|
+                resolved << dot_paths.map do |p|
+                  path_array = p.delete_prefix('facts.').split('.')
+                  fs.dig(*path_array)
+                end
+              end
             end
           end
           resolved

data/lib/abide_dev_utils/ppt/hiera.rb

@@ -10,7 +10,7 @@ module AbideDevUtils
     module Hiera
       INTERP_PATTERN = /%{([^{}]+)}/.freeze
       FACT_PATTERN = /%{facts\.([^{}]+)}/.freeze
-      DEFAULT_FACTER_VERSION = '3.14'
+      DEFAULT_FACTER_VERSION = '4.2'
       DEFAULT_CONFIG_FILE = 'hiera.yaml'
 
       def self.facter_version=(version)
@@ -18,7 +18,7 @@ module AbideDevUtils
       end
 
       def self.facter_version
-        @facter_version
+        @facter_version ||= AbideDevUtils::Ppt::FacterUtils.latest_version
       end
 
       def self.default_datadir=(dir)
@@ -41,7 +41,7 @@ module AbideDevUtils
           @root_dir = File.dirname(@path)
           @conf = YAML.load_file(File.expand_path(path))
           @by_name_path_store = {}
-          AbideDevUtils::Ppt::Hiera.facter_version = facter_version
+          #AbideDevUtils::Ppt::Hiera.facter_version = facter_version
           if @conf['defaults'].key?('datadir')
             AbideDevUtils::Ppt::Hiera.default_datadir = File.join(@root_dir, @conf['defaults']['datadir'])
           end
@@ -166,6 +166,7 @@ module AbideDevUtils
 
         def initialize(path)
           @path = path
+          @fact_sets = AbideDevUtils::Ppt::FacterUtils::FactSets.new
         end
 
         def path_parts
@@ -189,7 +190,7 @@ module AbideDevUtils
         end
 
         def possible_fact_values
-          @possible_fact_values ||= AbideDevUtils::Ppt::FacterUtils.resolve_related_dot_paths(*facts)
+          @possible_fact_values ||= @fact_sets.resolve_related_dot_paths(*facts)
         end
 
         def local_files

data/lib/abide_dev_utils/ppt/strings.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'puppet-strings'
+require 'puppet-strings/yard'
+
+module AbideDevUtils
+  module Ppt
+    # Puppet Strings reference object
+    class Strings
+      REGISTRY_TYPES = %i[
+        root
+        module
+        class
+        puppet_class
+        puppet_data_type
+        puppet_data_type_alias
+        puppet_defined_type
+        puppet_type
+        puppet_provider
+        puppet_function
+        puppet_task
+        puppet_plan
+      ].freeze
+
+      attr_reader :search_patterns
+
+      def initialize(search_patterns: nil, **opts)
+        check_yardoc_dir
+        @search_patterns = search_patterns || PuppetStrings::DEFAULT_SEARCH_PATTERNS
+        @debug = opts[:debug]
+        @quiet = opts[:quiet]
+        PuppetStrings::Yard.setup!
+        YARD::CLI::Yardoc.run(*yard_args(@search_patterns, debug: @debug, quiet: @quiet))
+      end
+
+      def debug?
+        !!@debug
+      end
+
+      def quiet?
+        !!@quiet
+      end
+
+      def registry
+        @registry ||= YARD::Registry.all(*REGISTRY_TYPES).map { |i| YardObjectWrapper.new(i) }
+      end
+
+      def find_resource(resource_name)
+        to_h.each do |_, resources|
+          res = resources.find { |r| r[:name] == resource_name.to_sym }
+          return res if res
+        end
+      end
+
+      def puppet_classes(hashed: false)
+        reg_type(:puppet_class, hashed: hashed)
+      end
+
+      def data_types(hashed: false)
+        reg_type(:puppet_data_types, hashed: hashed)
+      end
+      alias puppet_data_type data_types
+
+      def data_type_aliases(hashed: false)
+        reg_type(:puppet_data_type_alias, hashed: hashed)
+      end
+      alias puppet_data_type_alias data_type_aliases
+
+      def defined_types(hashed: false)
+        reg_type(:puppet_defined_type, hashed: hashed)
+      end
+      alias puppet_defined_type defined_types
+
+      def resource_types(hashed: false)
+        reg_type(:puppet_type, hashed: hashed)
+      end
+      alias puppet_type resource_types
+
+      def providers(hashed: false)
+        reg_type(:puppet_provider, hashed: hashed)
+      end
+      alias puppet_provider providers
+
+      def puppet_functions(hashed: false)
+        reg_type(:puppet_function, hashed: hashed)
+      end
+      alias puppet_function puppet_functions
+
+      def puppet_tasks(hashed: false)
+        reg_type(:puppet_task, hashed: hashed)
+      end
+      alias puppet_task puppet_tasks
+
+      def puppet_plans(hashed: false)
+        reg_type(:puppet_plan, hashed: hashed)
+      end
+      alias puppet_plan puppet_plans
+
+      def to_h
+        {
+          puppet_classes: puppet_classes,
+          data_types: data_types,
+          data_type_aliases: data_type_aliases,
+          defined_types: defined_types,
+          resource_types: resource_types,
+          providers: providers,
+          puppet_functions: puppet_functions,
+          puppet_tasks: puppet_tasks,
+          puppet_plans: puppet_plans,
+        }
+      end
+
+      private
+
+      def check_yardoc_dir
+        yardoc_dir = File.expand_path('./.yardoc')
+        return unless Dir.exist?(yardoc_dir) && !File.writable?(yardoc_dir)
+
+        raise "yardoc directory permissions error. Ensure #{yardoc_dir} is writable by current user."
+      end
+
+      def reg_type(reg_type, hashed: false)
+        hashed ? hashes_for_reg_type(reg_type) : select_by_reg_type(reg_type)
+      end
+
+      def select_by_reg_type(reg_type)
+        registry.select { |i| i.type == reg_type }
+      end
+
+      def hashes_for_reg_type(reg_type)
+        all_to_h(select_by_reg_type(reg_type))
+      end
+
+      def all_to_h(objects)
+        objects.sort_by(&:name).map(&:to_hash)
+      end
+
+      def yard_args(patterns, debug: false, quiet: false)
+        args = ['doc', '--no-progress', '-n']
+        args << '--debug' if debug && !quiet
+        args << '--backtrace' if debug && !quiet
+        args << '-q' if quiet
+        args << '--no-stats' if quiet
+        args += patterns
+        args
+      end
+    end
+
+    # Wrapper class for Yard objects that allows associating things like validators with them
+    class YardObjectWrapper
+      attr_accessor :validator
+      attr_reader :object
+
+      def initialize(object, validator: nil)
+        @object = object
+        @validator = validator
+      end
+
+      def method_missing(method, *args, &block)
+        if object.respond_to?(method)
+          object.send(method, *args, &block)
+        elsif validator.respond_to?(method)
+          validator.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        object.respond_to?(method) || validator.respond_to?(method) || super
+      end
+
+      def to_hash
+        object.to_hash
+      end
+      alias to_h to_hash
+
+      def to_s
+        object.to_s
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'abide_dev_utils/output'
-require 'abide_dev_utils/validate'
-require 'abide_dev_utils/errors'
-require 'abide_dev_utils/ppt/api'
-require 'abide_dev_utils/ppt/code_gen'
-require 'abide_dev_utils/ppt/code_introspection'
-require 'abide_dev_utils/ppt/class_utils'
-require 'abide_dev_utils/ppt/facter_utils'
-require 'abide_dev_utils/ppt/hiera'
-require 'abide_dev_utils/ppt/puppet_module'
+require_relative 'output'
+require_relative 'validate'
+require_relative 'errors'
+require_relative 'ppt/api'
+require_relative 'ppt/code_gen'
+require_relative 'ppt/code_introspection'
+require_relative 'ppt/class_utils'
+require_relative 'ppt/facter_utils'
+require_relative 'ppt/hiera'
+require_relative 'ppt/puppet_module'
 
 module AbideDevUtils
   module Ppt