abide_dev_utils 0.16.1 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ba88038da5800b45085201557c28a7d4096027230083e0c8d5a811a7fd1de5a
-  data.tar.gz: 78da6fd7887fdb50a7de4505b4dd95b6fa2e24400dc6b5419dcc44aaa1f15d24
+  metadata.gz: ba0491c8fbcaa0a69015c410a2aa7e61ac61e6b30caca6fb5b334d22fd77069c
+  data.tar.gz: 119c837a5ea897957e63744ec3f38a7567222d7dbb5b952302ec71cd70aafc24
 SHA512:
-  metadata.gz: 3e1577583c8fcc597f75e02d3ef5edee126984f8daaea8fc98741c718c0254044767189acf24e0e21ba2b60607f4042c1f0c52be934dbc129d270008042f8bf5
-  data.tar.gz: eb8b1038e223efeec1f7a2b3d0d0ee0f04cba49f385b58c8de5e1dfe8c2d935dac0d760faf65d8ab45f0b539f4729ea9195926d0cce1d4fe294c19f6e426e879
+  metadata.gz: 492066b562bee8dd3c3d3b465396a569d66a66200018bb74e606c8f3a78320853ecc71a8f30ee0c4f18194dbdc0d8679ff8c32fd38fbaf7936267eae1b35d5eb
+  data.tar.gz: 2766d7c84c887b573cd9cb23f5d2aa869a4f238e5208ab2377832827e88d44056d180226a31c93ee242ed954d6aaf65b0e075d282b65ba53ea475ae1adb8e45a

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    abide_dev_utils (0.16.1)
+    abide_dev_utils (0.17.1)
       cmdparse (~> 3.0)
       facterdb (>= 1.21)
       google-cloud-storage (~> 1.34)
       hashdiff (~> 1.0)
       jira-ruby (~> 2.2)
       nokogiri (~> 1.13)
-      puppet (>= 6.23)
+      puppet (>= 7.0.0)
       puppet-strings (>= 2.7)
       ruby-progressbar (~> 1.11)
       selenium-webdriver (~> 4.0.0.beta4)
@@ -69,7 +69,7 @@ GEM
     faraday-http-cache (2.3.0)
       faraday (>= 0.8)
     faraday-net_http (2.0.3)
-    fast_gettext (1.8.0)
+    fast_gettext (2.3.0)
     fiber-local (1.0.0)
     gem-release (2.2.2)
     github_changelog_generator (1.16.4)
@@ -137,6 +137,8 @@ GEM
     multi_json (1.15.0)
     multipart-post (2.3.0)
     nio4r (2.5.8)
+    nokogiri (1.15.2-arm64-darwin)
+      racc (~> 1.4)
     nokogiri (1.15.2-x86_64-darwin)
       racc (~> 1.4)
     nokogiri (1.15.2-x86_64-linux)
@@ -265,6 +267,7 @@ GEM
     yard (0.9.34)
 
 PLATFORMS
+  arm64-darwin-22
   x86_64-darwin-19
   x86_64-darwin-20
   x86_64-linux
@@ -273,7 +276,7 @@ DEPENDENCIES
   abide_dev_utils!
   bundler
   console
-  fast_gettext (~> 1.8)
+  fast_gettext (>= 2.0)
   gem-release
   github_changelog_generator
   pry

data/abide_dev_utils.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   # Prod dependencies
   spec.add_dependency 'nokogiri', '~> 1.13'
   spec.add_dependency 'cmdparse', '~> 3.0'
-  spec.add_dependency 'puppet', '>= 6.23'
+  spec.add_dependency 'puppet', '>= 7.0.0'
   spec.add_dependency 'puppet-strings', '>= 2.7'
   spec.add_dependency 'jira-ruby', '~> 2.2'
   spec.add_dependency 'ruby-progressbar', '~> 1.11'
@@ -56,7 +56,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop-ast', '~> 1.4'
   spec.add_development_dependency 'rubocop-performance', '~> 1.9'
   spec.add_development_dependency 'rubocop-i18n', '~> 3.0'
-  spec.add_development_dependency 'fast_gettext', '~> 1.8'
+  spec.add_development_dependency 'fast_gettext', '>= 2.0'
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/abide_dev_utils/cem/generate/reference.rb

@@ -382,7 +382,12 @@ module AbideDevUtils
             # @valid_level is populated in verify_profile_and_level_selections from the fact that we've given
             # the generator a list of levels we want to use. If we didn't give it a list of levels, then we
             # want to use all of the levels that the control supports from @control.
-            @md.add_ul('Supported Levels:')
+            if @framework == 'stig'
+              @md.add_ul('Supported MAC Levels:')
+            else
+              @md.add_ul('Supported Levels:')
+            end
+
             if @valid_level.empty?
               @control.levels.each do |l|
                 @md.add_ul(@md.code(l), indent: 1)
@@ -400,7 +405,12 @@ module AbideDevUtils
             # @valid_profile is populated in verify_profile_and_level_selections from the fact that we've given
             # the generator a list of profiles we want to use. If we didn't give it a list of profiles, then we
             # want to use all of the profiles that the control supports from @control.
-            @md.add_ul('Supported Profiles:')
+            if @framework == 'stig'
+              @md.add_ul('Supported Confidentiality:')
+            else
+              @md.add_ul('Supported Profiles:')
+            end
+
             if @valid_profile.empty?
               @control.profiles.each do |l|
                 @md.add_ul(@md.code(l), indent: 1)
@@ -413,7 +423,7 @@ module AbideDevUtils
           end
 
           def control_alternate_ids_builder
