issue-db 1.1.0 → 1.3.0

data/lib/issue_db/database.rb

@@ -4,218 +4,274 @@ require_relative "cache"
 require_relative "models/record"
 require_relative "utils/generate"
 
-class RecordNotFound < StandardError; end
-
-class Database
-  include Cache
-  include Generate
-
-  # :param: log [Logger] a logger object to use for logging
-  # :param: client [Octokit::Client] an Octokit::Client object to use for interacting with the GitHub API
-  # :param: repo [Repository] a Repository object that represents the GitHub repository to use as the datastore
-  # :param: label [String] the label to use for issues managed in the datastore by this library
-  # :param: cache_expiry [Integer] the number of seconds to cache issues in memory (default: 60)
-  # :return: A new Database object
-  def initialize(log, client, repo, label, cache_expiry)
-    @log = log
-    @client = client
-    @repo = repo
-    @label = label
-    @cache_expiry = cache_expiry
-    @issues = nil
-    @issues_last_updated = nil
-  end
+module IssueDB
+  class RecordNotFound < StandardError; end
+
+  class Database
+    include Cache
+    include Generate
+
+    # :param: log [Logger] a logger object to use for logging
+    # :param: client [Octokit::Client] an Octokit::Client object to use for interacting with the GitHub API
+    # :param: repo [Repository] a Repository object that represents the GitHub repository to use as the datastore
+    # :param: label [String] the label to use for issues managed in the datastore by this library
+    # :param: cache_expiry [Integer] the number of seconds to cache issues in memory (default: 60)
+    # :return: A new Database object
+    def initialize(log, client, repo, label, cache_expiry)
+      @log = log
+      @client = client
+      @repo = repo
+      @label = label
+      @cache_expiry = cache_expiry
+      @issues = nil
+      @issues_last_updated = nil
+    end
 
-  # Create a new issue/record in the database
-  # This will return the newly created issue as a Record object (parsed)
-  # :param: key [String] the key (issue title) to create
-  # :param: data [Hash] the data to use for the issue body
-  # :param: options [Hash] a hash of options containing extra data such as body_before and body_after
-  # :return: The newly created issue as a Record object
-  # usage example:
-  # data = { color: "blue", cool: true, popularity: 100, tags: ["tag1", "tag2"] }
-  # options = { body_before: "some text before the data", body_after: "some text after the data", include_closed: true }
-  # db.create("event123", {cool: true, data: "here"}, options)
-  def create(key, data, options = {})
-    @log.debug("attempting to create: #{key}")
-    issue = find_issue_by_key(key, options, create_mode: true)
-    if issue
-      @log.warn("skipping issue creation and returning existing issue - an issue already exists with the key: #{key}")
+    # Create a new issue/record in the database
+    # This will return the newly created issue as a Record object (parsed)
+    # :param: key [String] the key (issue title) to create
+    # :param: data [Hash] the data to use for the issue body
+    # :param: options [Hash] a hash of options containing extra data such as body_before, body_after, labels, and assignees
+    # :return: The newly created issue as a Record object
+    # usage example:
+    # data = { color: "blue", cool: true, popularity: 100, tags: ["tag1", "tag2"] }
+    # options = { body_before: "some text before the data", body_after: "some text after the data", include_closed: true, labels: ["priority:high", "bug"], assignees: ["username1", "username2"] }
+    # db.create("event123", {cool: true, data: "here"}, options)
+    def create(key, data, options = {})
+      @log.debug("attempting to create: #{key}")
+      issue = find_issue_by_key(key, options, create_mode: true)
+      if issue
+        @log.warn("skipping issue creation and returning existing issue - an issue already exists with the key: #{key}")
+        return Record.new(issue)
+      end
+
+      # if we make it here, no existing issues were found so we can safely create one
+
+      body = generate(data, body_before: options[:body_before], body_after: options[:body_after])
+
+      # Prepare labels array - always include the library-managed label for create operations
+      labels = [@label]
+      if options[:labels] && options[:labels].is_a?(Array)
+        # Add user-provided labels but ensure the library label is not duplicated
+        user_labels = options[:labels].reject { |label| label == @label }
+        labels.concat(user_labels)
+      end
+
+      # Prepare API options hash
+      api_options = { labels: labels }
+
+      # Add assignees if provided
+      if options[:assignees] && options[:assignees].is_a?(Array)
+        api_options[:assignees] = options[:assignees]
+      end
+
+      # if we make it here, no existing issues were found so we can safely create one
+      issue = @client.create_issue(@repo.full_name, key, body, api_options)
+
+      # ensure the cache is initialized before appending and handle race conditions
+      current_issues = issues
+      if current_issues && !current_issues.include?(issue)
+        @issues << issue
+      end
+
+      @log.debug("issue created: #{key}")
       return Record.new(issue)
     end
 
