abide_dev_utils 0.4.1 → 0.6.0

data/lib/abide_dev_utils/ppt/class_utils.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+require 'abide_dev_utils/errors/ppt'
+
+module AbideDevUtils
+  module Ppt
+    module ClassUtils
+      include AbideDevUtils::Errors::Ppt
+
+      CLASS_NAME_PATTERN = /\A([a-z][a-z0-9_]*)?(::[a-z][a-z0-9_]*)*\Z/.freeze
+      CLASS_NAME_CAPTURE_PATTERN = /\A^class (?<class_name>([a-z][a-z0-9_]*)?(::[a-z][a-z0-9_]*)*).*\Z/.freeze
+
+      # Validates a Puppet class name
+      # @param name [String] Puppet class name
+      # @return [Boolean] Is the name a valid Puppet class name
+      def self.valid_class_name?(name)
+        name.match?(CLASS_NAME_PATTERN)
+      end
+
+      # Takes a full Puppet class name and returns the path
+      # of the class file. This command must be run from the
+      # root module directory if validate_path is true.
+      # @param class_name [String] full Puppet class name
+      # @return [String] path to class file
+      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]))
+      end
+
+      # Returns the namespaced class name from a file path
+      # @param class_path [String] the path to the Puppet class
+      # @return [String] the namespaced class name
+      def self.class_name_from_path(class_path)
+        parts = class_path.split(File::SEPARATOR).map { |x| x == '' ? File::SEPARATOR : x }
+        module_root_idx = parts.find_index('manifests') - 1
+        module_root = parts[module_root_idx].split('-')[-1]
+        namespaces = parts[(module_root_idx + 2)..-2].join('::') # add 2 to module root idx to skip manifests dir
+        class_name = parts[-1].delete_suffix('.pp')
+        [module_root, namespaces, class_name].join('::')
+      end
+
+      # Takes a path to a Puppet file and extracts the class name from the class declaration in the file.
+      # This differs from class_name_from_path because we actually read the class file and search
+      # the code for a class declaration to get the class name instead of just using the path
+      # to construct a valid Puppet class name.
+      # @param path [String] the path to a Puppet file
+      # @return [String] the Puppet class name
+      # @raise [ClassDeclarationNotFoundError] if there is not class declaration in the file
+      def self.class_name_from_declaration(path)
+        File.readlines(path).each do |line|
+          next unless line.match?(/^class /)
+
+          return CLASS_NAME_CAPTURE_PATTERN.match(line)['class_name']
+        end
+        raise ClassDeclarationNotFoundError, "Path:#{path}"
+      end
+
+      # Renames a file by file move. Ensures destination path exists before moving.
+      # @param from_path [String] path of the original file
+      # @param to_path [String] path of the new file
+      # @param verbose [Boolean] Sets verbose mode on file operations
+      # @param force [Boolean] If true, file move file overwrite existing files
+      def self.rename_class_file(from_path, to_path, **kwargs)
+        verbose = kwargs.fetch(:verbose, false)
+        force = kwargs.fetch(:force, false)
+        FileUtils.mkdir_p(File.dirname(to_path), verbose: verbose)
+        FileUtils.mv(from_path, to_path, verbose: verbose, force: force)
+      end
+
+      # Renames a Puppet class in the class declaration of the given file
+      # @param from [String] the original class name
+      # @param to [String] the new class name
+      # @param file_path [String] the path to the class file
+      # @param verbose [Boolean] Sets verbose mode on file operations
+      # @param force [Boolean] If true, file move file overwrite existing files
+      # @raise [ClassDeclarationNotFoundError] if the class file does not contain the from class declaration
+      def self.rename_puppet_class_declaration(from, to, file_path, **kwargs)
+        verbose = kwargs.fetch(:verbose, false)
+        force = kwargs.fetch(:force, false)
+        temp_file = Tempfile.new
+        renamed = false
+        begin
+          File.readlines(file_path).each do |line|
+            if line.match?(/^class #{from}.*/)
+              line.gsub!(/^class #{from}/, "class #{to}")
+              renamed = true
+            end
+            temp_file.puts line
+          end
+          raise ClassDeclarationNotFoundError, "File:#{file_path},Declaration:class #{from}" unless renamed
+
+          temp_file.close
+          FileUtils.mv(temp_file.path, file_path, verbose: verbose, force: force)
+        ensure
+          temp_file.close
+          temp_file.unlink
+        end
+      end
+
+      # Determines if a Puppet class name is mismatched by constructing a class name from
+      # a path to a Puppet file and extracting the class name from the class declaration
+      # inside the file. This is useful to determine if a Puppet class file breaks the
+      # autoload path pattern.
+      # @param path [String] path to a Puppet class file
+      # @return [Boolean] if the actual class name and path-constructed class name match
+      def self.mismatched_class_declaration?(path)
+        class_name_from_path(path) != class_name_from_declaration(path)
+      end
+
+      # Finds all Puppet classes in the given directory that have class declarations
+      # that do not adhere to the autoload path pattern.
+      # @param class_dir [String] path to a directory containing Puppet class files
+      # @return [Array] paths to all Puppet class files with mismatched class names
+      def self.find_all_mismatched_class_declarations(class_dir)
+        mismatched = []
+        Dir[File.join(File.expand_path(class_dir), '*.pp')].each do |class_file|
+          mismatched << class_file if mismatched_class_declaration?(class_file)
+        end
+        mismatched.sort
+      end
+
+      # Given a directory holding Puppet manifests, returns
+      # the full namespace for all classes in that directory.
+      # @param puppet_class_dir [String] path to a dir containing Puppet manifests
+      # @return [String] The namespace for all classes in manifests in the dir
+      def self.find_class_namespace(puppet_class_dir)
+        path = Pathname.new(puppet_class_dir)
+        mod_root = nil
+        ns_parts = []
+        found_manifests = false
+        path.ascend do |p|
+          if found_manifests
+            mod_root = find_mod_root(p)
+            break
+          end
+          if File.basename(p) == 'manifests'
+            found_manifests = true
+            next
+          else
+            ns_parts << File.basename(p)
+          end
+        end
+        "#{mod_root}::#{ns_parts.reverse.join('::')}::"
+      end
+
+      # Given a Pathname object of the 'manifests' directory in a Puppet module,
+      # determines the module namespace root. Does this by consulting
+      # metadata.json, if it exists, or by using the parent directory name.
+      # @param pathname [Pathname] A Pathname object of the module's manifests dir
+      # @return [String] The module's namespace root
+      def self.find_mod_root(pathname)
+        metadata_file = nil
+        pathname.entries.each do |e|
+          metadata_file = "#{pathname}/metadata.json" if File.basename(e) == 'metadata.json'
+        end
+        if metadata_file.nil?
+          File.basename(p)
+        else
+          File.open(metadata_file) do |f|
+            file = JSON.parse(f.read)
+            File.basename(p) unless file.key?('name')
+            file['name'].split('-')[-1]
+          end
+        end
+      end
+
+      # @return [Array] An array of frozen arrays where each sub-array's
+      #   index 0 is class_name and index 1 is the full path to the file.
+      def self.find_all_classes_and_paths(puppet_class_dir)
+        all_cap = []
+        Dir.each_child(puppet_class_dir) do |c|
+          path = "#{puppet_class_dir}/#{c}"
+          next if File.directory?(path) || File.extname(path) != '.pp'
+
+          all_cap << [File.basename(path, '.pp'), path].freeze
+        end
+        all_cap
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/ppt/coverage.rb

@@ -4,16 +4,15 @@ require 'json'
 require 'pathname'
 require 'yaml'
 require 'puppet_pal'
-require 'abide_dev_utils/ppt'
+require 'abide_dev_utils/ppt/class_utils'
 
 module AbideDevUtils
   module Ppt
     class CoverageReport
-      include AbideDevUtils::Ppt
       def self.generate(puppet_class_dir, hiera_path, profile = nil)
         coverage = {}
         coverage['classes'] = {}
-        all_cap = AbideDevUtils::Ppt.find_all_classes_and_paths(puppet_class_dir)
+        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

data/lib/abide_dev_utils/ppt.rb

@@ -1,66 +1,152 @@
 # frozen_string_literal: true
 
-require 'abide_dev_utils/ppt/coverage'
-require 'abide_dev_utils/ppt/new_obj'
+require 'abide_dev_utils/output'
+require 'abide_dev_utils/validate'
+require 'abide_dev_utils/errors'
+require 'abide_dev_utils/ppt/class_utils'
 
 module AbideDevUtils
   module Ppt
-    # Given a directory holding Puppet manifests, returns
-    # the full namespace for all classes in that directory.
-    # @param puppet_class_dir [String] path to a dir containing Puppet manifests
-    # @return [String] The namespace for all classes in manifests in the dir
-    def self.find_class_namespace(puppet_class_dir)
-      path = Pathname.new(puppet_class_dir)
-      mod_root = nil
-      ns_parts = []
-      found_manifests = false
-      path.ascend do |p|
-        if found_manifests
-          mod_root = find_mod_root(p)
-          break
-        end
-        if File.basename(p) == 'manifests'
-          found_manifests = true
-          next
-        else
-          ns_parts << File.basename(p)
-        end
+    # Renames a Puppet class by renaming the class declaration and class file
+    # @param from [String] fully-namespaced existing Puppet class name
+    # @param to [String] fully-namespaced new Puppet class name
+    def self.rename_puppet_class(from, to, **kwargs)
+      from_path = ClassUtils.path_from_class_name(from)
+      to_path = ClassUtils.path_from_class_name(to)
+      file_path = kwargs.fetch(:declaration_in_to_file, false) ? to_path : from_path
+      raise ClassFileNotFoundError, "Path:#{file_path}" if !File.file?(file_path) && kwargs.fetch(:validate_path, true)
+
+      rename_puppet_class_declaration(from, to, file_path, **kwargs)
+      AbideDevUtils::Output.simple("Renamed #{from} to #{to} at #{file_path}.")
+      return unless kwargs.fetch(:declaration_only, false)
+
+      rename_class_file(from_path, to_path, **kwargs)
+      AbideDevUtils::Output.simple("Renamed file #{from_path} to #{to_path}.")
+    end
+
+    def self.audit_class_names(dir, **kwargs)
+      mismatched = ClassUtils.find_all_mismatched_class_declarations(dir)
+      outfile = kwargs.key?(:file) ? File.open(kwargs[:file], 'a') : nil
+      quiet = kwargs.fetch(:quiet, false)
+      mismatched.each do |class_file|
+        AbideDevUtils::Output.simple("Mismatched class name in file #{class_file}") unless quiet
+        outfile << "MISMATCHED_CLASS_NAME: #{class_file}\n" unless outfile.nil?
       end
-      "#{mod_root}::#{ns_parts.reverse.join('::')}::"
+      outfile&.close
+      AbideDevUtils::Output.simple("Found #{mismatched.length} mismatched classes in #{dir}.") unless quiet
+    ensure
+      outfile&.close
     end
 
-    # Given a Pathname object of the 'manifests' directory in a Puppet module,
-    # determines the module namespace root. Does this by consulting
-    # metadata.json, if it exists, or by using the parent directory name.
-    # @param pathname [Pathname] A Pathname object of the module's manifests dir
-    # @return [String] The module's namespace root
-    def self.find_mod_root(pathname)
-      metadata_file = nil
-      pathname.entries.each do |e|
-        metadata_file = "#{pathname}/metadata.json" if File.basename(e) == 'metadata.json'
+    def self.fix_class_names_file_rename(dir, **kwargs)
+      mismatched = ClassUtils.find_all_mismatched_class_declarations(dir)
+      progress = AbideDevUtils::Output.progress(title: 'Renaming files', total: mismatched.length)
+      mismatched.each do |class_path|
+        should = ClassUtils.path_from_class_name(class_name_from_declaration(class_path))
+        ClassUtils.rename_class_file(class_path, should, **kwargs)
+        progress.increment
+        AbideDevUtils::Output.simple("Renamed file #{class_path} to #{should}...") if kwargs.fetch(:verbose, false)
       end
-      if metadata_file.nil?
-        File.basename(p)
-      else
-        File.open(metadata_file) do |f|
-          file = JSON.parse(f.read)
-          File.basename(p) unless file.key?('name')
-          file['name'].split('-')[-1]
-        end
+      AbideDevUtils::Output.simple('Successfully fixed all classes.')
+    end
+
+    def self.fix_class_names_class_rename(dir, **kwargs)
+      mismatched = ClassUtils.find_all_mismatched_class_declarations(dir)
+      progress = AbideDevUtils::Output.progress(title: 'Renaming classes', total: mismatched.length)
+      mismatched.each do |class_path|
+        current = ClassUtils.class_name_from_declaration(class_path)
+        should = ClassUtils.class_name_from_path(class_path)
+        ClassUtils.rename_puppet_class_declaration(current, should, class_path, **kwargs)
+        progress.increment
+        AbideDevUtils::Output.simple("Renamed #{from} to #{to} at #{file_path}...") if kwargs.fetch(:verbose, false)
+      end
+      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(
+        type,
+        name,
+        opts: opts,
+        vars: opts.fetch(:vars, '').split(',').map { |i| i.split('=') }.to_h # makes the str a hash
+      ).build
+    end
+
+    def self.add_cis_comment(path, xccdf, number_format: false)
+      require 'abide_dev_utils/xccdf'
+      utils = AbideDevUtils::XCCDF::UtilsObject
+      parsed_xccdf = utils.parse(xccdf)
+      return add_cis_comment_to_all(path, parsed_xccdf, utils, number_format: number_format) if File.directory?(path)
+      return add_cis_comment_to_single(path, parsed_xccdf, utils, number_format: number_format) if File.file?(path)
+
+      raise AbideDevUtils::Errors::FileNotFoundError, path
+    end
+
+    def self.add_cis_comment_to_single(path, xccdf, utils, number_format: false)
+      write_cis_comment_to_file(
+        path,
+        cis_recommendation_comment(
+          path,
+          utils.all_cis_recommendations(xccdf),
+          number_format,
+          utils
+        )
+      )
+    end
+
+    def self.add_cis_comment_to_all(path, xccdf, utils, number_format: false)
+      comments = {}
+      recommendations = utils.all_cis_recommendations(xccdf)
+      Dir[File.join(path, '*.pp')].each do |puppet_file|
+        comment = cis_recommendation_comment(puppet_file, recommendations, number_format, utils)
+        comments[puppet_file] = comment unless comment.nil?
+      end
+      comments.each do |key, value|
+        write_cis_comment_to_file(key, value)
       end
+      AbideDevUtils::Output.simple('Successfully added comments.')
     end
 
-    # @return [Array] An array of frozen arrays where each sub-array's
-    #   index 0 is class_name and index 1 is the full path to the file.
-    def self.find_all_classes_and_paths(puppet_class_dir)
-      all_cap = []
-      Dir.each_child(puppet_class_dir) do |c|
-        path = "#{puppet_class_dir}/#{c}"
-        next if File.directory?(path) || File.extname(path) != '.pp'
+    def self.write_cis_comment_to_file(path, comment)
+      require 'tempfile'
+      tempfile = Tempfile.new
+      begin
+        File.open(tempfile, 'w') do |nf|
+          nf.write("#{comment}\n")
+          File.foreach(path) do |line|
+            next if line.match?(/#{comment}/)
+
+            nf << line
+          end
+        end
+        File.rename(path, "#{path}.old")
+        tempfile.close
+        File.rename(tempfile.path, path)
+        File.delete("#{path}.old")
+        AbideDevUtils::Output.simple("Added CIS recomendation comment to #{path}...")
+      ensure
+        tempfile.close
+        tempfile.unlink
+      end
+    end
 
-        all_cap << [File.basename(path, '.pp'), path].freeze
+    def self.cis_recommendation_comment(puppet_file, recommendations, number_format, utils)
+      reco_text = utils.find_cis_recommendation(
+        File.basename(puppet_file, '.pp'),
+        recommendations,
+        number_format: number_format
+      )
+      if reco_text.nil?
+        AbideDevUtils::Output.simple("Could not find recommendation text for #{puppet_file}...")
+        return nil
       end
-      all_cap
+      "# #{reco_text}"
     end
   end
 end

data/lib/abide_dev_utils/version.rb

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

data/lib/abide_dev_utils/xccdf/cis/hiera.rb

@@ -3,6 +3,7 @@
 require 'yaml'
 require 'nokogiri'
 require 'abide_dev_utils/errors'
+require 'abide_dev_utils/xccdf/utils'
 
 module AbideDevUtils
   module XCCDF
@@ -12,21 +13,23 @@ module AbideDevUtils
       # @!attribute [r] version
       # @!attribute [r] yaml_title
       class Hiera
-        CONTROL_PREFIX = /^[\d.]+_/.freeze
-        UNDERSCORED = /(\s|\(|\)|-|\.)/.freeze
-        XPATHS = {
-          benchmark: {
-            all: 'xccdf:Benchmark',
-            title: 'xccdf:Benchmark/xccdf:title',
-            version: 'xccdf:Benchmark/xccdf:version'
-          },
-          profiles: {
-            all: 'xccdf:Benchmark/xccdf:Profile',
-            relative_title: './xccdf:title',
-            relative_select: './xccdf:select'
-          }
-        }.freeze
-        NEXT_GEN_WINDOWS = /(next_generation_windows_security)/.freeze
+        include AbideDevUtils::XCCDF::Utils
+
+        # CONTROL_PREFIX = /^[\d.]+_/.freeze
+        # UNDERSCORED = /(\s|\(|\)|-|\.)/.freeze
+        # XPATHS = {
+        #   benchmark: {
+        #     all: 'xccdf:Benchmark',
+        #     title: 'xccdf:Benchmark/xccdf:title',
+        #     version: 'xccdf:Benchmark/xccdf:version'
+        #   },
+        #   profiles: {
+        #     all: 'xccdf:Benchmark/xccdf:Profile',
+        #     relative_title: './xccdf:title',
+        #     relative_select: './xccdf:select'
+        #   }
+        # }.freeze
+        # NEXT_GEN_WINDOWS = /(next_generation_windows_security)/.freeze
 
         attr_reader :title, :version
 
@@ -37,15 +40,15 @@ module AbideDevUtils
         #   the top-level key.
         def initialize(xccdf_file, parent_key_prefix: nil, num: false)
           @doc = parse(xccdf_file)
-          @title = xpath(XPATHS[:benchmark][:title]).children.to_s
-          @version = xpath(XPATHS[:benchmark][:version]).children.to_s
-          @profiles = xpath(XPATHS[:profiles][:all])
+          @title = xpath(CIS_XPATHS[:benchmark][:title]).children.to_s
+          @version = xpath(CIS_XPATHS[:benchmark][:version]).children.to_s
+          @profiles = xpath(CIS_XPATHS[:profiles][:all])
           @parent_key = make_parent_key(@doc, parent_key_prefix)
-          @hash = make_hash(@doc, @parent_key, num)
+          @hash = make_hash(@doc, number_format: num)
         end
 
         def yaml_title
-          normalize_str(@title)
+          normalize_string(@title)
         end
 
         # Convert the Hiera object to a hash
@@ -63,8 +66,8 @@ module AbideDevUtils
         # Convert the Hiera object to YAML string
         # @return [String] YAML-formatted string
         def to_yaml
-          yh = @hash[@parent_key.to_sym].transform_keys do |k|
-            "#{@parent_key}::#{k}"
+          yh = @hash.transform_keys do |k|
+            [@parent_key, k].join('::').strip
           end
           yh.to_yaml
         end
@@ -92,64 +95,66 @@ module AbideDevUtils
 
         attr_accessor :doc, :hash, :parent_key, :profiles
 
-        # Accepts a path to an xccdf xml file and returns a parsed Nokogiri object of the file
-        # @param xccdf_file [String] path to an xccdf xml file
-        # @return [Nokogiri::Node] A Nokogiri node object of the XML document
-        def parse(xccdf_file)
-          raise AbideDevUtils::Errors::FileNotFoundError, xccdf_file unless File.file?(xccdf_file)
+        # # Accepts a path to an xccdf xml file and returns a parsed Nokogiri object of the file
+        # # @param xccdf_file [String] path to an xccdf xml file
+        # # @return [Nokogiri::Node] A Nokogiri node object of the XML document
+        # def parse(xccdf_file)
+        #   raise AbideDevUtils::Errors::FileNotFoundError, xccdf_file unless File.file?(xccdf_file)
 
-          Nokogiri.XML(File.open(xccdf_file))
-        end
+        #   Nokogiri.XML(File.open(xccdf_file))
+        # end
 
-        def make_hash(doc, parent_key, num)
-          hash = { parent_key.to_sym => { title: @title, version: @version } }
+        def make_hash(doc, number_format: false)
+          hash = { 'title' => @title, 'version' => @version }
           profiles = doc.xpath('xccdf:Benchmark/xccdf:Profile')
           profiles.each do |p|
             title = normalize_profile_name(p.xpath('./xccdf:title').children.to_s)
-            hash[parent_key.to_sym][title.to_sym] = []
+            hash[title.to_s] = []
             selects = p.xpath('./xccdf:select')
             selects.each do |s|
-              hash[parent_key.to_sym][title.to_sym] << normalize_ctrl_name(s['idref'].to_s, num)
+              hash[title.to_s] << normalize_control_name(s['idref'].to_s, number_format: number_format)
             end
           end
           hash
         end
 
-        def normalize_str(str)
-          nstr = str.downcase
-          nstr.gsub!(/[^a-z0-9]$/, '')
-          nstr.gsub!(/^[^a-z]/, '')
-          nstr.gsub!(/^(l1_|l2_|ng_)/, '')
-          nstr.delete!('(/|\\)')
-          nstr.gsub!(UNDERSCORED, '_')
-          nstr
-        end
-
-        def normalize_profile_name(prof)
-          prof_name = normalize_str("profile_#{prof}")
-          prof_name.gsub!(NEXT_GEN_WINDOWS, 'ngws')
-          prof_name
-        end
-
-        def normalize_ctrl_name(ctrl, num)
-          return num_normalize_ctrl(ctrl) if num
-
-          name_normalize_ctrl(ctrl)
-        end
-
-        def name_normalize_ctrl(ctrl)
-          new_ctrl = ctrl.split('benchmarks_rule_')[-1].gsub(CONTROL_PREFIX, '')
-          normalize_str(new_ctrl)
-        end
-
-        def num_normalize_ctrl(ctrl)
-          part = ctrl.split('benchmarks_rule_')[-1]
-          numpart = CONTROL_PREFIX.match(part).to_s.chop.gsub(UNDERSCORED, '_')
-          "c#{numpart}"
-        end
+        # def normalize_str(str)
+        #   nstr = str.downcase
+        #   nstr.gsub!(/[^a-z0-9]$/, '')
+        #   nstr.gsub!(/^[^a-z]/, '')
+        #   nstr.gsub!(/^(l1_|l2_|ng_)/, '')
+        #   nstr.delete!('(/|\\|\+)')
+        #   nstr.gsub!(UNDERSCORED, '_')
+        #   nstr.strip!
+        #   nstr
+        # end
+
+        # def normalize_profile_name(prof)
+        #   prof_name = normalize_str("profile_#{prof}")
+        #   prof_name.gsub!(NEXT_GEN_WINDOWS, 'ngws')
+        #   prof_name.strip!
+        #   prof_name
+        # end
+
+        # def normalize_ctrl_name(ctrl, num)
+        #   return num_normalize_ctrl(ctrl) if num
+
+        #   name_normalize_ctrl(ctrl)
+        # end
+
+        # def name_normalize_ctrl(ctrl)
+        #   new_ctrl = ctrl.split('benchmarks_rule_')[-1].gsub(CONTROL_PREFIX, '')
+        #   normalize_str(new_ctrl)
+        # end
+
+        # def num_normalize_ctrl(ctrl)
+        #   part = ctrl.split('benchmarks_rule_')[-1]
+        #   numpart = CONTROL_PREFIX.match(part).to_s.chop.gsub(UNDERSCORED, '_')
+        #   "c#{numpart}"
+        # end
 
         def make_parent_key(doc, prefix)
-          doc_title = normalize_str(doc.xpath(XPATHS[:benchmark][:title]).children.to_s)
+          doc_title = normalize_string(doc.xpath(CIS_XPATHS[:benchmark][:title]).children.to_s)
           return doc_title if prefix.nil?
 
           sepped_prefix = prefix.end_with?('::') ? prefix : "#{prefix}::"