-            return if @framework == 'stig'
+            # return if @framework == 'stig'
 
             @md.add_ul('Alternate Config IDs:')
             @control.alternate_ids.each do |l|

data/lib/abide_dev_utils/cli/jira.rb

@@ -6,9 +6,6 @@ require 'abide_dev_utils/jira'
 
 module Abide
   module CLI
-    CONFIG = AbideDevUtils::Config
-    JIRA = AbideDevUtils::Jira
-
     class JiraCommand < CmdParse::Command
       CMD_NAME = 'jira'
       CMD_SHORT = 'Commands related to Jira tickets'
@@ -38,11 +35,9 @@ module Abide
       end
 
       def execute
-        client = JIRA.client
-        myself = JIRA.myself(client)
-        return if myself.attrs['displayName'].empty?
+        return if AbideDevUtils::Jira.client.myself.attrs['displayName'].empty?
 
-        Abide::CLI::OUTPUT.simple("Successfully authenticated user #{myself.attrs['name']}!")
+        Abide::CLI::OUTPUT.simple("Successfully authenticated user #{AbideDevUtils::Jira.client.myself.attrs['displayName']}!")
       end
     end
 
@@ -59,8 +54,7 @@ module Abide
       end
 
       def execute(issue)
-        client = JIRA.client(options: {})
-        issue = client.Issue.find(issue)
+        issue = AbideDevUtils::Jira.client.find(:issue, issue)
         console = @data[:file].nil?
         out_json = issue.attrs.select { |_, v| !v.nil? || !v.empty? }
         Abide::CLI::OUTPUT.json(out_json, console: console, file: @data[:file])
@@ -83,13 +77,15 @@ module Abide
       end
 
       def execute(project, summary, *subtasks)
-        client = JIRA.client(options: {})
-        issue = JIRA.new_issue(client, project, summary)
+        issue = AbideDevUtils::Jira.client.create(:issue, project: project, summary: summary)
         Abide::CLI::OUTPUT.simple("Successfully created #{issue.attrs['key']}")
         return if subtasks.nil? || subtasks.empty?
 
         Abide::CLI::OUTPUT.simple('Creatings subtasks...')
-        JIRA.bulk_new_subtask(client, JIRA.issue(client, issue.attrs['key']), subtasks) unless subtasks.empty?
+        subtasks.each do |sum|
+          subtask = AbideDevUtils::Jira.client.create(:subtask, parent: issue, summary: sum)
+          Abide::CLI::OUTPUT.simple("Successfully created #{subtask.attrs['key']}")
+        end
       end
     end
 
@@ -107,11 +103,8 @@ module Abide
 
       def execute(report, project)
         Abide::CLI::VALIDATE.file(report)
-        @data[:dry_run] = false if @data[:dry_run].nil?
-        client = JIRA.client(options: {})
-        proj = JIRA.project(client, project)
         File.open(report) do |f|
-          JIRA.new_issues_from_coverage(client, proj, JSON.parse(f.read), dry_run: @data[:dry_run])
+          AbideDevUtils::Jira.new_issues_from_coverage(project, JSON.parse(f.read), dry_run: @data[:dry_run])
         end
       end
     end
@@ -125,16 +118,38 @@ module Abide
         short_desc(CMD_SHORT)
         long_desc(CMD_LONG)
         argument_desc(PATH: 'An XCCDF file', PROJECT: 'A Jira project')
-        options.on('-d', '--dry-run', 'Print to console instead of saving objects') { |_| @data[:dry_run] = true }
+        options.on('-d', '--dry-run', 'Runs through mock issue creation. Useful for testing, but not reliable for knowing what exactly will be created. Use --explain for more accurate information.') do
+          @data[:dry_run] = true
+        end
+        options.on('-x', '--explain', 'Shows a report of all the controls that will and won\'t be created as issues, and why. DOES NOT create issues.') do
+          @data[:explain] = true
+        end
         options.on('-e [EPIC]', '--epic [EPIC]', 'If given, tasks will be created and assigned to this epic. Takes form <PROJECT>-<NUM>') { |e| @data[:epic] = e }
+        options.on('-l [LEVEL]', '--level [LEVEL]', 'Only create tasks for rules belonging to the matching level. Takes a string that is treated as RegExp') do |x|
+          @data[:level] = x
+        end
+        options.on('-p [PROFILE]', '--profile [PROFILE]', 'Only create tasks for rules belonging to the matching profile. Takes a string that is treated as RegExp') do |x|
+          @data[:profile] = x
+        end
       end
 
       def execute(path, project)
         Abide::CLI::VALIDATE.file(path)
-        @data[:dry_run] = false if @data[:dry_run].nil?
-        client = JIRA.client(options: {})
-        proj = JIRA.project(client, project)
-        JIRA.new_issues_from_xccdf(client, proj, path, epic: @data[:epic], dry_run: @data[:dry_run])
+        # Each control gets assigned labels based on the levels and profiles it supports.
+        # Those labels all take the form "level_<level>_<profile>". This allows us to
+        # filter the controls we want to create tasks for by level and profile.
+        @data[:label_include] = nil
+        @data[:label_include] = "level_#{@data[:level]}_" if @data[:level]
+        @data[:label_include] = "#{@data[:label_include]}#{@data[:profile]}" if @data[:profile]
+        Abide::CLI::OUTPUT.simple "Label include: #{@data[:label_include]}"
+        AbideDevUtils::Jira.new_issues_from_xccdf(
+          project,
+          path,
+          epic: @data[:epic],
+          dry_run: @data[:dry_run],
+          explain: @data[:explain],
+          label_include: @data[:label_include],
+        )
       end
     end
 
