abide_dev_utils 0.10.1 → 0.11.0

data/lib/abide_dev_utils/cli/cem.rb

@@ -15,10 +15,90 @@ module Abide
       CMD_LONG = 'Namespace for commands related to Puppet CEM'
       def initialize
         super(CMD_NAME, CMD_SHORT, CMD_LONG, takes_commands: true)
+        add_command(CemGenerate.new)
         add_command(CemUpdateConfig.new)
       end
     end
 
+    class CemGenerate < AbideCommand
+      CMD_NAME = 'generate'
+      CMD_SHORT = 'Holds subcommands for generating objects / files'
+      CMD_LONG = 'Holds subcommands for generating objects / files'
+      def initialize
+        super(CMD_NAME, CMD_SHORT, CMD_LONG, takes_commands: true)
+        add_command(CemGenerateCoverageReport.new)
+        add_command(CemGenerateReference.new)
+      end
+    end
+
+    class CemGenerateCoverageReport < AbideCommand
+      CMD_NAME = 'coverage-report'
+      CMD_SHORT = 'Generates control coverage report'
+      CMD_LONG = <<-EOLC.chomp
+      Generates report of resources that are associated with controls in mapping data. This command must
+      be run from a module directory.
+      EOLC
+      def initialize
+        super(CMD_NAME, CMD_SHORT, CMD_LONG, takes_commands: false)
+        options.on('-o [FILE]', '--out-file [FILE]', 'Path to save the coverage report') { |f| @data[:file] = f }
+        options.on('-f [FORMAT]', '--format [FORMAT]', 'The format to output the report in (hash, json, yaml)') do |f|
+          @data[:format] = f
+        end
+        options.on('-I', '--ignore-benchmark-errors', 'Ignores errors while generating benchmark reports') do
+          @data[:ignore_all] = true
+        end
+        options.on('-v', '--verbose', 'Will output the report to the console') { @data[:verbose] = true }
+        options.on('-q', '--quiet', 'Will not output anything to the console') { @data[:quiet] = true }
+      end
+
+      def execute
+        file_name = @data.fetch(:file, 'coverage_report')
+        out_format = @data.fetch(:format, 'yaml')
+        quiet = @data.fetch(:quiet, false)
+        console = @data.fetch(:verbose, false) && !quiet
+        ignore_all = @data.fetch(:ignore_all, false)
+        AbideDevUtils::Output.simple('Generating coverage report...') unless quiet
+        coverage = AbideDevUtils::CEM::CoverageReport.basic_coverage(format_func: :to_h, ignore_benchmark_errors: ignore_all)
+        AbideDevUtils::Output.simple("Saving coverage report to #{file_name}...")
+        case out_format
+        when /yaml/i
+          AbideDevUtils::Output.yaml(coverage, console: console, file: file_name)
+        when /json/i
+          AbideDevUtils::Output.json(coverage, console: console, file: file_name)
+        else
+          File.open(file_name, 'w') do |f|
+            AbideDevUtils::Output.simple(coverage.to_s, stream: f)
+          end
+        end
+      end
+    end
+
+    class CemGenerateReference < AbideCommand
+      CMD_NAME = 'reference'
+      CMD_SHORT = 'Generates a reference doc for the module'
+      CMD_LONG = 'Generates a reference doc for the module'
+      def initialize
+        super(CMD_NAME, CMD_SHORT, CMD_LONG, takes_commands: false)
+        options.on('-o [FILE]', '--out-file [FILE]', 'Path to save the updated config file') do |o|
+          @data[:out_file] = o
+        end
+        options.on('-f [FORMAT]', '--format [FORMAT]', 'Format to save reference as') do |f|
+          @data[:format] = f
+        end
+        options.on('-v', '--verbose', 'Verbose output') do
+          @data[:verbose] = true
+        end
+        options.on('-q', '--quiet', 'Quiet output') do
+          @data[:quiet] = true
+        end
+      end
+
+      def execute
+        AbideDevUtils::Validate.puppet_module_directory
+        AbideDevUtils::CEM::Generate::Reference.generate(@data)
+      end
+    end
+
     class CemUpdateConfig < AbideCommand
       CMD_NAME = 'update-config'
       CMD_SHORT = 'Updates the Puppet CEM config'

data/lib/abide_dev_utils/errors/cem.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/errors/base'
+
+module AbideDevUtils
+  module Errors
+    # Raised by Benchmark when mapping data cannot be loaded
+    class MappingFilesNotFoundError < GenericError
+      @default = 'Mapping files not found using facts:'
+    end
+
+    # Raised by Benchmark when mapping files are not found for the specified framework
+    class MappingDataFrameworkMismatchError < GenericError
+      @default = 'Mapping data could not be found for the specified framework:'
+    end
+
+    # Raised by Benchmark when resource data cannot be loaded
+    class ResourceDataNotFoundError < GenericError
+      @default = 'Resource data not found using facts:'
+    end
+  end
+end

data/lib/abide_dev_utils/errors/general.rb

@@ -9,7 +9,12 @@ module AbideDevUtils
       @default = 'Object is empty and should not be:'
     end
 
-    # Raised when a an object is initialized with a nil param
+    # Raised when something is not a string, or is an empty string
+    class NotPopulatedStringError < GenericError
+      @default = 'Object is either not a String or is empty:'
+    end
+
+    # Raised when an object is initialized with a nil param
     class NewObjectParamNilError < GenericError
       @default = 'Object init parameter is nil and should not be:'
     end
@@ -54,8 +59,9 @@ module AbideDevUtils
       @default = 'Object does not respond to #to_hash or #to_h:'
     end
 
+    # Raised when conflicting CLI options are specified for a command
     class CliOptionsConflict < GenericError
-      @default = "Console options conflict."
+      @default = 'Console options conflict:'
     end
   end
 end

data/lib/abide_dev_utils/errors/ppt.rb

@@ -5,6 +5,10 @@ require 'abide_dev_utils/errors/base'
 module AbideDevUtils
   module Errors
     module Ppt
+      class NotModuleDirError < GenericError
+        @default = 'Path is not a Puppet module directory:'
+      end
+
       class ObjClassPathError < GenericError
         @default = 'Invalid path for class:'
       end

data/lib/abide_dev_utils/errors.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
 require 'abide_dev_utils/errors/base'
+require 'abide_dev_utils/errors/cem'
 require 'abide_dev_utils/errors/comply'
 require 'abide_dev_utils/errors/gcloud'
 require 'abide_dev_utils/errors/general'
 require 'abide_dev_utils/errors/jira'
 require 'abide_dev_utils/errors/xccdf'
 require 'abide_dev_utils/errors/ppt'
+
+module AbideDevUtils
+  # Namespace for Error objects
+  module Errors; end
+end

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