abide_dev_utils 0.10.1 → 0.11.2

data/lib/abide_dev_utils/ppt/code_gen/resource_types.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/ppt/code_gen/resource_types/class'
+require 'abide_dev_utils/ppt/code_gen/resource_types/manifest'
+require 'abide_dev_utils/ppt/code_gen/resource_types/parameter'
+require 'abide_dev_utils/ppt/code_gen/resource_types/strings'

data/lib/abide_dev_utils/ppt/code_gen.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/ppt/code_gen/data_types'
+require 'abide_dev_utils/ppt/code_gen/resource'
+require 'abide_dev_utils/ppt/code_gen/resource_types'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      def self.generate_a_manifest
+        Manifest.new
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt/code_introspection.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'puppet_pal'
+require_relative 'code_gen/data_types'
+
+module AbideDevUtils
+  module Ppt
+    module CodeIntrospection
+      class Manifest
+        attr_reader :manifest_file
+
+        def initialize(manifest_file)
+          @manifest_file = File.expand_path(manifest_file)
+          raise ArgumentError, "File #{@manifest_file} is not a file" unless File.file?(@manifest_file)
+        end
+
+        def ast
+          @ast ||= Puppet::Pal::Compiler.new(nil).parse_file(manifest_file)
+        end
+
+        def declaration
+          @declaration ||= Declaration.new(ast)
+        end
+      end
+
+      class Declaration
+        include AbideDevUtils::Ppt::CodeGen::DataTypes
+        attr_reader :ast
+
+        def initialize(ast)
+          @ast = ast.definitions.first
+        end
+
+        def parameters?
+          ast.respond_to? :parameters
+        end
+
+        def parameters
+          return unless parameters?
+
+          @parameters ||= ast.parameters.map { |p| Parameter.new(p) }
+        end
+      end
+
+      class Parameter
+        include AbideDevUtils::Ppt::CodeGen::DataTypes
+        attr_reader :ast
+
+        def initialize(param_ast)
+          @ast = param_ast
+        end
+
+        def to_a(raw: false)
+          [type_expr(raw: raw), name(raw: raw), value(raw: raw)]
+        end
+
+        def to_h(raw: false)
+          {
+            type_expr: type_expr(raw: raw),
+            name: name(raw: raw),
+            value: value(raw: raw),
+          }
+        end
+
+        def to_s(raw: false)
+          stra = [type_expr(raw: raw), name(raw: raw)]
+          stra << '=' if value? && !raw
+          stra << value(raw: raw)
+          stra.compact.join(' ')
+        end
+
+        def name(raw: false)
+          return ast.name if raw
+
+          "$#{ast.name}"
+        end
+
+        def value?
+          ast.respond_to? :value
+        end
+
+        def value(raw: false)
+          return unless value?
+          return ast.value if raw
+
+          display_value(ast)
+        end
+
+        def type_expr?
+          ast.respond_to? :type_expr
+        end
+
+        def type_expr(raw: false)
+          return unless type_expr?
+          return ast.type_expr if raw
+
+          display_type_expr(ast)
+        end
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt/facter_utils.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'facterdb'
+
+module AbideDevUtils
+  module Ppt
+    # Methods relating to Facter
+    module FacterUtils
+      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
+          @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_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))
+          end
+        end
+
+        def file_facter_version(path)
+          File.basename(File.dirname(path))
+        end
+
+        def all_versions
+          @all_versions ||= fact_files.keys.sort
+        end
+
+        def latest_version
+          @latest_version ||= all_versions[-1]
+        end
+
+        def previous_major_version(facter_version = current_version)
+          @previous_major_version_map ||= {}
+
+          majver = facter_version.split('.')[0]
+          return @previous_major_version_map[majver] if @previous_major_version_map.key?(majver)
+
+          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]
+        end
+
+        def recurse_versions(version = current_version, &block)
+          use_version(version)
+          output = yield
+          return output unless output.nil? || output.empty?
+
+          prev_ver = previous_major_version(version).dup
+          return nil if prev_ver.nil?
+
+          recurse_versions(prev_ver, &block)
+        rescue SystemStackError
+          locals = {
+            prev_ver_map: @previous_major_version_map,
+            current_version: current_version,
+          }
+          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)
+          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 resolve_dot_path(dot_path, facter_version: latest_version)
+          path_array = dot_path.delete_prefix('facts.').split('.')
+          resolved = fact_sets[facter_version].map do |fs|
+            fs.dig(*path_array)
+          end
+          resolved.compact.uniq
+        end
+
+        def resolve_related_dot_paths(*dot_paths, facter_version: current_version)
+          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)
+            end
+          end
+          resolved
+        end
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt/hiera.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'abide_dev_utils/validate'
+require 'abide_dev_utils/ppt/facter_utils'
+
+module AbideDevUtils
+  module Ppt
+    # Module for working with Hiera
+    module Hiera
+      INTERP_PATTERN = /%{([^{}]+)}/.freeze
+      FACT_PATTERN = /%{facts\.([^{}]+)}/.freeze
+      DEFAULT_FACTER_VERSION = '3.14'
+      DEFAULT_CONFIG_FILE = 'hiera.yaml'
+
+      def self.facter_version=(version)
+        @facter_version = AbideDevUtils::Ppt::FacterUtils.use_version(version.to_s)
+      end
+
+      def self.facter_version
+        @facter_version
+      end
+
+      def self.default_datadir=(dir)
+        edir = File.expand_path(dir)
+        raise "Dir #{edir} not found" unless File.directory?(edir)
+
+        @default_datadir = edir
+      end
+
+      def self.default_datadir
+        @default_datadir
+      end
+
+      # Represents a Hiera configuration file
+      class Config
+        def initialize(path = DEFAULT_CONFIG_FILE, facter_version: DEFAULT_FACTER_VERSION)
+          @path = File.expand_path(path)
+          raise "Hiera config file at path #{@path} not found!" unless File.file?(@path)
+
+          @root_dir = File.dirname(@path)
+          @conf = YAML.load_file(File.expand_path(path))
+          @by_name_path_store = {}
+          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
+        end
+
+        def hierarchy
+          @hierarchy ||= Hierarchy.new(@conf['hierarchy'], AbideDevUtils::Ppt::Hiera.default_datadir)
+        end
+
+        def version
+          @version ||= @conf['version']
+        end
+
+        def defaults
+          @defaults ||= @conf['defaults']
+        end
+
+        def default_datadir
+          AbideDevUtils::Ppt::Hiera.default_datadir
+        end
+
+        def default_data_hash
+          @default_data_hash ||= defaults['data_hash']
+        end
+
+        def local_hiera_files(hierarchy_name: nil)
+          if hierarchy_name
+            hierarchy.entry_by_name(hierarchy_name).local_files
+          else
+            hierarchy.entries.map(&:local_files).flatten
+          end
+        end
+
+        def local_hiera_files_with_fact(fact_str, value = nil, hierarchy_name: nil)
+          if hierarchy_name
+            hierarchy.entry_by_name(hierarchy_name).local_files_with_fact(fact_str, value)
+          else
+            hierarchy.entries.map { |e| e.local_files_with_fact(fact_str, value) }.flatten
+          end
+        end
+
+        def local_hiera_files_with_facts(*fact_arrays, hierarchy_name: nil)
+          if hierarchy_name
+            hierarchy.entry_by_name(hierarchy_name).local_files_with_facts(*fact_arrays)
+          else
+            hierarchy.entries.map { |e| e.local_files_with_fact(*fact_arrays) }.flatten
+          end
+        end
+      end
+
+      # Represents the "hierarchy" section of the Hiera config
+      class Hierarchy
+        attr_reader :default_datadir, :entries
+
+        def initialize(hierarchy, default_datadir)
+          @hierarchy = hierarchy
+          @default_datadir = File.expand_path(default_datadir)
+          @entries = @hierarchy.map { |h| HierarchyEntry.new(h) }
+          @by_name_store = {}
+          @paths_by_name_store = {}
+        end
+
+        def method_missing(m, *args, &block)
+          if %i[each each_with_object each_with_index select reject map].include?(m)
+            @entries.send(m, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(m, include_private = false)
+          %i[each each_with_object each_with_index select reject map].include?(m) || super
+        end
+
+        def entry_by_name(name)
+          AbideDevUtils::Validate.populated_string(name)
+          return @by_name_store[name] if @by_name_store[name]
+
+          found = @entries.select { |x| x.name == name }
+          AbideDevUtils::Validate.not_empty(found, "Hierarchy entry for name '#{name}' not found")
+          @by_name_store[name] = found[0]
+          @by_name_store[name]
+        end
+      end
+
+      # Represents a single entry in the hierarchy
+      class HierarchyEntry
+        attr_reader :entry, :name, :paths
+
+        def initialize(entry)
+          @entry = entry
+          @name = @entry['name']
+          @paths = @entry.key?('path') ? create_paths(@entry['path']) : create_paths(*@entry['paths'])
+        end
+
+        def local_files
+          @local_files ||= paths.map(&:local_files).flatten
+        end
+
+        def local_files_with_fact(fact_str, value = nil)
+          paths.map { |p| p.local_files_with_fact(fact_str, value) }.flatten
+        end
+
+        def local_files_with_facts(*fact_arrays)
+          paths.map { |p| p.local_files_with_facts(*fact_arrays) }.flatten
+        end
+
+        def to_s
+          name
+        end
+
+        private
+
+        def create_paths(*paths)
+          paths.map { |p| HierarchyEntryPath.new(p) }
+        end
+      end
+
+      # Represents a Hiera entry path
+      class HierarchyEntryPath
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def path_parts
+          @path_parts ||= path.split('/')
+        end
+
+        def interpolation
+          @interpolation ||= path.scan(INTERP_PATTERN).flatten
+        end
+
+        def interpolation?
+          !interpolation.empty?
+        end
+
+        def facts
+          @facts ||= path.scan(FACT_PATTERN).flatten
+        end
+
+        def facts?
+          !facts.empty?
+        end
+
+        def possible_fact_values
+          @possible_fact_values ||= AbideDevUtils::Ppt::FacterUtils.resolve_related_dot_paths(*facts)
+        end
+
+        def local_files
+          @local_files ||= find_local_files.flatten
+        end
+
+        def local_files_with_fact(fact_str, value = nil)
+          local_files.select do |lf|
+            # The match below is case-insentive for convenience
+            (value.nil? ? lf.fact_values.key?(fact_str) : (lf.fact_values[fact_str]&.match?(/#{value}/i) || false))
+          end
+        end
+
+        def local_files_with_facts(*fact_arrays)
+          return local_files_with_fact(*fact_arrays[0]) if fact_arrays.length == 1
+
+          start_fact = fact_arrays[0][0]
+          last_fact = nil
+          memo = {}
+          with_facts = []
+          fact_arrays.each do |fa|
+            cur_fact = fa[0]
+            memo[cur_fact] = local_files_with_fact(*fa)
+            if cur_fact == start_fact
+              with_facts = memo[cur_fact]
+            else
+              last_paths = memo[last_fact].map(&:path)
+              cur_paths = memo[cur_fact].map(&:path)
+              with_facts.reject! { |x| last_paths.difference(cur_paths).include?(x.path) }
+            end
+            last_fact = cur_fact
+          end
+          with_facts.flatten.uniq(&:path)
+        end
+
+        def to_s
+          path
+        end
+
+        private
+
+        def find_local_files
+          new_paths = []
+          possible_fact_values.each do |pfv|
+            new_path = path.dup
+            pfv.each do |v|
+              next unless v
+
+              new_path.sub!(FACT_PATTERN, v)
+            end
+            new_paths << EntryPathLocalFile.new(new_path, facts, possible_fact_values)
+          end
+          new_paths.uniq(&:path).select(&:exist?)
+        end
+      end
+
+      # Represents a local file derived from a Hiera path
+      class EntryPathLocalFile
+        attr_reader :path, :facts
+
+        def initialize(path, facts, possible_fact_values)
+          @path = File.expand_path(File.join(AbideDevUtils::Ppt::Hiera.default_datadir, path))
+          @facts = facts
+          @possible_fact_values = possible_fact_values
+        end
+
+        def fact_values
+          @fact_values ||= fact_values_for_path
+        end
+
+        def path_parts
+          @path_parts ||= path.split('/')
+        end
+
+        def exist?
+          File.file?(path)
+        end
+
+        def to_s
+          path
+        end
+
+        def to_h
+          {
+            path: path,
+            facts: facts
+          }
+        end
+
+        private
+
+        def fact_values_for_path
+          no_fext_path_parts = path_parts.map { |part| File.basename(part, '.yaml') }
+          valid_fact_values = @possible_fact_values.select do |pfv|
+            pfv.all? { |v| no_fext_path_parts.include?(v) }
+          end
+          valid_fact_values.uniq! # Removes duplicate arrays, not duplicate fact values
+          valid_fact_values.flatten!
+          return {} if valid_fact_values.empty?
+
+          fact_vals = {}
+          facts.each_index { |idx| fact_vals[facts[idx]] = valid_fact_values[idx] }
+          fact_vals
+        end
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt/puppet_module.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+require 'abide_dev_utils/validate'
+require 'abide_dev_utils/ppt/hiera'
+
+module AbideDevUtils
+  module Ppt
+    # Class for working with Puppet Modules
+    class PuppetModule
+      DEF_FILES = {
+        metadata: 'metadata.json',
+        readme: 'README.md',
+        reference: 'REFERENCE.md',
+        changelog: 'CHANGELOG.md',
+        hiera_config: 'hiera.yaml',
+        fixtures: '.fixtures.yml',
+        rubocop: '.rubocop.yml',
+        sync: '.sync.yml',
+        pdkignore: '.pdkignore',
+        gitignore: '.gitignore'
+      }.freeze
+
+      attr_reader :directory, :special_files
+
+      def initialize(directory = Dir.pwd)
+        AbideDevUtils::Validate.directory(directory)
+        @directory = directory
+        @special_files = DEF_FILES.dup.transform_values { |v| File.expand_path(File.join(@directory, v)) }
+      end
+
+      def name(strip_namespace: false)
+        strip_namespace ? metadata['name'].split('-')[-1] : metadata['name']
+      end
+
+      def metadata
+        @metadata ||= JSON.parse(File.read(special_files[:metadata]))
+      end
+
+      def supported_os
+        @supported_os ||= find_supported_os
+      end
+
+      def hiera_conf
+        @hiera_conf ||= AbideDevUtils::Ppt::Hiera::Config.new(special_files[:hiera_config])
+      end
+
+      private
+
+      def find_supported_os
+        return [] unless metadata['operatingsystem_support']
+
+        metadata['operatingsystem_support'].each_with_object([]) do |os, arr|
+          os['operatingsystemrelease'].each do |r|
+            arr << "#{os['operatingsystem']}::#{r}"
+          end
+        end
+      end
+
+      def in_dir
+        return unless block_given?
+
+        current = Dir.pwd
+        if current == File.expand_path(directory)
+          yield
+        else
+          Dir.chdir(directory)
+          yield
+          Dir.chdir(current)
+        end
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt.rb

@@ -3,7 +3,13 @@
 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'
 
 module AbideDevUtils
   module Ppt
@@ -63,11 +69,6 @@ module AbideDevUtils
       AbideDevUtils::Output.simple('Successfully fixed all classes.')
     end
 
-    def self.generate_coverage_report(puppet_class_dir, hiera_path, profile = nil)
-      require 'abide_dev_utils/ppt/coverage'
-      CoverageReport.generate(puppet_class_dir, hiera_path, profile)
-    end
-
     def self.build_new_object(type, name, opts)
       require 'abide_dev_utils/ppt/new_obj'
       AbideDevUtils::Ppt::NewObjectBuilder.new(

data/lib/abide_dev_utils/validate.rb

@@ -3,7 +3,12 @@
 require 'abide_dev_utils/errors'
 
 module AbideDevUtils
+  # Methods used for validating data
   module Validate
+    def self.puppet_module_directory(path = Dir.pwd)
+      raise AbideDevUtils::Errors::Ppt::NotModuleDirError, path unless File.file?(File.join(path, 'metadata.json'))
+    end
+
     def self.filesystem_path(path)
       raise AbideDevUtils::Errors::FileNotFoundError, path unless File.exist?(path)
     end
@@ -22,6 +27,15 @@ module AbideDevUtils
       raise AbideDevUtils::Errors::PathNotDirectoryError, path unless File.directory?(path)
     end
 
+    def self.populated_string(thing)
+      raise AbideDevUtils::Errors::NotPopulatedStringError, 'Object is nil' if thing.nil?
+
+      unless thing.instance_of?(String)
+        raise AbideDevUtils::Errors::NotPopulatedStringError, "Object is not a String. Type: #{thing.class}"
+      end
+      raise AbideDevUtils::Errors::NotPopulatedStringError, 'String is empty' if thing.empty?
+    end
+
     def self.not_empty(thing, msg)
       raise AbideDevUtils::Errors::ObjectEmptyError, msg if thing.empty?
     end

data/lib/abide_dev_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AbideDevUtils
-  VERSION = "0.10.1"
+  VERSION = "0.11.2"
 end