px_github_changelog_generator 0.0.0

data/lib/github_changelog_generator/generator/generator_processor.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module GitHubChangelogGenerator
+  class Generator
+    # delete all issues with labels from options[:exclude_labels] array
+    # @param [Array] issues
+    # @return [Array] filtered array
+    def exclude_issues_by_labels(issues)
+      return issues if !options[:exclude_labels] || options[:exclude_labels].empty?
+
+      issues.reject do |issue|
+        labels = issue["labels"].map { |l| l["name"] }
+        (labels & options[:exclude_labels]).any?
+      end
+    end
+
+    # Only include issues without labels if options[:add_issues_wo_labels]
+    # @param [Array] issues
+    # @return [Array] filtered array
+    def exclude_issues_without_labels(issues)
+      return issues if issues.empty?
+      return issues if issues.first.key?("pull_request") && options[:add_pr_wo_labels]
+      return issues if !issues.first.key?("pull_request") && options[:add_issues_wo_labels]
+
+      issues.reject do |issue|
+        issue["labels"].empty?
+      end
+    end
+
+    # @return [Array] filtered issues accourding milestone
+    def filter_by_milestone(filtered_issues, tag_name, all_issues)
+      remove_issues_in_milestones(filtered_issues)
+      unless tag_name.nil?
+        # add missed issues (according milestones)
+        issues_to_add = find_issues_to_add(all_issues, tag_name)
+
+        filtered_issues |= issues_to_add
+      end
+      filtered_issues
+    end
+
+    # Add all issues, that should be in that tag, according milestone
+    #
+    # @param [Array] all_issues
+    # @param [String] tag_name
+    # @return [Array] issues with milestone #tag_name
+    def find_issues_to_add(all_issues, tag_name)
+      all_issues.select do |issue|
+        if (milestone = issue["milestone"]).nil?
+          false
+        # check, that this milestone in tag list:
+        elsif (tag = find_tag_for_milestone(milestone)).nil?
+          false
+        else
+          tag["name"] == tag_name
+        end
+      end
+    end
+
+    # @return [Array] array with removed issues, that contain milestones with same name as a tag
+    def remove_issues_in_milestones(filtered_issues)
+      filtered_issues.select! do |issue|
+        # leave issues without milestones
+        if (milestone = issue["milestone"]).nil?
+          true
+        # remove issues of open milestones if option is set
+        elsif milestone["state"] == "open"
+          @options[:issues_of_open_milestones]
+        else
+          # check, that this milestone in tag list:
+          find_tag_for_milestone(milestone).nil?
+        end
+      end
+    end
+
+    def find_tag_for_milestone(milestone)
+      @filtered_tags.find { |tag| tag["name"] == milestone["title"] }
+    end
+
+    # Method filter issues, that belong only specified tag range
+    #
+    # @param [Array] issues issues to filter
+    # @param [Hash, Nil] newer_tag Tag to find PRs of. May be nil for unreleased section
+    # @return [Array] filtered issues
+    def filter_by_tag(issues, newer_tag = nil)
+      issues.select do |issue|
+        issue["first_occurring_tag"] == (newer_tag.nil? ? nil : newer_tag["name"])
+      end
+    end
+
+    # Method filter issues, that belong only specified tag range
+    # @param [Array] issues issues to filter
+    # @param [Symbol] hash_key key of date value default is :actual_date
+    # @param [Hash, Nil] older_tag all issues before this tag date will be excluded. May be nil, if it's first tag
+    # @param [Hash, Nil] newer_tag all issue after this tag will be excluded. May be nil for unreleased section
+    # @return [Array] filtered issues
+    def delete_by_time(issues, hash_key = "actual_date", older_tag = nil, newer_tag = nil)
+      # in case if not tags specified - return unchanged array
+      return issues if older_tag.nil? && newer_tag.nil?
+
+      older_tag = ensure_older_tag(older_tag, newer_tag)
+
+      newer_tag_time = newer_tag && get_time_of_tag(newer_tag)
+      older_tag_time = older_tag && get_time_of_tag(older_tag)
+
+      issues.select do |issue|
+        if issue[hash_key]
+          time = Time.parse(issue[hash_key].to_s).utc
+
+          tag_in_range_old = tag_newer_old_tag?(older_tag_time, time)
+
+          tag_in_range_new = tag_older_new_tag?(newer_tag_time, time)
+
+          tag_in_range = tag_in_range_old && tag_in_range_new
+
+          tag_in_range
+        else
+          false
+        end
+      end
+    end
+
+    def ensure_older_tag(older_tag, newer_tag)
+      return older_tag if older_tag
+
+      idx = sorted_tags.index { |t| t["name"] == newer_tag["name"] }
+      # skip if we are already at the oldest element
+      return if idx == sorted_tags.size - 1
+
+      sorted_tags[idx - 1]
+    end
+
+    def tag_older_new_tag?(newer_tag_time, time)
+      if newer_tag_time.nil?
+        true
+      else
+        time <= newer_tag_time
+      end
+    end
+
+    def tag_newer_old_tag?(older_tag_time, time)
+      if older_tag_time.nil?
+        true
+      else
+        time > older_tag_time
+      end
+    end
+
+    # Include issues with labels, specified in :include_labels
+    # @param [Array] issues to filter
+    # @return [Array] filtered array of issues
+    def include_issues_by_labels(issues)
+      filtered_issues = filter_by_include_labels(issues)
+      filter_wo_labels(filtered_issues)
+    end
+
+    # @param [Array] items Issues & PRs to filter when without labels
+    # @return [Array] Issues & PRs without labels or empty array if
+    #                 add_issues_wo_labels or add_pr_wo_labels are false
+    def filter_wo_labels(items)
+      if items.any? && items.first.key?("pull_request")
+        return items if options[:add_pr_wo_labels]
+      elsif options[:add_issues_wo_labels]
+        return items
+      end
+      # The default is to filter items without labels
+      items.select { |item| item["labels"].map { |l| l["name"] }.any? }
+    end
+
+    # @todo Document this
+    # @param [Object] issues
+    def filter_by_include_labels(issues)
+      if options[:include_labels].nil?
+        issues
+      else
+        issues.select do |issue|
+          labels = issue["labels"].map { |l| l["name"] } & options[:include_labels]
+          labels.any? || issue["labels"].empty?
+        end
+      end
+    end
+
+    # General filtered function
+    #
+    # @param [Array] all_issues PRs or issues
+    # @return [Array] filtered issues
+    def filter_array_by_labels(all_issues)
+      filtered_issues = include_issues_by_labels(all_issues)
+      filtered_issues = exclude_issues_by_labels(filtered_issues)
+      exclude_issues_without_labels(filtered_issues)
+    end
+
+    # Filter issues according labels
+    # @return [Array] Filtered issues
+    def get_filtered_issues(issues)
+      issues = filter_array_by_labels(issues)
+      puts "Filtered issues: #{issues.count}" if options[:verbose]
+      issues
+    end
+
+    # This method fetches missing params for PR and filter them by specified options
+    # It include add all PR's with labels from options[:include_labels] array
+    # And exclude all from :exclude_labels array.
+    # @return [Array] filtered PR's
+    def get_filtered_pull_requests(pull_requests)
+      pull_requests = filter_array_by_labels(pull_requests)
+      pull_requests = filter_merged_pull_requests(pull_requests)
+      puts "Filtered pull requests: #{pull_requests.count}" if options[:verbose]
+      pull_requests
+    end
+
+    # This method filter only merged PR and
+    # fetch missing required attributes for pull requests
+    # :merged_at - is a date, when issue PR was merged.
+    # More correct to use merged date, rather than closed date.
+    def filter_merged_pull_requests(pull_requests)
+      print "Fetching merged dates...\r" if options[:verbose]
+      closed_pull_requests = @fetcher.fetch_closed_pull_requests
+
+      pull_requests.each do |pr|
+        fetched_pr = closed_pull_requests.find do |fpr|
+          fpr["number"] == pr["number"]
+        end
+        if fetched_pr
+          pr["merged_at"] = fetched_pr["merged_at"]
+          closed_pull_requests.delete(fetched_pr)
+        end
+      end
+
+      pull_requests.reject! do |pr|
+        pr["merged_at"].nil?
+      end
+
+      pull_requests
+    end
+  end
+end