@@ -167,17 +182,15 @@ module Abide
       def execute(path1, path2, project)
         Abide::CLI::VALIDATE.file(path1)
         Abide::CLI::VALIDATE.file(path2)
-        @data[:dry_run] = false if @data[:dry_run].nil?
-        client = JIRA.client(options: {})
-        proj = JIRA.project(client, project)
-        JIRA.new_issues_from_xccdf_diff(client,
-                                        proj,
-                                        path1,
-                                        path2,
-                                        epic: @data[:epic],
-                                        dry_run: @data[:dry_run],
-                                        auto_approve: @data[:auto_approve],
-                                        diff_opts: @data[:diff_opts])
+        AbideDevUtils::Jira.new_issues_from_xccdf_diff(
+          project,
+          path1,
+          path2,
+          epic: @data[:epic],
+          dry_run: @data[:dry_run],
+          auto_approve: @data[:auto_approve],
+          diff_opts: @data[:diff_opts],
+        )
       end
     end
   end

data/lib/abide_dev_utils/jira/client.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'client_builder'
+require_relative 'dry_run'
+require_relative 'finder'
+require_relative 'helper'
+require_relative 'issue_builder'
+require_relative '../config'
+require_relative '../errors/jira'
+
+module AbideDevUtils
+  module Jira
+    class Client
+      extend DryRun
+
+      dry_run :create, :find, :myself
+
+      attr_accessor :default_project
+      attr_reader :config
+
+      def initialize(dry_run: false, **options)
+        @dry_run = dry_run
+        @options = options
+        @config = AbideDevUtils::Config.config_section('jira')
+        @default_project = @config[:default_project]
+        @client = nil
+        @finder = nil
+        @issue_builder = nil
+        @helper = nil
+      end
+
+      def myself
+        @myself ||= finder.myself
+      end
+
+      def find(type, id)
+        raise ArgumentError, "Invalid type #{type}" unless finder.respond_to?(type.to_sym)
+
+        finder.send(type.to_sym, id)
+      end
+
+      def create(type, **fields)
+        issue_builder.create(type, **fields)
+      end
+
+      def helper
+        @helper ||= Helper.new(self, dry_run: @dry_run)
+      end
+
+      def translate_issue_custom_field(name)
+        IssueBuilder::CUSTOM_FIELDS[name] || IssueBuilder::CUSTOM_FIELDS.invert[name]
+      end
+
+      private
+
+      def client
+        @client ||= ClientBuilder.new(@config, **@options).build
+      end
+
+      def finder
+        @finder ||= Finder.new(client)
+      end
+
+      def issue_builder
+        @issue_builder ||= IssueBuilder.new(client, finder)
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/jira/client_builder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'jira-ruby'
+require_relative '../prompt'
+
+module AbideDevUtils
+  module Jira
+    class ClientBuilder
+      def initialize(config, **options)
+        @options = options
+        @config = config
+      end
+
+      def username
+        find_option_value(:username)
+      end
+
+      def username=(username)
+        @options[:username] = username
+      end
+
+      def password
+        if find_option_value(:password)
+          '********'
+        else
+          nil
+        end
+      end
+
+      def password=(password)
+        @options[:password] = password
+      end
+
+      def site
+        find_option_value(:site)
+      end
+
+      def site=(site)
+        @options[:site] = site
+      end
+
+      def context_path
+        find_option_value(:context_path, default: '')
+      end
+
+      def context_path=(context_path)
+        @options[:context_path] = context_path
+      end
+
+      def auth_type
+        find_option_value(:auth_type, default: :basic)
+      end
+
+      def auth_type=(auth_type)
+        @options[:auth_type] = auth_type
+      end
+
+      def http_debug
+        find_option_value(:http_debug, default: false)
+      end
+
+      def http_debug=(http_debug)
+        @options[:http_debug] = http_debug
+      end
+
+      def build
+        JIRA::Client.new({
+          username: find_option_value(:username, prompt: true),
+          password: find_option_value(:password, prompt: true),
+          site: find_option_value(:site, prompt: 'Jira site URL'),
+          context_path: find_option_value(:context_path, default: ''),
+          auth_type: find_option_value(:auth_type, default: :basic),
+          http_debug: find_option_value(:http_debug, default: false),
+        })
+      end
+
+      private
+
+      def find_option_value(key, default: nil, prompt: nil)
+        if prompt
+          find_option_value_or_prompt(key, prompt)
+        else
+          find_option_value_or_default(key, default)
+        end
+      end
+
+      def find_option_val(key)
+        @options[key] || @config[key] || ENV["JIRA_#{key.to_s.upcase}"]
+      end
+
+      def find_option_value_or_prompt(key, prompt = 'Enter value')
+        case key
+        when /password/i
+          find_option_val(key) || AbideDevUtils::Prompt.password
+        when /username/i
+          find_option_val(key) || AbideDevUtils::Prompt.username
+        else
+          find_option_val(key) || AbideDevUtils::Prompt.single_line(prompt)
+        end
+      end
+
+      def find_option_value_or_default(key, default)
+        find_option_val(key) || default
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/jira/dry_run.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative '../output'
+
+module AbideDevUtils
+  module Jira
+    module DryRun
+      def dry_run(*method_names)
+        method_names.each do |method_name|
+          proxy = Module.new do
+            define_method(method_name) do |*args, **kwargs|
+              if !!@dry_run
+                case method_name
+                when %r{^create}
+                  AbideDevUtils::Output.simple("DRY RUN: #{self.class.name}##{method_name}(#{args[0]}, #{kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')})")
+                  sleep 0.1
+                  return DummyIssue.new if args[0].match?(%r{^issue$})
+                  return DummySubtask.new if args[0].match?(%r{^subtask$})
+                when %r{^find}
+                  AbideDevUtils::Output.simple("DRY RUN: #{self.class.name}##{method_name}(#{args[0]}, #{kwargs.inspect})")
+                  return DummyIssue.new if args[0].match?(%r{^issue$})
+                  return DummySubtask.new if args[0].match?(%r{^subtask$})
+                  return DummyProject.new if args[0].match?(%r{^project$})
+                  return [] if args[0].match?(%r{^issues_by_jql$})
+
+                  "Dummy #{args[0].capitalize}"
+                else
+                  AbideDevUtils::Output.simple("DRY RUN: #{self.class.name}##{method_name}(#{args.map(&:inspect).join(', ')}, #{kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')})")
+                end
+              else
+                super(*args, **kwargs)
+              end
+            end
+          end
+          self.prepend(proxy)
+        end
+      end
+
+      def dry_run_simple(*method_names)
+        method_names.each do |method_name|
+          proxy = Module.new do
+            define_method(method_name) do |*args, **kwargs|
+              return if !!@dry_run
+
+              super(*args, **kwargs)
+            end
+          end
+          self.prepend(proxy)
+        end
+      end
+
+      def dry_run_return_true(*method_names)
+        method_names.each do |method_name|
+          proxy = Module.new do
+            define_method(method_name) do |*args, **kwargs|
+              return true if !!@dry_run
+
+              super(*args, **kwargs)
+            end
+          end
+          self.prepend(proxy)
+        end
+      end
+
+      def dry_run_return_false(*method_names)
+        method_names.each do |method_name|
+          proxy = Module.new do
+            define_method(method_name) do |*args, **kwargs|
+              return false if !!@dry_run
+
+              super(*args, **kwargs)
+            end
+          end
+          self.prepend(proxy)
+        end
+      end
+
+      class Dummy
+        attr_reader :dummy
+
+        def initialize(*_args, **_kwargs)
+          @dummy = true
+        end
+      end
+
+      class DummyIssue < Dummy
+        attr_reader :summary, :key
+
+        def initialize(summary = 'Dummy Issue', key = 'DUM-111')
+          super
+          @summary = summary
+          @key = key
+        end
+
+        def labels
+          @labels ||= ['abide_dev_utils']
+        end
+
+        def attrs
+          {
+            'fields' => {
+              'project' => 'dummy',
+              'priority' => 'dummy',
+            },
+          }
+        end
+      end
+
+      class DummySubtask < DummyIssue
+        def initialize(summary = 'Dummy Subtask', key = 'DUM-222')
+          super(summary, key)
+        end
+
+        def attrs
+          {
+            'fields' => {
+              'project' => 'dummy',
+              'priority' => 'dummy',
+              'parent' => DummyIssue.new,
+            },
+          }
+        end
+      end
+
+      class DummyProject < Dummy
+        attr_reader :key, :issues
+
+        def initialize(key = 'DUM', issues = [DummyIssue.new, DummySubtask.new])
+          super
+          @key = 'DUM'
+          @issues = [DummyIssue.new, DummySubtask.new]
+        end
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/jira/finder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../errors/jira'
+
+module AbideDevUtils
+  module Jira
+    class Finder
+      def initialize(client)
+        @client = client
+      end
+
+      def myself
+        client.User.myself
+      end
+
+      # @param id [String] The project key or ID
+      def project(id)
+        return id if id.is_a?(client.Project.target_class)
+
+        client.Project.find(id)
+      end
+
+      # @param id [String] The issue key  or summary
+      def issue(id)
+        return id if id.is_a?(client.Issue.target_class)
+
+        client.Issue.find(id)
+      rescue URI::InvalidURIError
+        iss = client.Issue.all.find { |i| i.summary == id }
+        raise AbideDevUtils::Errors::Jira::FindIssueError, id if iss.nil?
+
+        iss
+      end
+
+      # @param jql [String] The JQL query
+      # @return [Array<JIRA::Resource::Issue>]
+      def issues_by_jql(jql)
+        client.Issue.jql(jql, max_results: 1000)
+      end
+
+      # @param id [String] The issuetype ID or name
+      def issuetype(id)
+        return id if id.is_a?(client.Issuetype.target_class)
+
+        if id.match?(%r{^\d+$})
+          client.Issuetype.find(id)
+        else
+          client.Issuetype.all.find { |i| i.name == id }
+        end
+      end
+
+      # @param id [String] The priority ID or name
+      def priority(id)
+        return id if id.is_a?(client.Priority.target_class)
+
+        if id.match?(%r{^\d+$})
+          client.Priority.find(id)
+        else
+          client.Priority.all.find { |i| i.name == id }
+        end
+      end
+
+      private
+
+      attr_reader :client
+    end
+  end
+end

