issue_scheduler 0.1.1

data/lib/issue_scheduler/config.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module IssueScheduler
+  # Manage the configuration for the YCA EOL Dashboard program
+  # @api public
+  class Config
+    # Create a new Config object from a given YAML config
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     { username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #
+    # @param config_hash [Hash] the config object as a hash
+    #
+    def initialize(config_hash)
+      @config = DEFAULT_VALUES.merge(config_hash)
+      assert_no_unexpected_keys(config)
+      assert_all_values_are_non_nil(config)
+    end
+
+    # The username to use when authenticating with Jira
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     { username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.username #=> 'user'
+    #
+    # @return [String] the username
+    #
+    def username
+      config[:username]
+    end
+
+    # The password to use when authenticating with Jira
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     { username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.password #=> 'pass'
+    #
+    # @return [String] the password
+    #
+    def password
+      config[:password]
+    end
+
+    # The URL of the Jira server
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     { username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.site #=> 'https://jira.mydomain.com'
+    #
+    # @return [String] the Jira URL
+    #
+    def site
+      config[:site]
+    end
+
+    # The context path to append to the Jira server URL
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     { username: user, password: pass, site: https://jira.mydomain.com, context_path: /jira, auth_type: basic }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.context_path #=> '/jira'
+    #
+    # @return [String] the context path
+    #
+    def context_path
+      config[:context_path]
+    end
+
+    # The authentication type to use when authenticating with Jira
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     { username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.auth_type #=> 'basic'
+    #
+    # @return ['basic', 'oauth'] the authentication type
+    #
+    def auth_type
+      config[:auth_type]
+    end
+
+    # The glob pattern to use to find issue files
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     {
+    #       username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic,
+    #       issue_templates: 'config/**/*.yaml'
+    #     }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.issue_templates #=> 'config/**/*.yaml'
+    #
+    # @return [String] the glob pattern
+    #
+    # @see https://ruby-doc.org/core-3.1.2/Dir.html#method-c-glob Dir.glob
+    #
+    def issue_templates
+      config[:issue_templates]
+    end
+
+    # Load the issue templates from the configured glob pattern(s) in issue_templates
+    #
+    # @example
+    #   config_yaml = <<~CONFIG
+    #     {
+    #       username: user, password: pass, site: https://jira.mydomain.com, auth_type: basic,
+    #       issue_templates: 'config/**/*.yaml'
+    #     }
+    #   CONFIG
+    #   config = IssueScheduler::Config.new(config_yaml)
+    #   config.load_issue_templates
+    #   IssueScheduler::IssueTemplate.size #=> number of issue templates loaded from config/**/*.yaml
+    #
+    # @return [void] as a side effect the issue templates are loaded
+    #
+    def load_issue_templates
+      Dir[*Array(issue_templates)].each do |file|
+        template_hash = { name: file, **IssueScheduler.load_yaml(file) }
+        template = IssueScheduler::IssueTemplate.new(template_hash)
+        if template.valid?
+          template.save
+        else
+          warn "Skipping invalid issue template #{file}: #{template.errors.full_messages.join(', ')}"
+        end
+      end
+    end
+
+    # The config in the form of a Hash
+    #
+    # @example
+    #   config = IssueScheduler::Config.new(<<~YAML)
+    #     username: jcouball
+    #     password: my_password
+    #     site: https://jira.example.com
+    #     context_path: ''
+    #     auth_type: basic
+    #     issue_templates: '~/scheduled_issues/**/*.yaml'
+    #   YAML
+    #   config.to_h #=> { 'username' => 'jcouball', 'password' => 'my_password', ... }
+    #
+    # @return [Hash] the config
+    #
+    def to_h
+      config
+    end
+
+    # Creates an options hash suitable to pass to Jira::Client.new
+    #
+    # @example
+    #   config = IssueScheduler::Config.new(<<~YAML)
+    #     username: jcouball
+    #     password: my_password
+    #     site: https://jira.example.com
+    #     context_path: ''
+    #     auth_type: basic
+    #     issue_templates: '~/scheduled_issues/**/*.yaml'
+    #   YAML
+    #   config.to_jira_options #=> {
+    #     username: 'jcouball',
+    #     password: 'my_password',
+    #     site: 'https://jira.example.com',
+    #     context_path: '',
+    #     auth_type: 'basic'
+    #   }
+    #
+    # @return [Hash] the options hash
+    #
+    def to_jira_options
+      config.slice(:username, :password, :site, :context_path, :auth_type)
+    end
+
+    private
+
+    # Raise a RuntimeError if the config contains unexpected keys
+    # @raise [RuntimeError] if the config is invalid
+    # @return [Void]
+    # @api private
+    def assert_no_unexpected_keys(config_hash)
+      unexpected_keys = config_hash.keys - DEFAULT_VALUES.keys
+      raise "Unexpected configuration keys : #{unexpected_keys}" unless
+        unexpected_keys.empty?
+    end
+
+    # Raise a RuntimeError if the config contains a nil value
+    # @raise [RuntimeError] if the config is invalid
+    # @return [Void]
+    # @api private
+    def assert_all_values_are_non_nil(config_hash)
+      keys_of_missing_values = config_hash.select { |_k, v| v.nil? }.keys
+      raise "Missing configuration values: #{keys_of_missing_values}" unless
+        keys_of_missing_values.empty?
+    end
+
+    # The config hash from config_yaml
+    # @return [Hash] the config hash
+    # @api private
+    attr_reader :config
+
+    # Defines the allows keys and default values for each key
+    #
+    # A nil value indicates that the key does not have a default value and must
+    # be specified in the config_yaml.
+    #
+    # @return [Hash] the allows keys and their default values
+    # @api private
+    DEFAULT_VALUES = {
+      username: nil,
+      password: nil,
+      site: nil,
+      context_path: '',
+      auth_type: 'basic',
+      issue_templates: '~/.issue_scheduler/issue_templates/**/*.yaml'
+    }.freeze
+  end
+end

data/lib/issue_scheduler/issue_template.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_model_persistence'
+
+require 'pp'
+require 'fugit'
+
+module IssueScheduler
+  # A template for an issue
+  #
+  # @example Create a new issue template specifying all attributes
+  #   attributes = {
+  #     name: 'weekly_status_report.yaml',
+  #     cron: '0 7 * * 6', # every Friday at 7:00 AM
+  #     project: 'MYJIRA',
+  #     component: 'Management',
+  #     type: 'Story',
+  #     summary: 'Weekly status report',
+  #     description: "Update the weekly status report\n\nhttp://mydomain.com/status",
+  #     due_date: '2022-05-06'
+  #   }
+  #
+  #   template = IssueScheduler::IssueTemplate.new(attributes)
+  #
+  # @example Create a new issue template specifying only required attributes
+  #   attributes = {
+  #     name: 'weekly_status_report.yaml',
+  #     cron: '0 7 * * 6', # every Friday at 7:00 AM
+  #     project: 'MYJIRA',
+  #     summary: 'Weekly status report',
+  #   }
+  #
+  #   template = IssueScheduler::IssueTemplate.new(attributes)
+  #
+  # @api public
+  class IssueTemplate
+    include ActiveModelPersistence::Persistence
+    include ActiveModel::Validations::Callbacks
+
+    # @!attribute [rw] name
+    # The template name
+    #
+    # * name must not be present
+    # * name must be unique across all IssueTemplate objects
+    #
+    # @example
+    #   template.name #=> "weekly_status_report"
+    #
+    # @return [String] the template name
+    #
+    # @api public
+
+    attribute :name, :string
+    validates :name, presence: true
+
+    # @!attribute [rw] cron
+    # A cron string that specifies when the issue should be created
+    #
+    # * cron must be present
+    # * cron must be a valid cron string
+    #
+    # @example
+    #   # 7 AM Monday - Friday
+    #   template.cron #=> "0 7 * * 1,2,3,4,5"
+    #
+    # @return [String] the cron string
+    #
+    # @see https://github.com/floraison/fugit The fugit gem
+    #
+    # @api public
+
+    attribute :cron, :string
+    validates :cron, presence: true
+    validates_each :cron do |record, attr, value|
+      record.errors.add(attr, 'is not a valid cron string') unless Fugit.parse_cron(value)
+    end
+
+    # @!attribute [rw] project
+    # The JIRA project name
+    #
+    # * project must be present
+    # * project is upcased
+    #
+    # @example
+    #   template.project #=> "MYPROJECT"
+    #
+    # @return [String] the project name
+    #
+    # @api public
+
+    attribute :project, :string
+    validates :project, presence: true
+
+    def project=(project)
+      super(project.is_a?(String) ? project.upcase : project)
+    end
+
+    # @!attribute [rw] component
+    # The JIRA component name
+    #
+    # * component is optional and defaults to nil
+    # * component may be nil but not an empty string
+    #
+    # The component name is optional and will be set to nil if not given.
+    #
+    # @example
+    #   template.component #=> "MYCOMPONENT"
+    #
+    # @return [String] the component name
+    #
+    # @api public
+
+    attribute :component, :string, default: nil
+    validates :component, presence: true, allow_nil: true
+
+    # @!attribute [rw] summary
+    # The JIRA issue summary
+    #
+    # * summary must be present
+    #
+    # @example
+    #   template.summary #=> "Take out the trash"
+    #
+    # @return [String] the JIRA issue summary
+    #
+    # @api public
+
+    attribute :summary, :string
+    validates :summary, presence: true
+
+    # @!attribute [rw] description
+    # The JIRA issue description
+    #
+    # * description is optional and defaults to nil
+    # * description may be nil but not an empty string
+    #
+    # @example
+    #   template.description #=> "Take out the trash in:\n- kitchen\n- bathroom\n- bedroom"
+    #
+    # @return [String] the JIRA issue description
+    #
+    # @api public
+
+    attribute :description, :string, default: nil
+    validates :description, presence: true, allow_nil: true
+
+    # @!attribute [rw] type
+    # The name of the JIRA issue type
+    #
+    # * type is optional and defaults to nil
+    # * type may be nil but not an empty string
+    #
+    # @example
+    #   template.type #=> "Story"
+    #
+    # @return [String] the JIRA issue type
+    #
+    # @api public
+
+    attribute :type, :string, default: nil
+    validates :type, presence: true, allow_nil: true
+
+    # @!attribute [rw] due_date
+    # The JIRA issue due date
+    #
+    # * due_date is optional and defaults to nil
+    # * If non-nil, due_date must be a Date object or parsable by Date.parse
+    #
+    # @example
+    #   template.due_date #=> #<Date: 2022-05-03 ((2459703j,0s,0n),+0s,2299161j)>
+    #
+    # @return [Date, nil] the JIRA issue description
+    #
+    # @api public
+
+    attribute :due_date, :date
+    validates :due_date, presence: true, allow_nil: true
+
+    validates_each :due_date do |record, attr, value|
+      before_type_cast = record.due_date_before_type_cast
+      record.errors.add(attr, "'#{before_type_cast}' is not a valid date") if value.nil? && !before_type_cast.nil?
+    end
+
+    def due_date=(date)
+      @due_date_before_type_cast = date
+      super(date)
+    end
+
+    # Sets the primary key to `:name`
+    # @return [Symbol] the attribute name of the primary key
+    # @api private
+    def self.primary_key
+      :name
+    end
+
+    # The due_date supplied by the user since ActiveModel sets it to nil of invalid
+    # @return [Date, String, nil] the due_date before type cast
+    # @api private
+    attr_reader :due_date_before_type_cast
+
+    # private
+
+    # Create a new issue template from the given template_yaml
+    #
+    # @example
+    #   template_yaml = <<~YAML
+    #     template_name: Take out the trash
+    #     cron: '0 7 * * 1,2,3,4,5 America/Los_Angeles' # Mon-Fri, 7 AM UTC
+    #     project: 'MYPROJECT'
+    #     component: 'Internal'
+    #     summary: 'Take out the trash'
+    #     description: |
+    #       Take out the trash in the following rooms:
+    #       - kitchen
+    #       - bathroom
+    #       - bedroom
+    #     type: 'Story'
+    #     due_date: '2022-05-03'
+    #   YAML
+    #
+    #   template = IssueScheduler::IssueTemplate.new(template_yaml)
+    #   template.recurrance_rule #=> "FREQ=WEEKLY;INTERVAL=1;BYDAY=MO,TU,WE,TH,FR"
+    #
+    # @param template_yaml [String] the YAML string to parse
+    #
+
+    # Define getter methods for allowed keys
+    # ATTRIBUTES.each do |key, _value|
+    #   define_method(key) do
+    #     template[__method__]
+    #   end
+    # end
+
+    # private
+
+    # The template Hash read from YAML
+    # @return [Hash]
+    # @api private
+    # attr_reader :template
+
+    # Reads the config file returning a hash
+    # @raise [RuntimeError] if the config file can not be read or is not valid
+    # @return [Hash<String, String] the config hash read from config_yaml
+    # @api private
+    # def parse_template(template_yaml)
+    #   YAML.safe_load(template_yaml, permitted_classes: [Symbol, Date], aliases: true, symbolize_names: true)
+    # rescue Psych::SyntaxError => e
+    #   raise "Error parsing YAML template: #{e.message}"
+    # end
+
+    # Set default values for keys that are not given in the template
+    #
+    # @param template_from_yaml [Hash] the template from YAML
+    # @return [Hash] the template with default values
+    # @api private
+    # def template_with_default_values(template_from_yaml)
+    #   template = {}
+    #   ATTRIBUTES.each { |k, v| template[k] = v[:default] if v.key?(:default) }
+    #   template.merge!(template_from_yaml)
+    # end
+
+    # Run the conversion functions for values that are given in the template
+    #
+    # @return [Void] the template is modified in place
+    # @api private
+    # def run_value_conversions!
+    #   template.each do |key, value|
+    #     if (conversion = ATTRIBUTES.dig(key, :conversion))
+    #       template[key] = conversion.call(value)
+    #     end
+    #   end
+    # end
+
+    # Raise a RuntimeError if any validation method returns false
+    #
+    # @raise [RuntimeError] if the config is invalid
+    # @return [Void]
+    # @api private
+    # def assert_all_values_are_valid
+    #   template.each do |key, value|
+    #     if (validation = ATTRIBUTES.dig(key, :validation)) && !validation.call(value)
+    #       raise "Invalid value for #{key}: #{value.pretty_inspect}"
+    #     end
+    #   end
+    # end
+
+    # Raise a RuntimeError if the config is not a Hash
+    # @raise [RuntimeError] if the config is invalid
+    # @return [Void]
+    # @api private
+    # def assert_template_is_an_object(template_from_yaml)
+    #   raise "YAML issue template is not an object, contained '#{template_from_yaml}'" unless
+    #     template_from_yaml.is_a?(Hash)
+    # end
+
+    # Raise a RuntimeError if the config contains unexpected keys
+    # @raise [RuntimeError] if the config is invalid
+    # @return [Void]
+    # @api private
+    # def assert_no_unexpected_keys
+    #   unexpected_keys = template.keys - ATTRIBUTES.keys
+    #   raise "Unexpected issue template keys: #{unexpected_keys}" unless
+    #     unexpected_keys.empty?
+    # end
+
+    # Raise a RuntimeError if the config contains a nil value
+    # @raise [RuntimeError] if the config is invalid
+    # @return [Void]
+    # @api private
+    # def assert_all_required_keys_are_given
+    #   required_attributes = ATTRIBUTES.select { |_, v| v[:required] }.keys
+    #   missing_keys = required_attributes - template.keys
+    #   raise "Missing issue template keys: #{missing_keys}" unless
+    #     missing_keys.empty?
+    # end
+  end
+end

data/lib/issue_scheduler/server.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'pp'
+require 'sidekiq'
+require 'sidekiq-cron'
+require 'issue_scheduler'
+require 'jira-ruby'
+
+issue_config = IssueScheduler::Config.new(IssueScheduler.load_yaml('config/config.yaml'))
+issue_config.load_issue_templates
+
+Sidekiq.configure_client do |config|
+  config.redis = { db: 1 }
+end
+
+Sidekiq.configure_server do |config|
+  config.redis = { db: 1 }
+
+  config.on(:startup) do
+    Sidekiq::Cron::Job.destroy_all!
+
+    IssueScheduler::IssueTemplate.all.each do |issue_template|
+      job_properties = {
+        'name' => issue_template.name,
+        'description' => issue_template.summary,
+        'cron' => issue_template.cron,
+        'class' => 'IssueWorker',
+        'args' => issue_template.name,
+        'date_as_argument' => true
+      }
+
+      job = Sidekiq::Cron::Job.new(job_properties)
+      raise "Error creating job: #{job.errors.pretty_inspect}" unless job.valid?
+
+      job.save
+    end
+  end
+end
+
+# My worker class that creates issues
+# @api private
+class IssueWorker
+  include Sidekiq::Worker
+
+  # Create an issue with the given template name
+  # @param template_name [String] the name of the template to use
+  # @param time [Time] the time to use for the issue
+  # @return [void]
+  # @api private
+  def perform(template_name, time)
+    puts "**** IssueWorker#perform called with #{template_name.pretty_inspect.chomp}, #{time.pretty_inspect.chomp}"
+
+    template = load_issue_template(template_name)
+    return unless template
+
+    create_issue(template)
+
+    puts '**** IssueWorker#perform finished'
+  end
+
+  private
+
+  # Create a Jira issue based on the following template
+  #
+  # @param template [IssueScheduler::IssueTemplate] the template to base the issue from
+  # @return [void]
+  # @api private
+  def create_issue(template)
+    puts ">>>> Creating issue with template: #{template.name}"
+
+    issue = jira_client.Issue.build
+
+    fields = { 'project' => { 'key' => template.project }, 'summary' => template.summary }
+
+    # fields['component'] = { 'key' => template.component } if template.component
+    fields['issuetype'] = { 'name' => template.type } if template.type
+    # fields['description'] = template.description if template.description
+    # fields['duedate'] = template.due_date.strftime('%Y-%m-%d') if template.due_date
+
+    issue.save({ 'fields' => fields })
+    issue.fetch
+
+    puts ">>>> Created issue #{issue.key}"
+  end
+
+  # Create and memoize a Jira Client
+  #
+  # @return [JIRA::Client] the Jira client to be used to create issues
+  # @api private
+  def jira_client
+    @jira_client ||= JIRA::Client.new(issue_config.to_jira_options)
+  end
+
+  # Create and memoize a IssueScheduler::Config
+  #
+  # @return [IssueScheduler::Config] the config to be used to create issues
+  # @api private
+  def issue_config
+    @issue_config ||= IssueScheduler::Config.new(IssueScheduler.load_yaml('config/config.yaml'))
+  end
+
+  # Load the IssueScheduler::IssueTemplate with the given name
+  #
+  # @return [IssueScheuler::IssueTemplate] the template with the given name
+  # @api private
+  def load_issue_template(template_name)
+    issue_config.load_issue_templates
+    IssueScheduler::IssueTemplate.find(template_name)
+  end
+end

data/lib/issue_scheduler/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module IssueScheduler
+  # The version of the Issue Scheduler gem
+  VERSION = '0.1.1'
+end