px_github_changelog_generator 0.0.0

data/lib/github_changelog_generator/generator/entry.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "github_changelog_generator/generator/section"
+
+module GitHubChangelogGenerator
+  # This class generates the content for a single changelog entry. An entry is
+  # generally either for a specific tagged release or the collection of
+  # unreleased changes.
+  #
+  # An entry is comprised of header text followed by a series of sections
+  # relating to the entry.
+  #
+  # @see GitHubChangelogGenerator::Generator
+  # @see GitHubChangelogGenerator::Section
+  class Entry
+    attr_reader :content
+
+    def initialize(options = Options.new({}))
+      @content = ""
+      @options = Options.new(options)
+    end
+
+    # Generates log entry with header and body
+    #
+    # @param [Array] pull_requests List or PR's in new section
+    # @param [Array] issues List of issues in new section
+    # @param [String] newer_tag_name Name of the newer tag. Could be nil for `Unreleased` section.
+    # @param [String] newer_tag_link Name of the newer tag. Could be "HEAD" for `Unreleased` section.
+    # @param [Time] newer_tag_time Time of the newer tag
+    # @param [Hash, nil] older_tag_name Older tag, used for the links. Could be nil for last tag.
+    # @return [String] Ready and parsed section content.
+    def generate_entry_for_tag(pull_requests, issues, newer_tag_name, newer_tag_link, newer_tag_time, older_tag_name) # rubocop:disable Metrics/ParameterLists
+      github_site = @options[:github_site] || "https://github.com"
+      project_url = "#{github_site}/#{@options[:user]}/#{@options[:project]}"
+
+      create_sections
+
+      @content = generate_header(newer_tag_name, newer_tag_link, newer_tag_time, older_tag_name, project_url)
+      @content += generate_body(pull_requests, issues)
+      @content
+    end
+
+    def line_labels_for(issue)
+      labels = if @options[:issue_line_labels] == ["ALL"]
+                 issue["labels"]
+               else
+                 issue["labels"].select { |label| @options[:issue_line_labels].include?(label["name"]) }
+               end
+      labels.map { |label| " \[[#{label['name']}](#{label['url'].sub('api.github.com/repos', 'github.com')})\]" }.join("")
+    end
+
+    private
+
+    # Creates section objects for this entry.
+    # @return [Nil]
+    def create_sections
+      @sections = if @options.configure_sections?
+                    parse_sections(@options[:configure_sections])
+                  elsif @options.add_sections?
+                    default_sections.concat parse_sections(@options[:add_sections])
+                  else
+                    default_sections
+                  end
+      nil
+    end
+
+    # Turns the argument from the commandline of --configure-sections or
+    # --add-sections into an array of Section objects.
+    #
+    # @param [String, Hash] sections_desc Either string or hash describing sections
+    # @return [Array] Parsed section objects.
+    def parse_sections(sections_desc)
+      require "json"
+
+      sections_desc = sections_desc.to_json if sections_desc.class == Hash
+
+      begin
+        sections_json = JSON.parse(sections_desc)
+      rescue JSON::ParserError => e
+        raise "There was a problem parsing your JSON string for sections: #{e}"
+      end
+
+      sections_json.collect do |name, v|
+        Section.new(name: name.to_s, prefix: v["prefix"], labels: v["labels"], body_only: v["body_only"], options: @options)
+      end
+    end
+
+    # Generates header text for an entry.
+    #
+    # @param [String] newer_tag_name The name of a newer tag
+    # @param [String] newer_tag_link Used for URL generation. Could be same as #newer_tag_name or some specific value, like HEAD
+    # @param [Time] newer_tag_time Time when the newer tag was created
+    # @param [String] older_tag_name The name of an older tag; used for URLs.
+    # @param [String] project_url URL for the current project.
+    # @return [String] Header text content.
+    def generate_header(newer_tag_name, newer_tag_link, newer_tag_time, older_tag_name, project_url)
+      header = ""
+
+      # Generate date string:
+      time_string = newer_tag_time.strftime(@options[:date_format])
+
+      # Generate tag name and link
+      release_url = if @options[:release_url]
+                      format(@options[:release_url], newer_tag_link)
+                    else
+                      "#{project_url}/tree/#{newer_tag_link}"
+                    end
+      header += if newer_tag_name.equal?(@options[:unreleased_label])
+                  "## [#{newer_tag_name}](#{release_url})\n\n"
+                else
+                  "## [#{newer_tag_name}](#{release_url}) (#{time_string})\n\n"
+                end
+
+      if @options[:compare_link] && older_tag_name
+        # Generate compare link
+        header += "[Full Changelog](#{project_url}/compare/#{older_tag_name}...#{newer_tag_link})\n\n"
+      end
+
+      header
+    end
+
+    # Generates complete body text for a tag (without a header)
+    #
+    # @param [Array] pull_requests
+    # @param [Array] issues
+    # @return [String] Content generated from sections of sorted issues & PRs.
+    def generate_body(pull_requests, issues)
+      sort_into_sections(pull_requests, issues)
+      @sections.map(&:generate_content).join
+    end
+
+    # Default sections to used when --configure-sections is not set.
+    #
+    # @return [Array] Section objects.
+    def default_sections
+      [
+        Section.new(name: "summary", prefix: @options[:summary_prefix], labels: @options[:summary_labels], options: @options, body_only: true),
+        Section.new(name: "breaking", prefix: @options[:breaking_prefix], labels: @options[:breaking_labels], options: @options),
+        Section.new(name: "enhancements", prefix: @options[:enhancement_prefix], labels: @options[:enhancement_labels], options: @options),
+        Section.new(name: "bugs", prefix: @options[:bug_prefix], labels: @options[:bug_labels], options: @options),
+        Section.new(name: "deprecated", prefix: @options[:deprecated_prefix], labels: @options[:deprecated_labels], options: @options),
+        Section.new(name: "removed", prefix: @options[:removed_prefix], labels: @options[:removed_labels], options: @options),
+        Section.new(name: "security", prefix: @options[:security_prefix], labels: @options[:security_labels], options: @options)
+      ]
+    end
+
+    # Sorts issues and PRs into entry sections by labels and lack of labels.
+    #
+    # @param [Array] pull_requests
+    # @param [Array] issues
+    # @return [Nil]
+    def sort_into_sections(pull_requests, issues)
+      if @options[:issues]
+        unmapped_issues = sort_labeled_issues(issues)
+        add_unmapped_section(unmapped_issues)
+      end
+      if @options[:pulls]
+        unmapped_pull_requests = sort_labeled_issues(pull_requests)
+        add_unmapped_section(unmapped_pull_requests)
+      end
+      nil
+    end
+
+    # Iterates through sections and sorts labeled issues into them based on
+    # the label mapping. Returns any unmapped or unlabeled issues.
+    #
+    # @param [Array] issues Issues or pull requests.
+    # @return [Array] Issues that were not mapped into any sections.
+    def sort_labeled_issues(issues)
+      sorted_issues = []
+      issues.each do |issue|
+        label_names = issue["labels"].collect { |l| l["name"] }
+
+        # Add PRs in the order of the @sections array. This will either be the
+        # default sections followed by any --add-sections sections in
+        # user-defined order, or --configure-sections in user-defined order.
+        # Ignore the order of the issue labels from github which cannot be
+        # controlled by the user.
+        @sections.each do |section|
+          unless (section.labels & label_names).empty?
+            section.issues << issue
+            sorted_issues << issue
+            break
+          end
+        end
+      end
+      issues - sorted_issues
+    end
+
+    # Creates a section for issues/PRs with no labels or no mapped labels.
+    #
+    # @param [Array] issues
+    # @return [Nil]
+    def add_unmapped_section(issues)
+      unless issues.empty?
+        # Distinguish between issues and pull requests
+        if issues.first.key?("pull_request")
+          name = "merged"
+          prefix = @options[:merge_prefix]
+          add_wo_labels = @options[:add_pr_wo_labels]
+        else
+          name = "issues"
+          prefix = @options[:issue_prefix]
+          add_wo_labels = @options[:add_issues_wo_labels]
+        end
+        add_issues = if add_wo_labels
+                       issues
+                     else
+                       # Only add unmapped issues
+                       issues.select { |issue| issue["labels"].any? }
+                     end
+        merged = Section.new(name: name, prefix: prefix, labels: [], issues: add_issues, options: @options) unless add_issues.empty?
+        @sections << merged
+      end
+      nil
+    end
+  end
+end