data/lib/abide_dev_utils/jira/helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'dry_run'
+
+module AbideDevUtils
+  module Jira
+    class Helper
+      extend DryRun
+
+      dry_run_simple :add_issue_label
+      dry_run_return_false :summary_exist?
+
+      def initialize(client, dry_run: false)
+        @client = client
+        @dry_run = dry_run
+      end
+
+      # @param project [JIRA::Resource::Project, String]
+      def all_project_issues_attrs(project)
+        project = @client.find(:project, project)
+        project.issues.collect(&:attrs)
+      end
+
+      # @param issue [JIRA::Resource::Issue, String]
+      # @param label [String]
+      def add_issue_label(issue, label)
+        issue = @client.find(:issue, issue)
+        return if issue.labels.include?(label)
+
+        issue.labels << label
+        issue.save
+      end
+
+      # @param summary [String]
+      # @param issue_attrs [Array<Hash>]
+      def summary_exist?(summary, issue_attrs)
+        issue_attrs.any? { |attrs| attrs['fields'].key?('summary') && attrs['fields']['summary'] == summary }
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/jira/issue_builder.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative '../errors/jira'
+
+module AbideDevUtils
+  module Jira
+    class IssueBuilder
+      CUSTOM_FIELDS = {
+        'epic_link' => 'customfield_10014',
+        'epic_name' => 'customfield_10011',
+      }.freeze
+
+      FIELD_DEFAULTS = {
+        'issuetype' => 'Task',
+        'priority' => 'Medium',
+        'labels' => ['abide_dev_utils'],
+      }.freeze
+
+      REQUIRED_FIELDS = %w[project summary].freeze
+
+      def initialize(client, finder)
+        @client = client
+        @finder = finder
+      end
+
+      def can_create?(type)
+        respond_to?("create_#{type}".to_sym, true)
+      end
+
+      def create(type, **fields)
+        type = type.to_s.downcase.to_sym
+        raise ArgumentError, "Invalid type \"#{type}\"; no method \"create_#{type}\"" unless can_create?(type)
+
+        fields = process_fields(fields)
+        send("create_#{type}".to_sym, **fields)
+      end
+
+      private
+
+      attr_reader :client
+
+      def create_issue(**fields)
+        iss = client.Issue.build
+        iss.save({ 'fields' => fields })
+        iss
+      rescue StandardError => e
+        raise AbideDevUtils::Errors::Jira::CreateIssueError, e
+      end
+
+      def create_subtask(**fields)
+        fields['parent'] = find_if_not_type(:issue, client.Issue.target_class, fields['parent'])
+        issue_fields = fields['parent'].attrs['fields']
+        fields['project'] = issue_fields['project']
+        fields['issuetype'] = find_if_not_type(:issuetype, client.Issuetype.target_class, 'Sub-task')
+        fields['priority'] = issue_fields['priority']
+        iss = client.Issue.build
+        iss.save({ 'fields' => fields })
+        iss
+      rescue StandardError => e
+        raise AbideDevUtils::Errors::Jira::CreateSubtaskError, e
+      end
+
+      def process_fields(fields)
+        fields = fields.dup
+        normalize_field_keys!(fields)
+        validate_required_fields!(fields)
+        normalize_field_values(fields)
+      end
+
+      def validate_required_fields!(fields)
+        missing = REQUIRED_FIELDS.reject { |f| fields.key?(f) }
+        raise "Missing required field(s) \"#{missing}\"; present fields: \"#{fields.keys}\"" unless missing.empty?
+      end
+
+      def normalize_field_keys!(fields)
+        fields.transform_keys! { |k| k.to_s.downcase }
+        fields.transform_keys! { |k| CUSTOM_FIELDS[k] || k }
+      end
+
+      def normalize_field_values(fields)
+        fields = FIELD_DEFAULTS.merge(fields).map do |k, v|
+          v = case k
+              when 'labels'
+                v.is_a?(Array) ? v : [v]
+              when 'issuetype'
+                find_if_not_type(:issuetype, client.Issuetype.target_class, v)
+              when 'parent'
+                find_if_not_type(:issue, client.Issue.target_class, v)
+              when 'priority'
+                find_if_not_type(:priority, client.Priority.target_class, v)
+              when 'epic_link', CUSTOM_FIELDS['epic_link']
+                find_if_not_type(:issue, client.Issue.target_class, v)&.key || v
+              when 'project'
+                find_if_not_type(:project, client.Project.target_class, v)
+              else
+                v
+              end
+          [k, v]
+        end
+        fields.to_h
+      end
+
+      def find_if_not_type(typesym, typeklass, obj)
+        return obj if obj.is_a?(typeklass)
+
+        @finder.send(typesym, obj)
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/jira.rb