-    # if we make it here, no existing issues were found so we can safely create one
-
-    body = generate(data, body_before: options[:body_before], body_after: options[:body_after])
-
-    # if we make it here, no existing issues were found so we can safely create one
-    issue = @client.create_issue(@repo.full_name, key, body, { labels: @label })
-
-    # ensure the cache is initialized before appending and handle race conditions
-    current_issues = issues
-    if current_issues && !current_issues.include?(issue)
-      @issues << issue
+    # Read an issue/record from the database
+    # This will return the issue as a Record object (parsed)
+    # :param: key [String] the key (issue title) to read
+    # :param: options [Hash] a hash of options to pass through to the search method
+    # :return: The issue as a Record object
+    def read(key, options = {})
+      @log.debug("attempting to read: #{key}")
+      issue = find_issue_by_key(key, options)
+      @log.debug("issue found: #{key}")
+      return Record.new(issue)
     end
 
-    @log.debug("issue created: #{key}")
-    return Record.new(issue)
-  end
-
-  # Read an issue/record from the database
-  # This will return the issue as a Record object (parsed)
-  # :param: key [String] the key (issue title) to read
-  # :param: options [Hash] a hash of options to pass through to the search method
-  # :return: The issue as a Record object
-  def read(key, options = {})
-    @log.debug("attempting to read: #{key}")
-    issue = find_issue_by_key(key, options)
-    @log.debug("issue found: #{key}")
-    return Record.new(issue)
-  end
-
-  # Update an issue/record in the database
-  # This will return the updated issue as a Record object (parsed)
-  # :param: key [String] the key (issue title) to update
-  # :param: data [Hash] the data to use for the issue body
-  # :param: options [Hash] a hash of options containing extra data such as body_before and body_after
-  # :return: The updated issue as a Record object
-  # usage example:
-  # data = { color: "blue", cool: true, popularity: 100, tags: ["tag1", "tag2"] }
-  # options = { body_before: "some text before the data", body_after: "some text after the data", include_closed: true }
-  # db.update("event123", {cool: true, data: "here"}, options)
-  def update(key, data, options = {})
-    @log.debug("attempting to update: #{key}")
-    issue = find_issue_by_key(key, options)
-
-    body = generate(data, body_before: options[:body_before], body_after: options[:body_after])
-
-    updated_issue = @client.update_issue(@repo.full_name, issue.number, key, body)
-
-    # update the issue in the cache using the reference we have
-    index = @issues.index(issue)
-    if index
-      @issues[index] = updated_issue
-    else
-      @log.warn("issue not found in cache during update: #{key}")
-      # Force a cache refresh to ensure consistency
-      update_issue_cache!
+    # Update an issue/record in the database
+    # This will return the updated issue as a Record object (parsed)
+    # :param: key [String] the key (issue title) to update
+    # :param: data [Hash] the data to use for the issue body
+    # :param: options [Hash] a hash of options containing extra data such as body_before, body_after, labels, and assignees
+    # :return: The updated issue as a Record object
+    # usage example:
+    # data = { color: "blue", cool: true, popularity: 100, tags: ["tag1", "tag2"] }
+    # options = { body_before: "some text before the data", body_after: "some text after the data", include_closed: true, labels: ["priority:high", "bug"], assignees: ["username1", "username2"] }
+    # db.update("event123", {cool: true, data: "here"}, options)
+    def update(key, data, options = {})
+      @log.debug("attempting to update: #{key}")
+      issue = find_issue_by_key(key, options)
+
+      body = generate(data, body_before: options[:body_before], body_after: options[:body_after])
+
+      # Prepare the API call options
+      api_options = {}
+
+      # Only modify labels if the user explicitly provides them
+      if options[:labels] && options[:labels].is_a?(Array)
+        # Prepare labels array - always include the library-managed label
+        labels = [@label]
+        # Add user-provided labels but ensure the library label is not duplicated
+        user_labels = options[:labels].reject { |label| label == @label }
+        labels.concat(user_labels)
+        api_options[:labels] = labels
+      end
+
+      # Only modify assignees if the user explicitly provides them
+      if options[:assignees] && options[:assignees].is_a?(Array)
+        api_options[:assignees] = options[:assignees]
+      end
+
+      updated_issue = @client.update_issue(@repo.full_name, issue.number, key, body, api_options)
+
+      # update the issue in the cache using the reference we have
+      index = @issues.index(issue)
+      if index
+        @issues[index] = updated_issue
+      else
+        @log.warn("issue not found in cache during update: #{key}")
+        # Force a cache refresh to ensure consistency
+        update_issue_cache!
+      end
+
+      @log.debug("issue updated: #{key}")
+      return Record.new(updated_issue)
     end
 
