abide_dev_utils 0.9.7 → 0.11.0

data/lib/abide_dev_utils/files.rb

@@ -1,7 +1,41 @@
 # frozen_string_literal: true
 
+require 'abide_dev_utils/validate'
+
 module AbideDevUtils
   module Files
+    class Reader
+      def self.read(path, raw: false, safe: true, opts: {})
+        AbideDevUtils::Validate.file(path)
+        return File.read(path) if raw
+
+        extension = File.extname(path)
+        case extension
+        when /\.yaml|\.yml/
+          require 'yaml'
+          if safe
+            YAML.safe_load(File.read(path))
+          else
+            YAML.load_file(path)
+          end
+        when '.json'
+          require 'json'
+          return JSON.parse(File.read(path), opts) if safe
+
+          JSON.parse!(File.read(path), opts)
+        when '.xml'
+          require 'nokogiri'
+          File.open(path, 'r') do |file|
+            Nokogiri::XML.parse(file) do |config|
+              config.strict.noblanks.norecover
+            end
+          end
+        else
+          File.read(path)
+        end
+      end
+    end
+
     class Writer
       MSG_EXT_APPEND = 'Appending %s extension to file'
 

data/lib/abide_dev_utils/markdown.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module AbideDevUtils
+  # Formats text for output in markdown
+  class Markdown
+    def initialize(file, with_toc: true)
+      @file = file
+      @with_toc = with_toc
+      @toc = ["## Table of Contents\n"]
+      @body = []
+      @title = nil
+    end
+
+    def to_markdown
+      toc = @toc.join("\n")
+      body = @body.join("\n")
+      "#{@title}\n#{toc}\n\n#{body}"
+    end
+
+    def to_file
+      File.write(@file, to_markdown)
+    end
+
+    def method_missing(name, *args, &block)
+      if name.to_s.start_with?('add_')
+        add(name.to_s.sub('add_', '').to_sym, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name.to_s.start_with?('add_') || super
+    end
+
+    def title(text)
+      "# #{text}\n"
+    end
+
+    def h1(text)
+      "## #{text}\n"
+    end
+
+    def h2(text)
+      "### #{text}\n"
+    end
+
+    def h3(text)
+      "#### #{text}\n"
+    end
+
+    def ul(text, indent: 0)
+      indented_text = []
+      indent.times { indented_text << '  ' } if indent.positive?
+
+      indented_text << "* #{text}"
+      indented_text.join
+    end
+
+    def bold(text)
+      "**#{text}**"
+    end
+
+    def italic(text)
+      "*#{text}*"
+    end
+
+    def link(text, url, anchor: false)
+      url = anchor(url) if anchor
+      "[#{text}](#{url.downcase})"
+    end
+
+    def code(text)
+      "\`#{text}\`"
+    end
+
+    def code_block(text, language: nil)
+      language.nil? ? "```\n#{text}\n```" : "```#{language}\n#{text}\n```"
+    end
+
+    def anchor(text)
+      "##{text.downcase.gsub(%r{\s|_}, '-').tr('.,\'"()', '')}"
+    end
+
+    private
+
+    def add(type, text, *args, **kwargs)
+      @toc << ul(link(text, text, anchor: true), indent: 0) if @with_toc && type == :h1
+
+      case type.to_sym
+      when :title
+        @title = title(text)
+      when :ul
+        @body << ul(text, indent: kwargs.fetch(:indent, 0))
+      when :link
+        @body << link(text, args.first, anchor: kwargs.fetch(:anchor, false))
+      when :code_block
+        @body << code_block(text, language: kwargs.fetch(:language, nil))
+      else
+        @body << send(type, text)
+      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,297 @@
+# 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)
+
+          @conf = YAML.load_file(File.expand_path(path))
+          @by_name_path_store = {}
+          AbideDevUtils::Ppt::Hiera.default_datadir = @conf['defaults']['datadir'] if @conf['defaults'].key?('datadir')
+          AbideDevUtils::Ppt::Hiera.facter_version = facter_version
+        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,74 @@
+# 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',
+        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
+      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

@@ -4,6 +4,9 @@ require 'abide_dev_utils/output'
 require 'abide_dev_utils/validate'
 require 'abide_dev_utils/errors'
 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 +66,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