@@ -5,6 +5,7 @@ require 'abide_dev_utils/output'
 require 'abide_dev_utils/prompt'
 require 'abide_dev_utils/config'
 require 'abide_dev_utils/errors/jira'
+require_relative 'jira/client'
 
 module AbideDevUtils
   module Jira
@@ -14,236 +15,182 @@ module AbideDevUtils
     UPD_EPIC_SUMMARY_PREFIX = '::BENCHMARK UPDATE::'
     PROGRESS_BAR_FORMAT = '%a %e %P% Created: %c of %C'
 
-    def self.project(client, project)
-      client.Project.find(project)
-    end
-
-    def self.issue(client, issue)
-      client.Issue.find(issue)
-    rescue URI::InvalidURIError
-      iss = client.Issue.all.find { |i| i.summary == issue }
-      raise ERRORS::FindIssueError, issue unless iss
-
-      iss
-    end
-
-    def self.myself(client)
-      client.User.myself
-    end
-
-    def self.issuetype(client, id)
-      if id.match?(%r{^\d+$})
-        client.Issuetype.find(id)
-      else
-        client.Issuetype.all.find { |i| i.name == id }
-      end
-    end
-
-    def self.priority(client, id)
-      if id.match?(%r{^\d+$})
-        client.Priority.find(id)
-      else
-        client.Priority.all.find { |i| i.name == id }
-      end
-    end
-
-    def self.all_project_issues_attrs(project)
-      raw_issues = project.issues
-      raw_issues.collect(&:attrs)
-    end
-
-    def self.add_issue_label(iss, label, dry_run: false)
-      return if dry_run || iss.labels.include?(label)
-
-      iss.labels << profile_summary
-      iss.save
-    end
-
-    def self.new_issue(client, project, summary, description: nil, labels: ['abide_dev_utils'], epic: nil, dry_run: false)
-      if dry_run
-        sleep(0.2)
-        return Dummy.new(summary)
-      end
-      fields = {}
-      fields['summary'] = summary
-      fields['project'] = project(client, project)
-      fields['issuetype'] = issuetype(client, 'Task')
-      fields['priority'] = priority(client, '3')
-      fields['description'] = description if description
-      fields['labels'] = labels
-      epic = issue(client, epic) if epic && !epic.is_a?(JIRA::Resource::Issue)
-      fields['customfield_10006'] = epic.key if epic # Epic_Link
-      iss = client.Issue.build
-      raise ERRORS::CreateIssueError, iss.attrs unless iss.save({ 'fields' => fields })
-
-      iss
-    end
-
-    def self.new_epic(client, project, summary, dry_run: false)
-      AbideDevUtils::Output.simple("#{dr_prefix(dry_run)}Creating epic '#{summary}'")
-      if dry_run
-        sleep(0.2)
-        return Dummy.new(summary)
-      end
-      fields = {
-        'summary' => summary,
-        'project' => project(client, project),
-        'issuetype' => issuetype(client, 'Epic'),
-        'customfield_10007' => summary, # Epic Name
-      }
-      iss = client.Issue.build
-      raise ERRORS::CreateEpicError, iss.attrs unless iss.save({ 'fields' => fields })
-
-      iss
-    end
-
-    # This should probably be threaded in the future
-    def self.bulk_new_issue(client, project, summaries, dry_run: false)
-      summaries.each { |s| new_issue(client, project, s, dry_run: dry_run) }
-    end
-
-    def self.new_subtask(client, issue, summary, dry_run: false)
-      if dry_run
-        sleep(0.2)
-        return Dummy.new
-      end
-      issue_fields = issue.attrs['fields']
-      fields = {}
-      fields['parent'] = issue
-      fields['summary'] = summary
-      fields['project'] = issue_fields['project']
-      fields['issuetype'] = issuetype(client, '5')
-      fields['priority'] = issue_fields['priority']
-      subtask = client.Issue.build
-      raise ERRORS::CreateSubtaskError, subtask.attrs unless subtask.save({ 'fields' => fields })
-
-      subtask
-    end
+    def self.client(memo: true, dry_run: false, **options)
+      return AbideDevUtils::Jira::Client.new(dry_run: dry_run, **options) unless memo
 
