abide_dev_utils 0.10.1 → 0.11.2

data/lib/abide_dev_utils/cli/cem.rb

@@ -15,10 +15,108 @@ 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('-B [BENCHMARK]', '--benchmark [BENCHMARK]', 'Specify the benchmark to show coverage for') do |x|
+          @data[:benchmark] = x
+        end
+        options.on('-P [PROFILE]', '--profile [PROFILE]', 'Specifiy the profile to show coverage for') do |x|
+          @data[:profile] = x
+        end
+        options.on('-L [LEVEL]', '--level [LEVEL]', 'Specify the level to show coverage for') do |l|
+          @data[:profile] = l
+        end
+        options.on('-I', '--ignore-benchmark-errors', 'Ignores errors while generating benchmark reports') do
+          @data[:ignore_all] = true
+        end
+        options.on('-X [XCCDF_DIR]', '--xccdf-dir [XCCDF_DIR]', 'If specified, the coverage report will be correlated with info from the benchmark XCCDF files') do |d|
+          @data[:xccdf_dir] = d
+        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
+        generate_opts = {
+          benchmark: @data.fetch(:benchmark),
+          profile: @data.fetch(:profile),
+          level: @data.fetch(:level),
+          ignore_benchmark_errors: @data.fetch(:ignore_all, false),
+          xccdf_dir: @data.fetch(:xccdf_dir),
+        }
+        AbideDevUtils::Output.simple('Generating coverage report...') unless quiet
+        coverage = AbideDevUtils::CEM::Generate::CoverageReport.generate(format_func: :to_h, opts: generate_opts)
+        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/dot_number_comparable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module AbideDevUtils
+  # Module provides comparison methods for "dot numbers", numbers that
+  # take the form of "1.1.1" as found in CIS benchmarks. Classes that
+  # include this module must implement a method "number" that returns
+  # their dot number representation.
+  module DotNumberComparable
+    include ::Comparable
+
+    def <=>(other)
+      return 0 if number_eq(number, other.number)
+      return 1 if number_gt(number, other.number)
+      return -1 if number_lt(number, other.number)
+    end
+
+    def number_eq(this_num, other_num)
+      this_num == other_num
+    end
+
+    def number_parent_of?(this_num, other_num)
+      return false if number_eq(this_num, other_num)
+
+      # We split the numbers into parts and compare the resulting arrays
+      num1_parts = this_num.to_s.split('.')
+      num2_parts = other_num.to_s.split('.')
+      # For this_num to be a parent of other_num, the number of parts in
+      # this_num must be less than the number of parts in other_num.
+      # Additionally, each part of this_num must be equal to the parts of
+      # other_num at the same index.
+      # Example: this_num = '1.2.3' and other_num = '1.2.3.4'
+      # In this case, num1_parts = ['1', '2', '3'] and num2_parts = ['1', '2', '3', '4']
+      # So, this_num is a parent of other_num because at indexes 0, 1, and 2
+      # of num1_parts and num2_parts, the parts are equal.
+      num1_parts.length < num2_parts.length &&
+        num2_parts[0..(num1_parts.length - 1)] == num1_parts
+    end
+
+    def number_child_of?(this_num, other_num)
+      number_parent_of?(other_num, this_num)
+    end
+
+    def number_gt(this_num, other_num)
+      return false if number_eq(this_num, other_num)
+      return true if number_parent_of?(this_num, other_num)
+
+      num1_parts = this_num.to_s.split('.')
+      num2_parts = other_num.to_s.split('.')
+      num1_parts.zip(num2_parts).each do |num1_part, num2_part|
+        next if num1_part == num2_part # we skip past equal parts
+
+        # If num1_part is nil that means that we've had equal numbers so far.
+        # Therfore, this_num is greater than other num because of the
+        # hierarchical nature of the numbers.
+        # Example: this_num = '1.2' and other_num = '1.2.3'
+        # In this case, num1_part is nil and num2_part is '3'
+        # So, this_num is greater than other_num
+        return true if num1_part.nil?
+        # If num2_part is nil that means that we've had equal numbers so far.
+        # Therfore, this_num is less than other num because of the
+        # hierarchical nature of the numbers.
+        # Example: this_num = '1.2.3' and other_num = '1.2'
+        # In this case, num1_part is '3' and num2_part is nil
+        # So, this_num is less than other_num
+        return false if num2_part.nil?
+
+        return num1_part.to_i > num2_part.to_i
+      end
+    end
+
+    def number_lt(this_num, other_num)
+      number_gt(other_num, this_num)
+    end
+  end
+end