data/lib/github_changelog_generator/generator/generator.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "github_changelog_generator/octo_fetcher"
+require "github_changelog_generator/generator/generator_fetcher"
+require "github_changelog_generator/generator/generator_processor"
+require "github_changelog_generator/generator/generator_tags"
+require "github_changelog_generator/generator/entry"
+require "github_changelog_generator/generator/section"
+
+module GitHubChangelogGenerator
+  # Default error for ChangelogGenerator
+  class ChangelogGeneratorError < StandardError
+  end
+
+  # This class is the high-level code for gathering issues and PRs for a github
+  # repository and generating a CHANGELOG.md file. A changelog is made up of a
+  # series of "entries" of all tagged releases, plus an extra entry for the
+  # unreleased changes. Entries are made up of various organizational
+  # "sections," and sections contain the github issues and PRs.
+  #
+  # So the changelog contains entries, entries contain sections, and sections
+  # contain issues and PRs.
+  #
+  # @see GitHubChangelogGenerator::Entry
+  # @see GitHubChangelogGenerator::Section
+  class Generator
+    attr_accessor :options, :filtered_tags, :tag_section_mapping, :sorted_tags
+
+    CREDIT_LINE = <<~CREDIT
+      \\* *[Test] This Changelog was automatically generated \
+      by [github_changelog_generator]\
+      (https://github.com/github-changelog-generator/github-changelog-generator)*
+    CREDIT
+
+    # A Generator responsible for all logic, related with changelog generation from ready-to-parse issues
+    #
+    # Example:
+    #   generator = GitHubChangelogGenerator::Generator.new
+    #   content = generator.compound_changelog
+    def initialize(options = {})
+      @options        = options
+      @tag_times_hash = {}
+      @fetcher        = GitHubChangelogGenerator::OctoFetcher.new(options)
+      @sections       = []
+    end
+
+    # Main function to start changelog generation
+    #
+    # @return [String] Generated changelog file
+    def compound_changelog
+      @options.load_custom_ruby_files
+
+      Sync do
+        fetch_and_filter_tags
+        fetch_issues_and_pr
+
+        log = if @options[:unreleased_only]
+                generate_entry_between_tags(@filtered_tags[0], nil)
+              else
+                generate_entries_for_all_tags
+              end
+        log += File.read(@options[:base]) if File.file?(@options[:base])
+        log = remove_old_fixed_string(log)
+        log = insert_fixed_string(log)
+        @log = log
+      end
+    end
+
+    private
+
+    # Generate log only between 2 specified tags
+    # @param [String] older_tag all issues before this tag date will be excluded. May be nil, if it's first tag
+    # @param [String] newer_tag all issue after this tag will be excluded. May be nil for unreleased section
+    def generate_entry_between_tags(older_tag, newer_tag)
+      filtered_issues, filtered_pull_requests = filter_issues_for_tags(newer_tag, older_tag)
+
+      if newer_tag.nil? && filtered_issues.empty? && filtered_pull_requests.empty?
+        # do not generate empty unreleased section
+        return +""
+      end
+
+      newer_tag_link, newer_tag_name, newer_tag_time = detect_link_tag_time(newer_tag)
+
+      # If the older tag is nil, go back in time from the latest tag and find
+      # the SHA for the first commit.
+      older_tag_name =
+        if older_tag.nil?
+          @fetcher.oldest_commit["sha"]
+        else
+          older_tag["name"]
+        end
+
+      Entry.new(options).generate_entry_for_tag(filtered_pull_requests, filtered_issues, newer_tag_name, newer_tag_link, newer_tag_time, older_tag_name)
+    end
+
+    # Filters issues and pull requests based on, respectively, `actual_date`
+    # and `merged_at` timestamp fields. `actual_date` is the detected form of
+    # `closed_at` based on merge event SHA commit times.
+    #
+    # @return [Array] filtered issues and pull requests
+    def filter_issues_for_tags(newer_tag, older_tag)
+      filtered_pull_requests = filter_by_tag(@pull_requests, newer_tag)
+      filtered_issues        = delete_by_time(@issues, "actual_date", older_tag, newer_tag)
+
+      newer_tag_name = newer_tag.nil? ? nil : newer_tag["name"]
+
+      if options[:filter_issues_by_milestone]
+        # delete excess irrelevant issues (according milestones). Issue #22.
+        filtered_issues = filter_by_milestone(filtered_issues, newer_tag_name, @issues)
+        filtered_pull_requests = filter_by_milestone(filtered_pull_requests, newer_tag_name, @pull_requests)
+      end
+      [filtered_issues, filtered_pull_requests]
+    end
+
+    # The full cycle of generation for whole project
+    # @return [String] All entries in the changelog
+    def generate_entries_for_all_tags
+      puts "Generating entry..." if options[:verbose]
+
+      entries = generate_unreleased_entry
+
+      @tag_section_mapping.each_pair do |_tag_section, left_right_tags|
+        older_tag, newer_tag = left_right_tags
+        entries += generate_entry_between_tags(older_tag, newer_tag)
+      end
+
+      entries
+    end
+
+    def generate_unreleased_entry
+      entry = +""
+      if options[:unreleased]
+        start_tag        = @filtered_tags[0] || @sorted_tags.last
+        unreleased_entry = generate_entry_between_tags(start_tag, nil)
+        entry           += unreleased_entry if unreleased_entry
+      end
+      entry
+    end
+
+    # Fetches @pull_requests and @issues and filters them based on options.
+    #
+    # @return [Nil] No return.
+    def fetch_issues_and_pr
+      issues, pull_requests = @fetcher.fetch_closed_issues_and_pr
+
+      @pull_requests = options[:pulls] ? get_filtered_pull_requests(pull_requests) : []
+
+      @issues = options[:issues] ? get_filtered_issues(issues) : []
+
+      fetch_events_for_issues_and_pr
+      detect_actual_closed_dates(@issues + @pull_requests)
+      add_first_occurring_tag_to_prs(@sorted_tags, @pull_requests)
+      nil
+    end
+
+    # Remove the previously assigned fixed message.
+    # @param log [String] Old lines are fixed
+    def remove_old_fixed_string(log)
+      log.gsub!(/#{Regexp.escape(@options[:frontmatter])}/, "") if @options[:frontmatter]
+      log.gsub!(/#{Regexp.escape(@options[:header])}\n{,2}/, "")
+      log.gsub!(/\n{,2}#{Regexp.escape(CREDIT_LINE)}/, "") # Remove old credit lines
+      log
+    end
+
+    # Add template messages to given string. Previously added
+    # messages of the same wording are removed.
+    # @param log [String]
+    def insert_fixed_string(log)
+      ins = +""
+      ins += @options[:frontmatter] if @options[:frontmatter]
+      ins += "#{@options[:header]}\n\n"
+      log.insert(0, ins)
+      log += "\n\n#{CREDIT_LINE}"
+      log
+    end
+  end
+end

data/lib/github_changelog_generator/generator/generator_fetcher.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module GitHubChangelogGenerator
+  class Generator
+    # Fetch event for issues and pull requests
+    # @return [Array] array of fetched issues
+    def fetch_events_for_issues_and_pr
+      print "Fetching events for issues and PR: 0/#{@issues.count + @pull_requests.count}\r" if options[:verbose]
+
+      # Async fetching events:
+      @fetcher.fetch_events_async(@issues + @pull_requests)
+    end
+
+    # Async fetching of all tags dates
+    def fetch_tags_dates(tags)
+      print "Fetching tag dates...\r" if options[:verbose]
+      i = 0
+      tags.each do |tag|
+        get_time_of_tag(tag)
+        i += 1
+      end
+      puts "Fetching tags dates: #{i}/#{tags.count}" if options[:verbose]
+    end
+
+    # Find correct closed dates, if issues was closed by commits
+    def detect_actual_closed_dates(issues)
+      print "Fetching closed dates for issues...\r" if options[:verbose]
+
+      i = 0
+      issues.each do |issue|
+        find_closed_date_by_commit(issue)
+        i += 1
+      end
+      puts "Fetching closed dates for issues: #{i}/#{issues.count}" if options[:verbose]
+    end
+
+    # Adds a key "first_occurring_tag" to each PR with a value of the oldest
+    # tag that a PR's merge commit occurs in in the git history. This should
+    # indicate the release of each PR by git's history regardless of dates and
+    # divergent branches.
+    #
+    # @param [Array] tags The tags sorted by time, newest to oldest.
+    # @param [Array] prs The PRs to discover the tags of.
+    # @return [Nil] No return; PRs are updated in-place.
+    def add_first_occurring_tag_to_prs(tags, prs)
+      total = prs.count
+
+      prs_left = associate_tagged_prs(tags, prs, total)
+      prs_left = associate_release_branch_prs(prs_left, total)
+      prs_left = associate_rebase_comment_prs(tags, prs_left, total) if prs_left.any?
+      # PRs in prs_left will be untagged, not in release branch, and not
+      # rebased. They should not be included in the changelog as they probably
+      # have been merged to a branch other than the release branch.
+      @pull_requests -= prs_left
+      Helper.log.info "Associating PRs with tags: #{total}/#{total}"
+    end
+
+    # Associate merged PRs by the merge SHA contained in each tag. If the
+    # merge_commit_sha is not found in any tag's history, skip association.
+    #
+    # @param [Array] tags The tags sorted by time, newest to oldest.
+    # @param [Array] prs The PRs to associate.
+    # @return [Array] PRs without their merge_commit_sha in a tag.
+    def associate_tagged_prs(tags, prs, total)
+      @fetcher.fetch_tag_shas(tags)
+
+      i = 0
+      prs.reject do |pr|
+        found = false
+        # XXX Wish I could use merge_commit_sha, but gcg doesn't currently
+        # fetch that. See
+        # https://developer.github.com/v3/pulls/#get-a-single-pull-request vs.
+        # https://developer.github.com/v3/pulls/#list-pull-requests
+        if pr["events"] && (event = pr["events"].find { |e| e["event"] == "merged" })
+          # Iterate tags.reverse (oldest to newest) to find first tag of each PR.
+          if (oldest_tag = tags.reverse.find { |tag| tag["shas_in_tag"].include?(event["commit_id"]) })
+            pr["first_occurring_tag"] = oldest_tag["name"]
+            found = true
+            i += 1
+            print("Associating PRs with tags: #{i}/#{total}\r") if @options[:verbose]
+          end
+        else
+          # Either there were no events or no merged event. GitHub's api can be
+          # weird like that apparently. Check for a rebased comment before erroring.
+          no_events_pr = associate_rebase_comment_prs(tags, [pr], total)
+          raise StandardError, "No merge sha found for PR #{pr['number']} via the GitHub API" unless no_events_pr.empty?
+
+          found = true
+          i += 1
+          print("Associating PRs with tags: #{i}/#{total}\r") if @options[:verbose]
+        end
+        found
+      end
+    end
+
+    # Associate merged PRs by the HEAD of the release branch. If no
+    # --release-branch was specified, then the github default branch is used.
+    #
+    # @param [Array] prs_left PRs not associated with any tag.
+    # @param [Integer] total The total number of PRs to associate; used for verbose printing.
+    # @return [Array] PRs without their merge_commit_sha in the branch.
+    def associate_release_branch_prs(prs_left, total)
+      if prs_left.any?
+        i = total - prs_left.count
+        prs_left.reject do |pr|
+          found = false
+          if pr["events"] && (event = pr["events"].find { |e| e["event"] == "merged" }) && sha_in_release_branch?(event["commit_id"])
+            found = true
+            i += 1
+            print("Associating PRs with tags: #{i}/#{total}\r") if @options[:verbose]
+          end
+          found
+        end
+      else
+        prs_left
+      end
+    end
+
+    # Associate merged PRs by the SHA detected in github comments of the form
+    # "rebased commit: <sha>". For use when the merge_commit_sha is not in the
+    # actual git history due to rebase.
+    #
+    # @param [Array] tags The tags sorted by time, newest to oldest.
+    # @param [Array] prs_left The PRs not yet associated with any tag or branch.
+    # @return [Array] PRs without rebase comments.
+    def associate_rebase_comment_prs(tags, prs_left, total)
+      i = total - prs_left.count
+      # Any remaining PRs were not found in the list of tags by their merge
+      # commit and not found in any specified release branch. Fallback to
+      # rebased commit comment.
+      @fetcher.fetch_comments_async(prs_left)
+      prs_left.reject do |pr|
+        found = false
+        if pr["comments"] && (rebased_comment = pr["comments"].reverse.find { |c| c["body"].match(%r{rebased commit: ([0-9a-f]{40})}i) })
+          rebased_sha = rebased_comment["body"].match(%r{rebased commit: ([0-9a-f]{40})}i)[1]
+          if (oldest_tag = tags.reverse.find { |tag| tag["shas_in_tag"].include?(rebased_sha) })
+            pr["first_occurring_tag"] = oldest_tag["name"]
+            found = true
+            i += 1
+          elsif sha_in_release_branch?(rebased_sha)
+            found = true
+            i += 1
+          else
+            raise StandardError, "PR #{pr['number']} has a rebased SHA comment but that SHA was not found in the release branch or any tags"
+          end
+          print("Associating PRs with tags: #{i}/#{total}\r") if @options[:verbose]
+        else
+          puts "Warning: PR #{pr['number']} merge commit was not found in the release branch or tagged git history and no rebased SHA comment was found"
+        end
+        found
+      end
+    end
+
+    # Fill :actual_date parameter of specified issue by closed date of the commit, if it was closed by commit.
+    # @param [Hash] issue
+    def find_closed_date_by_commit(issue)
+      return if issue["events"].nil?
+
+      # if it's PR -> then find "merged event", in case of usual issue -> found closed date
+      compare_string = issue["merged_at"].nil? ? "closed" : "merged"
+      # reverse! - to find latest closed event. (event goes in date order)
+      issue["events"].reverse!.each do |event|
+        if event["event"] == compare_string
+          set_date_from_event(event, issue)
+          break
+        end
+      end
+      # TODO: assert issues, that remain without 'actual_date' hash for some reason.
+    end
+
+    # Set closed date from this issue
+    #
+    # @param [Hash] event
+    # @param [Hash] issue
+    def set_date_from_event(event, issue)
+      if event["commit_id"].nil?
+        issue["actual_date"] = issue["closed_at"]
+        return
+      end
+
+      commit = @fetcher.fetch_commit(event["commit_id"])
+      issue["actual_date"] = commit["commit"]["author"]["date"]
+
+      # issue['actual_date'] = commit['author']['date']
+    rescue StandardError
+      puts "Warning: Can't fetch commit #{event['commit_id']}. It is probably referenced from another repo."
+      issue["actual_date"] = issue["closed_at"]
+    end
+
+    private
+
+    # Detect if a sha occurs in the --release-branch. Uses the github repo
+    # default branch if not specified.
+    #
+    # @param [String] sha SHA to check.
+    # @return [Boolean] True if SHA is in the branch git history.
+    def sha_in_release_branch?(sha)
+      branch = @options[:release_branch] || @fetcher.default_branch
+      @fetcher.commits_in_branch(branch).include?(sha)
+    end
+  end
+end