abide_dev_utils 0.10.1 → 0.11.0

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

data/lib/abide_dev_utils/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abide_dev_utils
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - abide-team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-02 00:00:00.000000000 Z
+date: 2022-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: facterdb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.18'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -345,6 +359,11 @@ files:
 - exe/abide
 - lib/abide_dev_utils.rb
 - lib/abide_dev_utils/cem.rb
+- lib/abide_dev_utils/cem/benchmark.rb
+- lib/abide_dev_utils/cem/coverage_report.rb
+- lib/abide_dev_utils/cem/generate.rb
+- lib/abide_dev_utils/cem/generate/reference.rb
+- lib/abide_dev_utils/cem/mapping/mapper.rb
 - lib/abide_dev_utils/cli.rb
 - lib/abide_dev_utils/cli/abstract.rb
 - lib/abide_dev_utils/cli/cem.rb
@@ -358,6 +377,7 @@ files:
 - lib/abide_dev_utils/constants.rb
 - lib/abide_dev_utils/errors.rb
 - lib/abide_dev_utils/errors/base.rb
+- lib/abide_dev_utils/errors/cem.rb
 - lib/abide_dev_utils/errors/comply.rb
 - lib/abide_dev_utils/errors/gcloud.rb
 - lib/abide_dev_utils/errors/general.rb
@@ -367,13 +387,16 @@ files:
 - lib/abide_dev_utils/files.rb
 - lib/abide_dev_utils/gcloud.rb
 - lib/abide_dev_utils/jira.rb
+- lib/abide_dev_utils/markdown.rb
 - lib/abide_dev_utils/mixins.rb
 - lib/abide_dev_utils/output.rb
 - lib/abide_dev_utils/ppt.rb
 - lib/abide_dev_utils/ppt/api.rb
 - lib/abide_dev_utils/ppt/class_utils.rb
-- lib/abide_dev_utils/ppt/coverage.rb
+- lib/abide_dev_utils/ppt/facter_utils.rb
+- lib/abide_dev_utils/ppt/hiera.rb
 - lib/abide_dev_utils/ppt/new_obj.rb
+- lib/abide_dev_utils/ppt/puppet_module.rb
 - lib/abide_dev_utils/ppt/score_module.rb
 - lib/abide_dev_utils/prompt.rb
 - lib/abide_dev_utils/resources/generic_spec.erb

data/lib/abide_dev_utils/ppt/coverage.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'pathname'
-require 'yaml'
-require 'puppet_pal'
-require 'abide_dev_utils/ppt/class_utils'
-
-module AbideDevUtils
-  module Ppt
-    class CoverageReport
-      def self.generate(puppet_class_dir, hiera_path, profile = nil)
-        coverage = {}
-        coverage['classes'] = {}
-        all_cap = ClassUtils.find_all_classes_and_paths(puppet_class_dir)
-        invalid_classes = find_invalid_classes(all_cap)
-        valid_classes = find_valid_classes(all_cap, invalid_classes)
-        coverage['classes']['invalid'] = invalid_classes
-        coverage['classes']['valid'] = valid_classes
-        hiera = YAML.safe_load(File.open(hiera_path))
-        profile&.gsub!(/^profile_/, '') unless profile.nil?
-
-        matcher = profile.nil? ? /^profile_/ : /^profile_#{profile}/
-        hiera.each do |k, v|
-          key_base = k.split('::')[-1]
-          coverage['benchmark'] = v if key_base == 'title'
-          next unless key_base.match?(matcher)
-
-          coverage[key_base] = generate_uncovered_data(v, valid_classes)
-        end
-        coverage
-      end
-
-      def self.generate_uncovered_data(ctrl_list, valid_classes)
-        out_hash = {}
-        out_hash[:num_total] = ctrl_list.length
-        out_hash[:uncovered] = []
-        out_hash[:covered] = []
-        ctrl_list.each do |c|
-          if valid_classes.include?(c)
-            out_hash[:covered] << c
-          else
-            out_hash[:uncovered] << c
-          end
-        end
-        out_hash[:num_covered] = out_hash[:covered].length
-        out_hash[:num_uncovered] = out_hash[:uncovered].length
-        out_hash[:coverage] = Float(
-          (Float(out_hash[:num_covered]) / Float(out_hash[:num_total])) * 100.0
-        ).floor(3)
-        out_hash
-      end
-
-      def self.find_valid_classes(all_cap, invalid_classes)
-        all_classes = all_cap.dup.transpose[0]
-        return [] if all_classes.nil?
-
-        return all_classes - invalid_classes unless invalid_classes.nil?
-
-        all_classes
-      end
-
-      def self.find_invalid_classes(all_cap)
-        invalid_classes = []
-        all_cap.each do |cap|
-          invalid_classes << cap[0] unless class_valid?(cap[1])
-        end
-        invalid_classes
-      end
-
-      def self.class_valid?(manifest_path)
-        compiler = Puppet::Pal::Compiler.new(nil)
-        ast = compiler.parse_file(manifest_path)
-        ast.body.body.statements.each do |s|
-          next unless s.respond_to?(:arguments)
-          next unless s.arguments.respond_to?(:each)
-
-          s.arguments.each do |i|
-            return false if i.value == 'Not implemented'
-          end
-        end
-        true
-      end
-    end
-  end
-end