release-notes 2.0.0 → 3.0.0

data/lib/release/notes/git.rb

@@ -2,41 +2,76 @@
 
 module Release
   module Notes
-    module Git
-      module_function
-
-      extend ActiveSupport::Concern
-
-      included do
-        delegate :all_labels, :grep_insensitive?,
-                 :regex_type, :include_merges?, to: :"Release::Notes.configuration"
+    class Git
+      class << self
+        include Configurable
+        DEFAULT_TAG = "HEAD"
 
+        #
+        # Returns a string matching the following format: "hash - message\n"
+        # for all commits falling within the tag_from and tag_to threshold
+        # taking account the relevant label, invert grep options, and log format
+        #
+        # @param **opts
+        #
+        # @return [String] git log entries between tag_from and tag_to that include the word(s) in label,
+        # taking into account the invert grep and log_format flags specified.
+        #
         def log(**opts)
           "git log '#{opts[:tag_from]}'..'#{opts[:tag_to]}'" \
             " --grep='#{opts[:label]}#{opts[:invert_grep]}'" \
-            " #{regex_type} #{grep_insensitive?}" \
-            " #{include_merges?} --format='%h #{log_format}'"
+            " #{config_regex_type} #{config_grep_insensitive?}" \
+            " #{config_include_merges?} --format='%h #{log_format}'"
         end
-      end
 
-      def log_format
-        "- %s"
-      end
+        #
+        # Returns the git hash of the first commit.
+        #
+        # @return [String] the first commit hash.
+        #
+        def first_commit
+          "git rev-list --max-parents=0 #{DEFAULT_TAG}"
+        end
 
-      def first_commit
-        "git rev-list --max-parents=0 HEAD"
-      end
+        #
+        # Returns the latest git tag.
+        #
+        # @return [String] the most recent tag.
+        #
+        def last_tag
+          "git describe --abbrev=0 --tags"
+        end
 
-      def last_tag
-        "git describe --abbrev=0 --tags"
-      end
+        #
+        # Returns the date and time of the latest tag.
+        #
+        # @param [String] a git tag
+        #
+        # @return [String] the most recent tag date.
+        #
+        def tag_date(tag)
+          "git log -1 --format=%ai #{tag}"
+        end
 
-      def tag_date(tag)
-        "git log -1 --format=%ai #{tag}"
-      end
+        #
+        # Returns an array of all tags in the git log
+        #
+        # @return [Array] all git tags
+        #
+        def read_all_tags
+          "git for-each-ref --sort=taggerdate --format='%(tag)' refs/tags"
+        end
+
+        private
 
-      def read_all_tags
-        "git tag | sort -u -r"
+        #
+        # Returns a string representing the git log format flag
+        #
+        # @return [String] git log format flag
+        #
+        def log_format
+          "- %s"
+        end
       end
     end
   end

data/lib/release/notes/link.rb

@@ -6,8 +6,15 @@ module Release
       extend ActiveSupport::Concern
 
       included do
-        delegate :link_to_labels, :link_to_sites, :link_to_humanize, to: :"Release::Notes.configuration"
+        include Configurable
 
+        #
+        # Link log messages
+        #
+        # @param [String] lines - log messages for a git tag
+        #
+        # @return [String] log messages that can be linked
+        #
         def link_lines(lines:)
           @new_lines = ""
           split_lines(lines)
@@ -16,33 +23,59 @@ module Release
 
         private
 
-        # @api private
+        #
+        # Format lines or add link if log message should be linked
+        #
+        # @param [String] lines - log messages for a given git commit
+        #
+        # @return [Array] label log messages should be linked to
+        #
         def split_lines(lines)
-          lines.split("\n").each do |line|
-            unless link_to_labels&.any? { |la| line.include? la }
-              @new_lines += "#{line}\n"
+          lines.split(NEWLINE).each do |line|
+            unless config_link_to_labels&.any? { |la| line.include? la }
+              @new_lines += "#{line}#{NEWLINE}"
               next
             end
             split_words(line)
           end
         end
 
-        # @api private
+        #
+        # Determine if log message has a pre-determined label
+        #
+        # @param [String] line - a line from the log messages
+        #
+        # @return none
+        #
         def split_words(line)
-          link_to_labels.each_with_index do |label, i|
+          config_link_to_labels.each_with_index do |label, i|
             next unless line.include? label
 
             replace_lines(line, label, i)
           end
         end
 