data/lib/abide_dev_utils/errors/cem.rb

@@ -0,0 +1,32 @@
+# 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
+
+    # Raised by Control when it can't find mapping data for itself
+    class NoMappingDataForControlError < GenericError
+      @default = 'No mapping data found for control:'
+    end
+
+    # Raised by a control when it's given ID and framework are incompatible
+    class ControlIdFrameworkMismatchError < GenericError
+      @default = 'Control ID is invalid with the given framework:'
+    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/class_utils.rb

@@ -27,7 +27,7 @@ module AbideDevUtils
       def self.path_from_class_name(class_name)
         parts = class_name.split('::')
         parts[-1] = "#{parts[-1]}.pp"
-        File.expand_path(File.join('manifests', parts[1..-1]))
+        File.expand_path(File.join('manifests', parts[1..]))
       end
 
       # Returns the namespaced class name from a file path

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'puppet'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      module DataTypes
+        def infer_data_type(data)
+          Puppet::Pops::Types::TypeCalculator.infer(data).to_s
+        end
+
+        # Displays a Puppet type value as a string
+        def display_value(val)
+          if val.is_a?(Puppet::Pops::Model::LiteralUndef)
+            'undef'
+          elsif val.respond_to?(:value)
+            display_value(val.value)
+          elsif val.respond_to?(:cased_value)
+            display_value(val.cased_value)
+          else
+            val
+          end
+        end
+
+        # Displays a Puppet type expression (type signature) as a string
+        # @param param [Puppet::Pops::Model::Parameter] AST Parameter node of a parsed Puppet manifest
+        def display_type_expr(param)
+          te = param.respond_to?(:type_expr) ? param.type_expr : param
+          if te.respond_to? :left_expr
+            display_type_expr_with_left_expr(te)
+          elsif te.respond_to? :entries
+            display_type_expr_with_entries(te)
+          elsif te.respond_to? :cased_value
+            te.cased_value
+          elsif te.respond_to? :value
+            te.value
+          end
+        end
+
+        # Used by #display_type_expr
+        def display_type_expr_with_left_expr(te)
+          cased = nil
+          keys = nil
+          cased = te.left_expr.cased_value if te.left_expr.respond_to? :cased_value
+          keys = te.keys.map { |x| display_type_expr(x) }.to_s if te.respond_to? :keys
+          keys.tr!('"', '') unless cased == 'Enum'
+          "#{cased}#{keys}"
+        end
+
+        # Used by #display_type_expr
+        def display_type_expr_with_entries(te)
+          te.entries.each_with_object({}) do |x, hsh|
+            key = nil
+            val = nil
+            key = display_value(x.key) if x.respond_to? :key
+            val = display_type_expr(x.value) if x.respond_to? :value
+            hsh[key] = val if key
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      class Resource
+        attr_reader :type, :title
+
+        def initialize(type, title, **attributes)
+          validate_type_and_title(type, title)
+          @type = type
+          @title = title
+          @attributes = attributes
+        end
+
+        def reference
+          "#{title.split('::').map(&:capitalize).join('::')}['#{title}']"
+        end
+
+        def to_s
+          return "#{type} { '#{title}': }" if @attributes.empty?
+
+          str_array = ["#{type} { '#{title}':"]
+          @attributes.each do |key, val|
+            str_array << "  #{pad_attribute(key)} => #{val},"
+          end
+          str_array << '}'
+          str_array.join("\n")
+        end
+
+        private
+
+        def validate_type_and_title(type, title)
+          raise 'Type / title must be String' unless type.is_a?(String) && title.is_a?(String)
+          raise 'Type / title must not be empty' if type.empty? || title.empty?
+        end
+
+        def longest_attribute_length
+          return @longest_attribute_length if defined?(@longest_attribute_length)
+
+          longest = ''
+          @attributes.each_key do |k|
+            longest = k if k.length > longest.length
+          end
+          @longest_attribute_length = longest.length
+          @longest_attribute_length
+        end
+
+        def pad_attribute(attribute)
+          return attribute if attribute.length == longest_attribute_length
+
+          attr_array = [attribute]
+          (longest_attribute_length - attribute.length).times { attr_array << ' ' }
+          attr_array.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      # Base class for all code gen objects
+      class Base
+        attr_accessor :title, :id
+
+        def initialize
+          @id = SecureRandom.hex(10)
+          @supports_value = false
+          @supports_children = false
+        end
+
+        def to_s
+          "#{type} : value: #{@value}; children: #{@children}"
+        end
+
+        def reference
+          raise NotImplementedError, "#{type} does not support having a reference"
+        end
+
+        def type
+          self.class.to_s
+        end
+
+        def value
+          raise NotImplementedError, "#{type} does not support having a value" unless @supports_value
+
+          @value
+        end
+
+        def get_my(t, named: nil)
+          if named.nil?
+            children.each_with_object([]) do |(k, v), arr|
+              arr << v if k.start_with?("#{t.to_s.capitalize}_")
+            end
+          else
+            children["#{t.to_s.capitalize}_#{named}"]
+          end
+        end
+
+        # Creates a new object of the given type and adds it to the current objects children
+        # if the current object supports children.
+        # Returns `self`. If a block is given, the new
+        # object will be yielded before adding to children.
+        def with_a(t, named: nil)
+          obj = Object.const_get("AbideDevUtils::Ppt::CodeGen::#{t.to_s.capitalize}").new
+          obj.title = named unless named.nil? || named.empty?
+
+          yield obj if block_given?
+
+          children["#{t.to_s.capitalize}_#{obj.id}"] = obj
+          self
+        end
+        alias and_a with_a
+
+        def has_a(t, named: nil)
+          obj = Object.const_get("AbideDevUtils::Ppt::CodeGen::#{t.to_s.capitalize}").new
+          obj.title = named unless named.nil? || named.empty?
+          children["#{t.to_s.capitalize}_#{obj.id}"] = obj
+          obj
+        end
+        alias and_has_a has_a
+        alias that_has_a has_a
+
+        # Sets the explicit value of the current object if the current object has an explicit value.
+        def that_equals(val)
+          self.value = val
+          self
+        end
+        alias and_assign_a_value_of that_equals
+        alias has_a_value_of that_equals
+        alias that_has_a_value_of that_equals
+
+        private
+
+        def children
+          raise NotImplementedError, "#{type} does not support children" unless @supports_children
+
+          @children ||= {}
+        end
+
+        def value=(val)
+          @value = val if @supports_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/ppt/code_gen/resource_types/base'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      class Class < Base
+        def initialize
+          super
+          @supports_children = true
+          @supports_value = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/ppt/code_gen/resource_types/base'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      class Manifest < Base
+        def initialize
+          super
+          @supports_children = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/ppt/code_gen/resource_types/base'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      class Parameter < Base
+        def initialize
+          @supports_children = true
+          @supports_value = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/ppt/code_gen/resource_types/base'
+
+module AbideDevUtils
+  module Ppt
+    module CodeGen
+      class Strings < Base
+        VALID_CHILDREN = %w[See Summary Param Example].freeze
+      end
+    end
+  end
+end