data/lib/github_changelog_generator/generator/generator_tags.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module GitHubChangelogGenerator
+  class Generator
+    # fetch, filter tags, fetch dates and sort them in time order
+    def fetch_and_filter_tags
+      since_tag
+      due_tag
+
+      all_tags = @fetcher.fetch_all_tags
+      fetch_tags_dates(all_tags) # Creates a Hash @tag_times_hash
+      all_sorted_tags = sort_tags_by_date(all_tags)
+
+      @sorted_tags   = filter_included_tags(all_sorted_tags)
+      @sorted_tags   = filter_excluded_tags(@sorted_tags)
+      @filtered_tags = get_filtered_tags(@sorted_tags)
+      @tag_section_mapping = build_tag_section_mapping(@filtered_tags, @filtered_tags)
+
+      @filtered_tags
+    end
+
+    # @param [Array] section_tags are the tags that need a subsection output
+    # @param [Array] filtered_tags is the list of filtered tags ordered from newest -> oldest
+    # @return [Hash] key is the tag to output, value is an array of [Left Tag, Right Tag]
+    # PRs to include in this section will be >= [Left Tag Date] and <= [Right Tag Date]
+    # rubocop:disable Style/For - for allows us to be more concise
+    def build_tag_section_mapping(section_tags, filtered_tags)
+      tag_mapping = {}
+      for i in 0..(section_tags.length - 1)
+        tag = section_tags[i]
+
+        # Don't create section header for the "since" tag
+        next if since_tag && tag["name"] == since_tag
+
+        # Don't create a section header for the first tag in between_tags
+        next if options[:between_tags] && tag == section_tags.last
+
+        # Don't create a section header for excluded tags
+        next unless filtered_tags.include?(tag)
+
+        older_tag = section_tags[i + 1]
+        tag_mapping[tag] = [older_tag, tag]
+      end
+      tag_mapping
+    end
+    # rubocop:enable Style/For
+
+    # Sort all tags by date, newest to oldest
+    def sort_tags_by_date(tags)
+      puts "Sorting tags..." if options[:verbose]
+      tags.sort_by! do |x|
+        get_time_of_tag(x)
+      end.reverse!
+    end
+
+    # Returns date for given GitHub Tag hash
+    #
+    # Memoize the date by tag name.
+    #
+    # @param [Hash] tag_name
+    #
+    # @return [Time] time of specified tag
+    def get_time_of_tag(tag_name)
+      raise ChangelogGeneratorError, "tag_name is nil" if tag_name.nil?
+
+      name_of_tag = tag_name.fetch("name")
+      time_for_tag_name = @tag_times_hash[name_of_tag]
+      return time_for_tag_name if time_for_tag_name
+
+      @fetcher.fetch_date_of_tag(tag_name).tap do |time_string|
+        @tag_times_hash[name_of_tag] = time_string
+      end
+    end
+
+    # Detect link, name and time for specified tag.
+    #
+    # @param [Hash] newer_tag newer tag. Can be nil, if it's Unreleased section.
+    # @return [Array] link, name and time of the tag
+    def detect_link_tag_time(newer_tag)
+      # if tag is nil - set current time
+      newer_tag_time = newer_tag.nil? ? Time.new.getutc : get_time_of_tag(newer_tag)
+
+      # if it's future release tag - set this value
+      if newer_tag.nil? && options[:future_release]
+        newer_tag_name = options[:future_release]
+        newer_tag_link = options[:future_release]
+      else
+        # put unreleased label if there is no name for the tag
+        newer_tag_name = newer_tag.nil? ? options[:unreleased_label] : newer_tag["name"]
+        newer_tag_link = newer_tag.nil? ? "HEAD" : newer_tag_name
+      end
+      [newer_tag_link, newer_tag_name, newer_tag_time]
+    end
+
+    # @return [Object] try to find newest tag using #Reader and :base option if specified otherwise returns nil
+    def since_tag
+      @since_tag ||= options.fetch(:since_tag) { version_of_first_item }
+    end
+
+    def due_tag
+      @due_tag ||= options.fetch(:due_tag, nil)
+    end
+
+    def version_of_first_item
+      return unless File.file?(options[:base].to_s)
+
+      sections = GitHubChangelogGenerator::Reader.new.read(options[:base])
+      sections.first["version"] if sections && sections.any?
+    end
+
+    # Return tags after filtering tags in lists provided by option: --exclude-tags
+    #
+    # @return [Array]
+    def get_filtered_tags(all_tags)
+      filtered_tags = filter_since_tag(all_tags)
+      filter_due_tag(filtered_tags)
+    end
+
+    # @param [Array] all_tags all tags
+    # @return [Array] filtered tags according :since_tag option
+    def filter_since_tag(all_tags)
+      return all_tags unless (tag = since_tag)
+
+      raise ChangelogGeneratorError, "Error: can't find tag #{tag}, specified with --since-tag option." if all_tags.none? { |t| t["name"] == tag }
+
+      if (idx = all_tags.index { |t| t["name"] == tag })
+        all_tags[0..idx]
+      else
+        []
+      end
+    end
+
+    # @param [Array] all_tags all tags
+    # @return [Array] filtered tags according :due_tag option
+    def filter_due_tag(all_tags)
+      return all_tags unless (tag = due_tag)
+
+      raise ChangelogGeneratorError, "Error: can't find tag #{tag}, specified with --due-tag option." if all_tags.none? { |t| t["name"] == tag }
+
+      if (idx = all_tags.index { |t| t["name"] == tag }) > 0
+        all_tags[(idx + 1)..-1]
+      else
+        []
+      end
+    end
+
+    # @param [Array] all_tags all tags
+    # @return [Array] filtered tags according to :include_tags_regex option
+    def filter_included_tags(all_tags)
+      if options[:include_tags_regex]
+        regex = Regexp.new(options[:include_tags_regex])
+        all_tags.select { |tag| regex =~ tag["name"] }
+      else
+        all_tags
+      end
+    end
+
+    # @param [Array] all_tags all tags
+    # @return [Array] filtered tags according :exclude_tags or :exclude_tags_regex option
+    def filter_excluded_tags(all_tags)
+      if options[:exclude_tags]
+        apply_exclude_tags(all_tags)
+      elsif options[:exclude_tags_regex]
+        apply_exclude_tags_regex(all_tags)
+      else
+        all_tags
+      end
+    end
+
+    private
+
+    def apply_exclude_tags(all_tags)
+      if options[:exclude_tags].is_a?(Regexp)
+        filter_tags_with_regex(all_tags, options[:exclude_tags], "--exclude-tags")
+      else
+        filter_exact_tags(all_tags)
+      end
+    end
+
+    def apply_exclude_tags_regex(all_tags)
+      regex = Regexp.new(options[:exclude_tags_regex])
+      filter_tags_with_regex(all_tags, regex, "--exclude-tags-regex")
+    end
+
+    def filter_tags_with_regex(all_tags, regex, regex_option_name)
+      warn_if_nonmatching_regex(all_tags, regex, regex_option_name)
+      all_tags.reject { |tag| regex =~ tag["name"] }
+    end
+
+    def filter_exact_tags(all_tags)
+      options[:exclude_tags].each do |tag|
+        warn_if_tag_not_found(all_tags, tag)
+      end
+      all_tags.reject { |tag| options[:exclude_tags].include?(tag["name"]) }
+    end
+
+    def warn_if_nonmatching_regex(all_tags, regex, regex_option_name)
+      return if all_tags.any? { |t| regex.match?(t["name"]) }
+
+      Helper.log.warn "Warning: unable to reject any tag, using regex "\
+                      "#{regex.inspect} in #{regex_option_name} option."
+    end
+
+    def warn_if_tag_not_found(all_tags, tag)
+      return if all_tags.any? { |t| t["name"] == tag }
+
+      Helper.log.warn("Warning: can't find tag #{tag}, specified with --exclude-tags option.")
+    end
+  end
+end