-        # @api private
+        #
+        # Replace a word in the changelog
+        #
+        # @param [String line - a line from the log messages
+        # @param [String] label - a specified label
+        # @param [Integer] index - index of log message
+        #
+        # @return none
+        #
         def replace_lines(line, label, index)
           replace_words(line.split(/\s/))
-          @new_lines += "#{replace(line, @word, label, index)}\n" if @word
+          @new_lines += "#{replace(line, @word, label, index)}#{NEWLINE}" if @word
         end
 
-        # @api private
+        #
+        # Replace words if log message
+        #
+        # @param [Array] words - split git log message
+        #
+        # @return [String] word to replace in the log message
+        #
         def replace_words(words)
           words.each do |word|
             next unless (word =~ /^#.*/)&.zero?
@@ -51,11 +84,20 @@ module Release
           end
         end
 
-        # @api private
+        #
+        # Replace log messages with linked messages
+        #
+        # @param [String] line - log message to replace
+        # @param [String] issue_number - word to replace
+        # @param [String] label - label to replace with
+        # @param [Integer] index - index of the linked site
+        #
+        # @return [String] formatted linked line
+        #
         def replace(line, issue_number, label, index)
           identifier = "#{label.split(/\s/)[0]} #{issue_number}"
-          humanized = "#{link_to_humanize[index]} #{issue_number}"
-          linked = "[#{humanized}](#{link_to_sites[index]}\/#{issue_number.tr('^0-9', '')})"
+          humanized = "#{config_link_to_humanize[index]} #{issue_number}"
+          linked = "[#{humanized}](#{config_link_to_sites[index]}\/#{issue_number.tr('^0-9', '')})"
 
           line.gsub! identifier, linked
           line

data/lib/release/notes/log.rb

@@ -3,140 +3,108 @@
 module Release
   module Notes
     class Log
-      include System
-      delegate :force_rewrite, :all_labels, :log_all, :header_title,
-               :header_title_type, :features, :bugs, :misc, :feature_title,
-               :bug_title, :misc_title, :log_all_title, :single_label,
-               :release_notes_exist?, to: :"Release::Notes.configuration"
-
-      delegate :date_humanized, :format_tag_date, to: :date_formatter
-      delegate :digest_header, :digest_title, to: :writer
-
-      def initialize
-        @_commits = []
-      end
+      include Configurable
 
+      #
+      # Release::Notes::Log initializer
+      #
+      # @return none
+      #
       def perform
-        if release_notes_exist? && !force_rewrite
-          # Find the last tag and group all commits
-          # under a date header at the time this is run
-          find_last_tag_and_log
-        else
+        if log_from_start?
           # Find all tags and get the logs between each tag
           # run this the first time if nothing exists
           find_all_tags_and_log_all
+        else
+          # Find the last tag and group all commits
+          # under a date header at the time this is run
+          find_last_tag_and_log
         end
+
         writer.write_new_file
       end
 
       private
 
-      # @api private
-      def copy_single_tag_of_activity(tag_from:, tag_to: "HEAD")
-        [features, bugs, misc].each_with_index do |regex, i|
-          log = system_log(tag_from: tag_from, tag_to: tag_to, label: regex, log_all: log_all)
-          log_grouped_commits(title: titles[i], log: log)
-        end
-
-        return unless log_all
-
-        log = system_log(tag_from: tag_from, tag_to: tag_to)
-        log_grouped_commits(title: log_all_title, log: log)
-      end
-
-      # @api private
-      def date_formatter
-        @date_formatter ||= Release::Notes::DateFormat.new
-      end
-
-      # @api private
+      #
+      # Find the most recent git tag
+      #
+      # @return [Array] most recent git tag
+      #
       def find_last_tag_and_log
-        last_tag = system_last_tag.strip
-        # return false unless system_log(tag_from: last_tag, label: all_labels).present?
-        if system_log(tag_from: last_tag, label: all_labels).blank?
-          log_last
-          return
-        end
-        # output the date right now
-        header_content date: date_humanized, tag: tag_to
-        copy_single_tag_of_activity(tag_from: last_tag)
+        tag_logger(System.last_tag.strip, previous_tag(0))
       end
 
-      # @api private
+      #
+      # Get all git tags and add to the changelog
+      #
+      # @return [Array] all the git tags
+      #
       def find_all_tags_and_log_all
         git_all_tags.each_with_index do |ta, i|
-          header_content(
-            date: date_humanized(date: System.tag_date(tag: ta)),
-            tag: ta,
-          )
-
-          copy_single_tag_of_activity(
-            tag_from: previous_tag(i).strip,
-            tag_to: ta,
-          )
+          tag_logger(ta, previous_tag(i))
         end
       end
 
-      # @api private
-      def log_last
-        header_content date: date_humanized, tag: git_all_tags[0]
-        copy_single_tag_of_activity(tag_from: git_all_tags[1], tag_to: git_all_tags[0])
+      #
+      # Check whether to start from the beginning of the git log
+      #
+      # @return [Boolean] append to changelog or start from beginning of git log
+      #
+      def log_from_start?
+        !config_release_notes_exist? || config_force_rewrite
       end
 
-      # @api private
+      #
+      # All tags in the git log
+      #
+      # @return [Array] all git tags
+      #
       def git_all_tags
-        @git_all_tags ||= System.all_tags.split("\n")
-      end
-
-      # @api private
-      def header_content(**date_and_tag)
-        digest_header(date_and_tag[header_title_type.to_sym])
+        @git_all_tags ||= System.all_tags.split(NEWLINE).reverse
       end
 
-      # @api private
-      def log_grouped_commits(log:, title:)
-        return unless log.present?
-
-        log_messages = log.split("\n").map { |x| x.split(/(?=-)/) }
-        commit_hashes = log_messages.flat_map { |msg| msg[0].strip }
-
-        trimmed_commit_hashes = trim_commit_hashes(commit_hashes)
-
-        digest_unique_messages(log_messages, trimmed_commit_hashes, title) if trimmed_commit_hashes.present?
-      end
-
-      # @api private
-      def digest_unique_messages(log_messages, commit_hashes, title)
-        messages = log_messages.map do |msg|
-          msg[1..-1].join if commit_hashes.include?(msg[0].strip)
-        end.compact
-
-        @_commits += commit_hashes
-
-        digest_title(title: title, log_message: "#{messages.join("\n")}\n")
-      end
-
-      # @api private
-      def trim_commit_hashes(commit_hashes)
-        commit_hashes.dup.each do |commit|
-          commit_hashes.delete commit if single_label && @_commits.include?(commit)
-        end
-        commit_hashes
+      #
+      # Second to last tag in the git log
+      #
+      # @param [Integer] index - index of the git tags array
+      #
+      # @return [String] second most recent git tag
+      #
+      def previous_tag(index)
+        git_all_tags[index + 1].yield_self { |t| tag(t) }.strip
       end
 
-      # @api private
-      def previous_tag(index)
-        git_all_tags[index + 1].present? ? git_all_tags[index + 1] : System.first_commit
+      #
+      # Get the next git tag or the first tag
+      #
+      # @param [String] git_tag - a git tag
+      #
+      # @return [String] most recent git tag or the first git tag
+      #
+      def tag(git_tag)
+        git_tag.present? ? git_tag : System.first_commit
       end
 
-      # @api private
-      def titles
-        [feature_title, bug_title, misc_title]
+      #
+      # Create a Release::Notes::Tag object
+      #
+      # @param [String] tag - tag to
+      # @param [String] previous_tag - tag from
+      #
+      # @return [Object] Release::Notes::Tag object
+      #
+      def tag_logger(tag, previous_tag)
+        Tag.new(tag: tag, previous_tag: previous_tag, writer: writer).perform
       end
 
-      # @api private
+      #
+      # Create write object containing the header, title, and log messages for a given tag
+      #
+      # @return [Object] Release::Notes::Write object
+      #
       def writer
-        @writer ||= Release::Notes::Write.new
+        @writer ||= Write.new
       end
     end
   end

data/lib/release/notes/prettify.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Release
+  module Notes
+    class Prettify
+      include Configurable
+      attr_reader :line
+
+      #
+      # Release::Notes::Prettify initializer
+      #
+      # @param [String] line - a line from the git log
+      #
+      def initialize(line:)
+        @line = line
+      end
+
+      #
+      # Perform method for Release::Notes::Prettify
+      #
+      # @return [String] log message
+      #
+      def perform
+        line.gsub(labels_regex, "").strip
+      end
+
+      private
+
+      #
+      #  Holds the regular expression used to match a pattern against labels
+      #
+      # @return [Regexp] regex containing all labels
+      #
+      def labels_regex
+        Regexp.new config_all_labels, Regexp::IGNORECASE
+      end
+    end
+  end
+end