-    def self.bulk_new_subtask(client, issue, summaries, dry_run: false)
-      summaries.each do |s|
-        new_subtask(client, issue, s, dry_run: dry_run)
-      end
-    end
-
-    def self.client(options: {})
-      opts = merge_options(options)
-      return client_from_prompts if opts.empty?
-
-      opts[:username] = AbideDevUtils::Prompt.username if opts[:username].nil?
-      opts[:password] = AbideDevUtils::Prompt.password if opts[:password].nil?
-      opts[:site] = AbideDevUtils::Prompt.single_line('Jira URL') if opts[:site].nil?
-      opts[:context_path] = '' if opts[:context_path].nil?
-      opts[:auth_type] = :basic if opts[:auth_type].nil?
-      JIRA::Client.new(opts)
-    end
-
-    def self.client_from_prompts(http_debug: false)
-      options = {}
-      options[:username] = AbideDevUtils::Prompt.username
-      options[:password] = AbideDevUtils::Prompt.password
-      options[:site] = AbideDevUtils::Prompt.single_line('Jira URL')
-      options[:context_path] = ''
-      options[:auth_type] = :basic
-      options[:http_debug] = http_debug
-      JIRA::Client.new(options)
-    end
-
-    def self.project_from_prompts(http_debug: false)
-      client = client_from_prompts(http_debug)
-      project = AbideDevUtils::Prompt.single_line('Project').upcase
-      client.Project.find(project)
+      @client ||= AbideDevUtils::Jira::Client.new(dry_run: dry_run, **options)
     end
 
     def self.new_issues_from_coverage(client, project, report, dry_run: false)
       dr_prefix = dry_run ? 'DRY RUN: ' : ''
-      i_attrs = all_project_issues_attrs(project)
+      client(dry_run: dry_run) # Initializes the client if needed
+      i_attrs = client.helper.all_project_issues_attrs(project)
       rep_sums = summaries_from_coverage_report(report)
       rep_sums.each do |k, v|
-        next if summary_exist?(k, i_attrs)
+        next if client.helper.summary_exist?(k, i_attrs)
 
-        parent = new_issue(client, project.attrs['key'], k.to_s, dry_run: dry_run)
-        AbideDevUtils::Output.simple("#{dr_prefix}Created parent issue #{k}")
-        parent_issue = issue(client, parent.attrs['key']) unless parent.respond_to?(:dummy)
+        AbideDevUtils::Output.simple("#{dr_prefix}Creating parent issue #{k}...")
+        parent = client.create(:issue, project: project, summary: k.to_s)
         AbideDevUtils::Output.simple("#{dr_prefix}Creating subtasks, this can take a while...")
         progress = AbideDevUtils::Output.progress(title: "#{dr_prefix}Creating Subtasks", total: nil)
         v.each do |s|
-          next if summary_exist?(s, i_attrs)
+          next if client.helper.summary_exist?(s, i_attrs)
 
           progress.title = "#{dr_prefix}#{s}"
-          new_subtask(client, parent_issue, s, dry_run: dry_run)
+          client.create(:subtask, parent: parent, summary: s)
           progress.increment
         end
       end
     end
 