-    @log.debug("issue updated: #{key}")
-    return Record.new(updated_issue)
-  end
-
-  # Delete an issue/record from the database - in this context, "delete" means to close the issue as "completed"
-  # :param: key [String] the key (issue title) to delete
-  # :param: options [Hash] a hash of options to pass through to the search method
-  # :return: The deleted issue as a Record object (parsed) - it may contain useful data
-  def delete(key, options = {})
-    @log.debug("attempting to delete: #{key}")
-    issue = find_issue_by_key(key, options)
-
-    deleted_issue = @client.close_issue(@repo.full_name, issue.number)
-
-    # update the issue in the cache using the reference we have
-    index = @issues.index(issue)
-    if index
-      @issues[index] = deleted_issue
-    else
-      @log.warn("issue not found in cache during delete: #{key}")
-      # Force a cache refresh to ensure consistency
-      update_issue_cache!
+    # Delete an issue/record from the database - in this context, "delete" means to close the issue as "completed"
+    # :param: key [String] the key (issue title) to delete
+    # :param: options [Hash] a hash of options to pass through to the search method and control labels and assignees
+    # :return: The deleted issue as a Record object (parsed) - it may contain useful data
+    def delete(key, options = {})
+      @log.debug("attempting to delete: #{key}")
+      issue = find_issue_by_key(key, options)
+
+      # For delete operations, only update labels and assignees if the user explicitly provides them
+      if (options[:labels] && options[:labels].is_a?(Array)) || (options[:assignees] && options[:assignees].is_a?(Array))
+        update_options = {}
+
+        if options[:labels] && options[:labels].is_a?(Array)
+          # Prepare labels array - always include the library-managed label
+          labels = [@label]
+          # Add user-provided labels but ensure the library label is not duplicated
+          user_labels = options[:labels].reject { |label| label == @label }
+          labels.concat(user_labels)
+          update_options[:labels] = labels
+        end
+
+        if options[:assignees] && options[:assignees].is_a?(Array)
+          update_options[:assignees] = options[:assignees]
+        end
+
+        # Update the issue with new labels and/or assignees before closing
+        @client.update_issue(@repo.full_name, issue.number, update_options)
+      end
+
+      deleted_issue = @client.close_issue(@repo.full_name, issue.number)      # update the issue in the cache using the reference we have
+      index = @issues.index(issue)
+      if index
+        @issues[index] = deleted_issue
+      else
+        @log.warn("issue not found in cache during delete: #{key}")
+        # Force a cache refresh to ensure consistency
+        update_issue_cache!
+      end
+
+      @log.debug("issue deleted: #{key}")
+      # return the deleted issue as a Record object as it may contain useful data
+      return Record.new(deleted_issue)
     end
 