data/lib/github_changelog_generator/generator/section.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module GitHubChangelogGenerator
+  # This class generates the content for a single section of a changelog entry.
+  # It turns the tagged issues and PRs into a well-formatted list of changes to
+  # be later incorporated into a changelog entry.
+  #
+  # @see GitHubChangelogGenerator::Entry
+  class Section
+    # @return [String]
+    attr_accessor :name
+
+    # @return [String] a merge prefix, or an issue prefix
+    attr_reader :prefix
+
+    # @return [Array<Hash>]
+    attr_reader :issues
+
+    # @return [Array<String>]
+    attr_reader :labels
+
+    # @return [Boolean]
+    attr_reader :body_only
+
+    # @return [Options]
+    attr_reader :options
+
+    def initialize(opts = {})
+      @name = opts[:name]
+      @prefix = opts[:prefix]
+      @labels = opts[:labels] || []
+      @issues = opts[:issues] || []
+      @options = opts[:options] || Options.new({})
+      @body_only = opts[:body_only] || false
+      @entry = Entry.new(options)
+    end
+
+    # Returns the content of a section.
+    #
+    # @return [String] Generated section content
+    def generate_content
+      content = +""
+
+      if @issues.any?
+        content += "#{@prefix}\n\n" unless @options[:simple_list] || @prefix.blank?
+        @issues.each do |issue|
+          merge_string = get_string_for_issue(issue)
+          content += "- " unless @body_only
+          content += "#{merge_string}\n"
+        end
+        content += "\n"
+      end
+      content
+    end
+
+    private
+
+    # Parse issue and generate single line formatted issue line.
+    #
+    # Example output:
+    # - Add coveralls integration [\#223](https://github.com/github-changelog-generator/github-changelog-generator/pull/223) (@github-changelog-generator)
+    #
+    # @param [Hash] issue Fetched issue from GitHub
+    # @return [String] Markdown-formatted single issue
+    def get_string_for_issue(issue)
+      encapsulated_title = encapsulate_string issue["title"]
+
+      title_with_number = "#{encapsulated_title} [\\##{issue['number']}](#{issue['html_url']})"
+      title_with_number = "#{title_with_number}#{@entry.line_labels_for(issue)}" if @options[:issue_line_labels].present?
+      line = issue_line_with_user(title_with_number, issue)
+      issue_line_with_body(line, issue)
+    end
+
+    def issue_line_with_body(line, issue)
+      return normalize_body(issue["body"]) if @body_only && issue["body"].present?
+      return line if !@options[:issue_line_body] || issue["body"].blank?
+
+      # get issue body till first line break
+      body_paragraph = body_till_first_break(normalize_body(issue["body"]))
+      # remove spaces from beginning of the string
+      body_paragraph.rstrip!
+      # encapsulate to md
+      encapsulated_body = "  \n#{encapsulate_string(body_paragraph)}"
+
+      "**#{line}** #{encapsulated_body}"
+    end
+
+    # Normalize line endings from CRLF to LF
+    def normalize_body(body)
+      body.gsub(/\r?\n/, "\n")
+    end
+
+    def body_till_first_break(body)
+      body.split(/\n/, 2).first
+    end
+
+    def issue_line_with_user(line, issue)
+      return line if !@options[:author] || issue["pull_request"].nil?
+
+      user = issue["user"]
+      return "#{line} ({Null user})" unless user
+
+      if @options[:usernames_as_github_logins]
+        "#{line} (@#{user['login']})"
+      else
+        "#{line} ([#{user['login']}](#{user['html_url']}))"
+      end
+    end
+
+    ENCAPSULATED_CHARACTERS = %w(< > * _ \( \) [ ] #)
+
+    # Encapsulate characters to make Markdown look as expected.
+    #
+    # @param [String] string
+    # @return [String] encapsulated input string
+    def encapsulate_string(string)
+      string = string.gsub('\\', '\\\\')
+
+      ENCAPSULATED_CHARACTERS.each do |char|
+        # Only replace char with escaped version if it isn't inside backticks (markdown inline code).
+        # This relies on each opening '`' being closed (ie an even number in total).
+        # A char is *outside* backticks if there is an even number of backticks following it.
+        string = string.gsub(%r{#{Regexp.escape(char)}(?=([^`]*`[^`]*`)*[^`]*$)}, "\\#{char}")
+      end
+
+      string
+    end
+  end
+end

data/lib/github_changelog_generator/helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "logger"
+require "rainbow"
+
+module GitHubChangelogGenerator
+  module Helper
+    # @return true if the currently running program is a unit test
+    def self.test?
+      defined? SpecHelper
+    end
+
+    # :nocov:
+    @log ||= if test?
+               Logger.new(nil) # don't show any logs when running tests
+             else
+               Logger.new($stdout)
+             end
+    @log.formatter = proc do |severity, _datetime, _progname, msg|
+      string = "#{msg}\n"
+      case severity
+      when "DEBUG" then Rainbow(string).magenta
+      when "INFO" then Rainbow(string).white
+      when "WARN" then Rainbow(string).yellow
+      when "ERROR" then Rainbow(string).red
+      when "FATAL" then Rainbow(string).red.bright
+      else string
+      end
+    end
+    # :nocov:
+
+    # Logging happens using this method
+    class << self
+      attr_reader :log
+    end
+  end
+end