-    def self.new_issues_from_xccdf(client, project, xccdf_path, epic: nil, dry_run: false)
-      i_attrs = all_project_issues_attrs(project)
+    ToCreateData = Struct.new(:summary, :labels, :should_create, :metadata)
+
+    def self.new_issues_from_xccdf(project, xccdf_path, epic: nil, dry_run: false, explain: false, label_include: nil)
+      client(dry_run: dry_run) # Initializes the client if needed
+      i_attrs = client.helper.all_project_issues_attrs(project)
       xccdf = AbideDevUtils::XCCDF::Benchmark.new(xccdf_path)
       # We need to get the actual epic Issue object, or create it if it doesn't exist
       epic = if epic.nil?
                new_epic_summary = "#{COV_PARENT_SUMMARY_PREFIX}#{xccdf.title}"
-               if summary_exist?(new_epic_summary, i_attrs)
-                 issue(client, new_epic_summary)
+               if client.helper.summary_exist?(new_epic_summary, i_attrs)
+                 client.find(:issue, new_epic_summary)
                else
                  unless AbideDevUtils::Prompt.yes_no("#{dr_prefix(dry_run)}Create new epic '#{new_epic_summary}'?")
                    AbideDevUtils::Output.simple("#{dr_prefix(dry_run)}Aborting")
                    exit(0)
                  end
-                 new_epic(client, project.key, new_epic_summary, dry_run: dry_run)
+                 client.create(:issue, project: project, summary: new_epic_summary, issuetype: 'Epic', epic_name: new_epic_summary)
                end
              else
-               issue(client, epic)
+               client.find(:issue, epic)
              end
       # Now we need to find out which issues we need to create for the benchmark
       # The profiles that the control belongs to will be added as an issue label
-      to_create = {}
+      to_create = []
       summaries_from_xccdf(xccdf).each do |profile_summary, control_summaries|
-        control_summaries.reject { |s| summary_exist?(s, i_attrs) }.each do |control_summary|
-          if to_create.key?(control_summary)
-            to_create[control_summary] << profile_summary.split.join('_').downcase
+        control_summaries.each do |control_summary|
+          existing_to_create = to_create.find { |tc| tc.summary == control_summary }
+          if existing_to_create
+            existing_to_create.labels << profile_summary.split.join('_').downcase
           else
-            to_create[control_summary] = [profile_summary.split.join('_').downcase]
+            new_to_create = ToCreateData.new(
+              summary: control_summary,
+              labels: [profile_summary.split.join('_').downcase],
+              should_create: true,
+              metadata: {
+                epic_key: epic.key,
+                project: project,
+              },
+            )
+            to_create << new_to_create
           end
         end
       end
 
-      unless AbideDevUtils::Prompt.yes_no("#{dr_prefix(dry_run)}Create #{to_create.keys.count} new Jira issues?")
+      final_to_create = filter_to_create(to_create, label_include, project, epic)
+
+      return explain_this(to_create) if explain
+
+      unless AbideDevUtils::Prompt.yes_no("#{dr_prefix(dry_run)}Create #{final_to_create.count} new Jira issues?")
         AbideDevUtils::Output.simple("#{dr_prefix(dry_run)}Aborting")
         exit(0)
       end
 
       progress = AbideDevUtils::Output.progress(title: "#{dr_prefix(dry_run)}Creating issues",
-                                                total: to_create.keys.count,
+                                                total: final_to_create.count,
                                                 format: PROGRESS_BAR_FORMAT)
-      to_create.each do |control_summary, labels|
-        abrev = control_summary.length > 40 ? control_summary[0..60] : control_summary
+      final_to_create.each do |tc|
+        abrev = tc.summary.length > 40 ? tc.summary[0..60] : tc.summary
         progress.log("#{dr_prefix(dry_run)}Creating #{abrev}...")
-        new_issue(client, project.key, control_summary, labels: labels, epic: epic, dry_run: dry_run)
+        client.create(:issue, project: project, summary: tc.summary, labels: tc.labels, epic_link: epic)
         progress.increment
       end
       progress.finish
       AbideDevUtils::Output.simple("#{dr_prefix(dry_run)}Done creating tasks in Epic '#{epic.summary}'")
     end
 
-    def self.new_issues_from_xccdf_diff(client, project, xccdf1_path, xccdf2_path, epic: nil, dry_run: false, auto_approve: false, diff_opts: {})
+    def self.filter_to_create(to_create, label_include, project, epic)
+      not_already_exists = filter_already_exists(to_create, project, epic)
+      AbideDevUtils::Output.simple(
+        "Filtered out #{to_create.count - not_already_exists.count} issues that already existed",
+      )
+      only_label_include = filter_label_include(not_already_exists, label_include)
+      AbideDevUtils::Output.simple(
+        "Filtered out #{not_already_exists.count - only_label_include.count} issues that didn't include the label #{label_include}",
+      )
+      only_label_include
+    end
+
+    def self.filter_already_exists(to_create, project, epic)
+      AbideDevUtils::Output.simple('Checking if issues already exist...')
+      project = client.find(:project, project)
+      epic = client.find(:issue, epic)
+      issues = client.find(:issues_by_jql, "project = \"#{project.key}\" AND 'Epic Link' = \"#{epic.key}\"")
+      to_create.reject do |tc|
+        if issues.any? { |i| i.summary == tc.summary }
+          tc.metadata[:already_exists] = true
+          tc.should_create = false
+          true
+        else
+          tc.metadata[:already_exists] = false
+          false
+        end
+      end
+    end
+
+    # If we have a label_include, we need to filter out any controls that don't have that label
+    def self.filter_label_include(to_create, label_include)
+      return to_create if label_include.nil?
+
+      AbideDevUtils::Output.simple("Filtering out controls that don't match label include: #{label_include}")
+      to_create.select do |tc|
+        if tc.labels.any? { |l| l.match?(label_include) }
+          tc.metadata[:label_include] = true
+          true
+        else
+          tc.metadata[:label_include] = false
+          tc.should_create = false
+          false
+        end
+      end
+    end
+
+    def self.explain_this(to_create)
+      should_create = to_create.select(&:should_create)
+      should_not_create = to_create.reject(&:should_create)
+      AbideDevUtils::Output.simple(AbideDevUtils::Output.simple_section_separator('EXPLAIN'))
+      AbideDevUtils::Output.simple("Will create #{should_create.count} issues")
+      AbideDevUtils::Output.simple("Will not create #{should_not_create.count} issues")
+      AbideDevUtils::Output.simple(AbideDevUtils::Output.simple_section_separator('WILL CREATE'))
+      should_create.each do |tc|
+        AbideDevUtils::Output.simple("\"#{tc.summary}\"; labels: #{tc.labels}; metadata: #{tc.metadata}")
+      end
+      AbideDevUtils::Output.simple(AbideDevUtils::Output.simple_section_separator('WILL NOT CREATE'))
+      should_not_create.each do |tc|
+        AbideDevUtils::Output.simple("\"#{tc.summary}\"; labels: #{tc.labels}; metadata: #{tc.metadata}")
+      end
+      exit(0)
+    end
+
+    def self.new_issues_from_xccdf_diff(project, xccdf1_path, xccdf2_path, epic: nil, dry_run: false, auto_approve: false, diff_opts: {})
       require 'abide_dev_utils/xccdf/diff'
       diff = AbideDevUtils::XCCDF::Diff::BenchmarkDiff.new(xccdf1_path, xccdf2_path, diff_opts)