-    # return the deleted issue as a Record object as it may contain useful data
-    return Record.new(deleted_issue)
-  end
-
-  # List all keys in the database
-  # This will return an array of strings that represent the issue titles that are "keys" in the database
-  # :param: options [Hash] a hash of options to pass through to the search method
-  # :return: An array of strings that represent the issue titles that are "keys" in the database
-  # usage example:
-  # options = {include_closed: true}
-  # keys = db.list_keys(options)
-  def list_keys(options = {})
-    current_issues = issues
-    return [] if current_issues.nil?
-
-    keys = current_issues.select do |issue|
-      options[:include_closed] || issue[:state] == "open"
-    end.map do |issue|
-      issue[:title]
+    # List all keys in the database
+    # This will return an array of strings that represent the issue titles that are "keys" in the database
+    # :param: options [Hash] a hash of options to pass through to the search method
+    # :return: An array of strings that represent the issue titles that are "keys" in the database
+    # usage example:
+    # options = {include_closed: true}
+    # keys = db.list_keys(options)
+    def list_keys(options = {})
+      current_issues = issues
+      return [] if current_issues.nil?
+
+      keys = current_issues.select do |issue|
+        options[:include_closed] || issue[:state] == "open"
+      end.map do |issue|
+        issue[:title]
+      end
+
+      return keys
     end
 
-    return keys
-  end
-
-  # List all issues/record in the database as Record objects (parsed)
-  # This will return an array of Record objects that represent the issues in the database
-  # :param: options [Hash] a hash of options to pass through to the search method
-  # :return: An array of Record objects that represent the issues in the database
-  # usage example:
-  # options = {include_closed: true}
-  # records = db.list(options)
-  def list(options = {})
-    current_issues = issues
-    return [] if current_issues.nil?
-
-    records = current_issues.select do |issue|
-      options[:include_closed] || issue[:state] == "open"
-    end.map do |issue|
-      Record.new(issue)
+    # List all issues/record in the database as Record objects (parsed)
+    # This will return an array of Record objects that represent the issues in the database
+    # :param: options [Hash] a hash of options to pass through to the search method
+    # :return: An array of Record objects that represent the issues in the database
+    # usage example:
+    # options = {include_closed: true}
+    # records = db.list(options)
+    def list(options = {})
+      current_issues = issues
+      return [] if current_issues.nil?
+
+      records = current_issues.select do |issue|
+        options[:include_closed] || issue[:state] == "open"
+      end.map do |issue|
+        Record.new(issue)
+      end
+
+      return records
     end
 
-    return records
-  end
-
-  # Force a refresh of the issues cache
-  # This will update the issues cache with the latest issues from the repo
-  # :return: The updated issue cache as a list of issues (Hash objects not parsed)
-  def refresh!
-    update_issue_cache!
-  end
+    # Force a refresh of the issues cache
+    # This will update the issues cache with the latest issues from the repo
+    # :return: The updated issue cache as a list of issues (Hash objects not parsed)
+    def refresh!
+      update_issue_cache!
+    end
 
   protected
 
-  def not_found!(key)
-    raise RecordNotFound, "no record found for key: #{key}"
-  end
-
-  # A helper method to search through the issues cache and return the first issue that matches the given key
-  # :param: key [String] the key (issue title) to search for
-  # :param: options [Hash] a hash of options to pass through to the search method
-  # :param: create_mode [Boolean] a flag to indicate whether or not we are in create mode
-  # :return: A direct reference to the issue as a Hash object if found, otherwise throws a RecordNotFound error
-  # ... unless create_mode is true, in which case it returns nil as a signal to proceed with creating the issue
-  def find_issue_by_key(key, options = {}, create_mode: false)
-    issue = issues.find do |issue|
-      issue[:title] == key && (options[:include_closed] || issue[:state] == "open")
+    def not_found!(key)
+      raise RecordNotFound, "no record found for key: #{key}"
     end
 
-    if issue.nil?
-      @log.debug("no issue found in cache for: #{key}")
-      return nil if create_mode
-
-      not_found!(key)
+    # A helper method to search through the issues cache and return the first issue that matches the given key
+    # :param: key [String] the key (issue title) to search for
+    # :param: options [Hash] a hash of options to pass through to the search method
+    # :param: create_mode [Boolean] a flag to indicate whether or not we are in create mode
+    # :return: A direct reference to the issue as a Hash object if found, otherwise throws a RecordNotFound error
+    # ... unless create_mode is true, in which case it returns nil as a signal to proceed with creating the issue
+    def find_issue_by_key(key, options = {}, create_mode: false)
+      issue = issues.find do |issue|
+        issue[:title] == key && (options[:include_closed] || issue[:state] == "open")
+      end
+
+      if issue.nil?
+        @log.debug("no issue found in cache for: #{key}")
+        return nil if create_mode
+
+        not_found!(key)
+      end
+
+      @log.debug("issue found in cache for: #{key}")
+      return issue
     end
 