-      i_attrs = all_project_issues_attrs(project)
+      client(dry_run: dry_run) # Initializes the client if needed
+      i_attrs = client.helper.all_project_issues_attrs(project)
       # We need to get the actual epic Issue object, or create it if it doesn't exist
       epic = if epic.nil?
-               new_epic_summary = "#{UPD_EPIC_SUMMARY_PREFIX}#{diff.this.title}: v#{diff.this.version} -> #{diff.other.version}"
-               if summary_exist?(new_epic_summary, i_attrs)
-                 issue(client, new_epic_summary)
+               new_epic_summary = "#{COV_PARENT_SUMMARY_PREFIX}#{xccdf.title}"
+               if client.helper.summary_exist?(new_epic_summary, i_attrs)
+                 client.find(:issue, new_epic_summary)
                else
-                 unless AbideDevUtils::Prompt.yes_no("#{dr_prefix(dry_run)}Create new epic '#{new_epic_summary}'?", auto_approve: auto_approve)
+                 unless AbideDevUtils::Prompt.yes_no("#{dr_prefix(dry_run)}Create new epic '#{new_epic_summary}'?")
                    AbideDevUtils::Output.simple("#{dr_prefix(dry_run)}Aborting")
                    exit(0)
                  end
-                 new_epic(client, project.key, new_epic_summary, dry_run: dry_run)
+                 client.create(:issue, project: project, summary: new_epic_summary, issuetype: 'Epic', epic_name: new_epic_summary)
                end
              else
-               issue(client, epic)
+               client.find(:issue, epic)
              end
       to_create = {}
       diff.diff[:rules].each do |key, val|
@@ -285,7 +232,7 @@ module AbideDevUtils
                                                 format: PROGRESS_BAR_FORMAT)
       approved_create.each do |summary, description|
         progress.log("#{dr_prefix(dry_run)}Creating #{summary}...")
-        new_issue(client, project.key, summary, description: description, labels: [], epic: epic, dry_run: dry_run)
+        client.create(:issue, project: project, summary: summary, description: description, labels: [], epic_link: epic)
         progress.increment
       end
       progress.finish

data/lib/abide_dev_utils/output.rb

@@ -10,6 +10,14 @@ require 'abide_dev_utils/files'
 module AbideDevUtils
   module Output
     FWRITER = AbideDevUtils::Files::Writer.new
+    def self.simple_section_separator(section_text, sepchar: '#', width: 60, **_)
+      section_text = section_text.to_s
+      section_text = section_text[0..width - 4] if section_text.length > width
+      section_text = " #{section_text} "
+      section_sep_line = sepchar * width
+      [section_sep_line, section_text.center(width, sepchar), section_sep_line].join("\n")
+    end
+
     def self.simple(msg, stream: $stdout, **_)
       case msg
       when Hash

data/lib/abide_dev_utils/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abide_dev_utils
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.17.1
 platform: ruby
 authors:
 - abide-team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-07 00:00:00.000000000 Z
+date: 2023-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.23'
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.23'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: puppet-strings
   requirement: !ruby/object:Gem::Requirement
@@ -322,16 +322,16 @@ dependencies:
   name: fast_gettext
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.0'
 description: Provides a CLI with helpful utilities for developing compliance Puppet
   code
 email:
@@ -404,6 +404,12 @@ files:
 - lib/abide_dev_utils/files.rb
 - lib/abide_dev_utils/gcloud.rb
 - lib/abide_dev_utils/jira.rb
+- lib/abide_dev_utils/jira/client.rb
+- lib/abide_dev_utils/jira/client_builder.rb
+- lib/abide_dev_utils/jira/dry_run.rb
+- lib/abide_dev_utils/jira/finder.rb
+- lib/abide_dev_utils/jira/helper.rb
+- lib/abide_dev_utils/jira/issue_builder.rb
 - lib/abide_dev_utils/markdown.rb
 - lib/abide_dev_utils/mixins.rb
 - lib/abide_dev_utils/output.rb
@@ -463,7 +469,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
 summary: Helper utilities for developing compliance Puppet code