-    @log.debug("issue found in cache for: #{key}")
-    return issue
-  end
+    # A helper method to fetch all issues from the repo and update the issues cache
+    # It is cache aware
+    def issues
+      # update the issues cache if it is nil
+      update_issue_cache! if @issues.nil?
 
-  # A helper method to fetch all issues from the repo and update the issues cache
-  # It is cache aware
-  def issues
-    # update the issues cache if it is nil
-    update_issue_cache! if @issues.nil?
+      # update the cache if it has expired (with nil safety)
+      if !@issues_last_updated.nil? && (Time.now - @issues_last_updated) > @cache_expiry
+        @log.debug("issue cache expired - last updated: #{@issues_last_updated} - refreshing now")
+        update_issue_cache!
+      end
 
-    # update the cache if it has expired (with nil safety)
-    if !@issues_last_updated.nil? && (Time.now - @issues_last_updated) > @cache_expiry
-      @log.debug("issue cache expired - last updated: #{@issues_last_updated} - refreshing now")
-      update_issue_cache!
+      return @issues
     end
-
-    return @issues
   end
 end

data/lib/issue_db/models/record.rb

@@ -2,34 +2,36 @@
 
 require_relative "../utils/parse"
 
-class IssueParseError < StandardError; end
+module IssueDB
+  class IssueParseError < StandardError; end
 
-class Record
-  include Parse
+  class Record
+    include Parse
 
-  attr_reader :body_before, :data, :body_after, :source_data, :key
-  def initialize(data)
-    @key = data.title
-    @source_data = data
-    parse!
-  end
+    attr_reader :body_before, :data, :body_after, :source_data, :key
+    def initialize(data)
+      @key = data.title
+      @source_data = data
+      parse!
+    end
 
   protected
 
-  def parse!
-    if @source_data.body.nil? || @source_data.body.strip == ""
-      raise IssueParseError, "issue body is empty for issue number #{@source_data.number}"
+    def parse!
+      if @source_data.body.nil? || @source_data.body.strip == ""
+        raise IssueParseError, "issue body is empty for issue number #{@source_data.number}"
+      end
+
+      begin
+        parsed = parse(@source_data.body)
+      rescue JSON::ParserError => e
+        message = "failed to parse issue body data contents for issue number: #{@source_data.number} - #{e.message}"
+        raise IssueParseError, message
+      end
+
+      @body_before = parsed[:body_before]
+      @data = parsed[:data]
+      @body_after = parsed[:body_after]
     end
-
-    begin
-      parsed = parse(@source_data.body)
-    rescue JSON::ParserError => e
-      message = "failed to parse issue body data contents for issue number: #{@source_data.number} - #{e.message}"
-      raise IssueParseError, message
-    end
-
-    @body_before = parsed[:body_before]
-    @data = parsed[:data]
-    @body_after = parsed[:body_after]
   end
 end

data/lib/issue_db/models/repository.rb

@@ -1,22 +1,24 @@
 # frozen_string_literal: true
 
-class RepoFormatError < StandardError; end
+module IssueDB
+  class RepoFormatError < StandardError; end
 
-class Repository
-  attr_reader :owner, :repo, :full_name
-  def initialize(repo)
-    @repo = repo
-    validate!
-  end
+  class Repository
+    attr_reader :owner, :repo, :full_name
+    def initialize(repo)
+      @repo = repo
+      validate!
+    end
 
   protected
 
-  def validate!
-    if @repo.nil? || !@repo.include?("/")
-      raise RepoFormatError, "repository #{@repo} is invalid - valid format: <owner>/<repo>"
-    end
+    def validate!
+      if @repo.nil? || !@repo.include?("/")
+        raise RepoFormatError, "repository #{@repo} is invalid - valid format: <owner>/<repo>"
+      end
 
-    @full_name = @repo.strip
-    @owner, @repo = @full_name.split("/")
+      @full_name = @repo.strip
+      @owner, @repo = @full_name.split("/")
+    end
   end
 end