github_changelog_generator 1.3.11 → 1.4.0

data/github_changelog_generator.gemspec

@@ -1,21 +1,21 @@
 # coding: utf-8
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'github_changelog_generator/version'
+require "github_changelog_generator/version"
 
 Gem::Specification.new do |spec|
   spec.name               = "github_changelog_generator"
   spec.version            = GitHubChangelogGenerator::VERSION
   spec.default_executable = "github_changelog_generator"
 
-  spec.required_ruby_version     = '>= 1.9.3'
+  spec.required_ruby_version     = ">= 1.9.3"
   spec.authors = ["Petr Korolev"]
-  spec.email = %q{sky4winder+github_changelog_generator@gmail.com}
+  spec.email = "sky4winder+github_changelog_generator@gmail.com"
   spec.date = `date +"%Y-%m-%d"`.strip!
-  spec.summary = %q{Script, that automatically generate changelog from your tags, issues, labels and pull requests.}
-  spec.description = %q{Changelog generation has never been so easy. Fully automate changelog generation - this gem generate change log file based on tags, issues and merged pull requests from Github issue tracker.}
-  spec.homepage = %q{https://github.com/skywinder/Github-Changelog-Generator}
+  spec.summary = "Script, that automatically generate changelog from your tags, issues, labels and pull requests."
+  spec.description = "Changelog generation has never been so easy. Fully automate changelog generation - this gem generate change log file based on tags, issues and merged pull requests from Github issue tracker."
+  spec.homepage = "https://github.com/skywinder/Github-Changelog-Generator"
   spec.license       = "MIT"
 
   spec.files = `git ls-files -z`.split("\x0")
@@ -26,7 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 
-  spec.add_runtime_dependency(%q<github_api>, ["~> 0.12"])
-  spec.add_runtime_dependency(%q<colorize>, ["~> 0.7"])
-
+  spec.add_runtime_dependency("github_api", ["~> 0.12"])
+  spec.add_runtime_dependency("colorize", ["~> 0.7"])
 end

data/lib/CHANGELOG.md

@@ -6,6 +6,8 @@
 
 **Merged pull requests:**
 
+- This PR SHOULD NOT appear in change log! [\#6](https://github.com/skywinder/changelog_test/pull/6) ([skywinder](https://github.com/skywinder))
+
 - Add automatically generated change log file. [\#5](https://github.com/skywinder/changelog_test/pull/5) ([skywinder](https://github.com/skywinder))
 
 ## [v0.0.3](https://github.com/skywinder/changelog_test/tree/v0.0.3) (2015-03-04)

data/lib/github_changelog_generator.rb

@@ -1,62 +1,65 @@
 #!/usr/bin/env ruby
 
-require 'github_api'
-require 'json'
-require 'colorize'
-require 'benchmark'
+require "github_api"
+require "json"
+require "colorize"
+require "benchmark"
 
-require_relative 'github_changelog_generator/parser'
-require_relative 'github_changelog_generator/generator'
-require_relative 'github_changelog_generator/version'
+require_relative "github_changelog_generator/parser"
+require_relative "github_changelog_generator/generator"
+require_relative "github_changelog_generator/version"
+require_relative "github_changelog_generator/reader"
+require_relative "github_changelog_generator/fetcher"
 
 module GitHubChangelogGenerator
-  class ChangelogGenerator
+  # Default error for ChangelogGenerator
+  class ChangelogGeneratorError < StandardError
+  end
 
+  # Main class and entry point for this script.
+  class ChangelogGenerator
     attr_accessor :options, :all_tags, :github
 
-    PER_PAGE_NUMBER = 30
-
+    # Class, responsible for whole change log generation cycle
+    # @return initialised instance of ChangelogGenerator
     def initialize
-
       @options = Parser.parse_options
 
-      fetch_github_token
+      @fetcher = GitHubChangelogGenerator::Fetcher.new @options
 
-      github_options = {per_page: PER_PAGE_NUMBER}
-      github_options[:oauth_token] = @github_token unless @github_token.nil?
-      github_options[:endpoint] = options[:github_endpoint] unless options[:github_endpoint].nil?
-      github_options[:site] = options[:github_endpoint] unless options[:github_site].nil?
+      @generator = Generator.new @options
 
-begin
-         @github = Github.new github_options
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
+      # @all_tags = get_filtered_tags
+      @all_tags = @fetcher.get_all_tags
 
-      @generator = Generator.new(@options)
+      @issues, @pull_requests = @fetcher.fetch_issues_and_pull_requests
 
-      @all_tags = self.get_all_tags
-      @issues, @pull_requests = self.fetch_issues_and_pull_requests
+      @pull_requests = @options[:pulls] ? get_filtered_pull_requests : []
 
-      if @options[:pulls]
-        @pull_requests = self.get_filtered_pull_requests
-      else
-        @pull_requests = []
-      end
-
-      if @options[:issues]
-        @issues = self.get_filtered_issues
-      else
-        @issues = []
-      end
+      @issues = @options[:issues] ? get_filtered_issues : []
 
       fetch_event_for_issues_and_pr
       detect_actual_closed_dates
-      @tag_times_hash = {}
     end
 
-    def detect_actual_closed_dates
+    # Return tags after filtering tags in lists provided by option: --between-tags & --exclude-tags
+    #
+    # @return [Array]
+    def get_filtered_tags
+      all_tags = @fetcher.get_all_tags
+      filtered_tags = []
+      if @options[:between_tags]
+        @options[:between_tags].each do |tag|
+          unless all_tags.include? tag
+            puts "Warning: can't find tag #{tag}, specified with --between-tags option.".yellow
+          end
+        end
+        filtered_tags = all_tags.select { |tag| @options[:between_tags].include? tag }
+      end
+      filtered_tags
+    end
 
+    def detect_actual_closed_dates
       if @options[:verbose]
         print "Fetching closed dates for issues...\r"
       end
@@ -74,32 +77,30 @@ rescue
           find_closed_date_by_commit(pull_request)
         }
       }
-      threads.each { |thr| thr.join }
+      threads.each(&:join)
 
       if @options[:verbose]
-        puts 'Fetching closed dates for issues: Done!'
+        puts "Fetching closed dates for issues: Done!"
       end
     end
 
+    # Fill :actual_date parameter of specified issue by closed date of the commit, it it was closed by commit.
+    # @param [Hash] issue
     def find_closed_date_by_commit(issue)
-      unless issue['events'].nil?
-        #if it's PR -> then find "merged event", in case of usual issue -> fond closed date
-        compare_string = issue[:merged_at].nil? ? 'closed' : 'merged'
+      unless issue["events"].nil?
+        # if it's PR -> then find "merged event", in case of usual issue -> fond 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 { |event|
+        issue["events"].reverse!.each { |event|
           if event[:event].eql? compare_string
             if event[:commit_id].nil?
               issue[:actual_date] = issue[:closed_at]
             else
               begin
-begin
-                   commit = @github.git_data.commits.get @options[:user], @options[:project], event[:commit_id]
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
+                commit = @fetcher.fetch_commit(event)
                 issue[:actual_date] = commit[:author][:date]
               rescue
-                puts "Warning: can't fetch commit #{event[:commit_id]} probably it referenced from another repo."
+                puts "Warning: Can't fetch commit #{event[:commit_id]}. It is probably referenced from another repo.".yellow
                 issue[:actual_date] = issue[:closed_at]
               end
             end
@@ -107,95 +108,92 @@ rescue
           end
         }
       end
-      #TODO: assert issues, that remain without 'actual_date' hash for some reason.
+      # TODO: assert issues, that remain without 'actual_date' hash for some reason.
     end
 
     def print_json(json)
       puts JSON.pretty_generate(json)
     end
 
-    def fetch_merged_at_pull_requests
+    # 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
+      fetch_merged_at_pull_requests
+
+      filtered_pull_requests = include_issues_by_labels(@pull_requests)
+
+      filtered_pull_requests = exclude_issues_by_labels(filtered_pull_requests)
+
       if @options[:verbose]
-        print "Fetching merged dates...\r"
+        puts "Filtered pull requests: #{filtered_pull_requests.count}"
       end
-      pull_requests = []
-begin
-         response = @github.pull_requests.list @options[:user], @options[:project], :state => 'closed'
-         page_i = 0
-         response.each_page do |page|
-           page_i += PER_PAGE_NUMBER
-           count_pages = response.count_pages
-           print "Fetching merged dates... #{page_i}/#{count_pages * PER_PAGE_NUMBER}\r"
-           pull_requests.concat(page)
-         end
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
-
 
+      filtered_pull_requests
+    end
 
-      print "                                                   \r"
+    # This method fetch missing required attributes for pull requests
+    # :merged_at - is a date, when issue PR was merged.
+    # More correct to use this date, not closed date.
+    def fetch_merged_at_pull_requests
+      if @options[:verbose]
+        print "Fetching merged dates...\r"
+      end
+      pull_requests = @fetcher.fetch_pull_requests
 
       @pull_requests.each { |pr|
         fetched_pr = pull_requests.find { |fpr|
-          fpr.number == pr.number }
+          fpr.number == pr.number
+        }
         pr[:merged_at] = fetched_pr[:merged_at]
         pull_requests.delete(fetched_pr)
       }
 
       if @options[:verbose]
-        puts 'Fetching merged dates... Done!'
+        puts "Fetching merged dates: Done!"
       end
-
     end
 
-    def get_filtered_pull_requests
-
-      self.fetch_merged_at_pull_requests
-
-      filtered_pull_requests = @pull_requests.select {|pr| pr[:merged_at] != nil }
+    # 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 = @options[:include_labels].nil? ? issues : issues.select { |issue| (issue.labels.map(&:name) & @options[:include_labels]).any? }
 
-      unless @options[:include_labels].nil?
-        filtered_pull_requests = @pull_requests.select { |issue|
-          #add all labels from @options[:incluse_labels] array
-          (issue.labels.map { |label| label.name } & @options[:include_labels]).any?
+      if @options[:add_issues_wo_labels]
+        issues_wo_labels = issues.select { |issue|
+          !issue.labels.map(&:name).any?
         }
+        filtered_issues |= issues_wo_labels
       end
+      filtered_issues
+    end
 
+    # delete all labels with labels from @options[:exclude_labels] array
+    # @param [Array] issues
+    # @return [Array] filtered array
+    def exclude_issues_by_labels(issues)
       unless @options[:exclude_labels].nil?
-        filtered_pull_requests = filtered_pull_requests.select { |issue|
-          #delete all labels from @options[:exclude_labels] array
-          !(issue.labels.map { |label| label.name } & @options[:exclude_labels]).any?
+        issues = issues.select { |issue|
+          !(issue.labels.map(&:name) & @options[:exclude_labels]).any?
         }
       end
-
-      if @options[:add_issues_wo_labels]
-        issues_wo_labels = @pull_requests.select {
-          # add issues without any labels
-            |issue| !issue.labels.map { |label| label.name }.any?
-        }
-        filtered_pull_requests |= issues_wo_labels
-      end
-
-
-      if @options[:verbose]
-        puts "Filtered pull requests: #{filtered_pull_requests.count}"
-      end
-
-      filtered_pull_requests
+      issues
     end
 
-    def compund_changelog
-
+    # The entry point of this script to generate change log
+    # @raise (ChangelogGeneratorError) Is thrown when one of specified tags was not found in list of tags.
+    def compound_changelog
       log = "# Change Log\n\n"
 
       if @options[:unreleased_only]
-        log += self.generate_log_between_tags(self.all_tags[0], nil)
+        log += generate_log_between_tags(all_tags[0], nil)
       elsif @options[:tag1] and @options[:tag2]
         tag1 = @options[:tag1]
         tag2 = @options[:tag2]
         tags_strings = []
-        self.all_tags.each { |x| tags_strings.push(x['name']) }
+        all_tags.each { |x| tags_strings.push(x["name"]) }
 
         if tags_strings.include?(tag1)
           if tags_strings.include?(tag2)
@@ -203,65 +201,63 @@ rescue
             hash = Hash[to_a]
             index1 = hash[tag1]
             index2 = hash[tag2]
-            log += self.generate_log_between_tags(self.all_tags[index1], self.all_tags[index2])
+            log += generate_log_between_tags(all_tags[index1], all_tags[index2])
           else
-            puts "Can't find tag #{tag2} -> exit"
-            exit
+            fail ChangelogGeneratorError, "Can't find tag #{tag2} -> exit".red
           end
         else
-          puts "Can't find tag #{tag1} -> exit"
-          exit
+          fail ChangelogGeneratorError, "Can't find tag #{tag1} -> exit".red
         end
       else
-        log += self.generate_log_for_all_tags
+        log += generate_log_for_all_tags
       end
 
       log += "\n\n\\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*"
 
       output_filename = "#{@options[:output]}"
-      File.open(output_filename, 'w') { |file| file.write(log) }
-      puts 'Done!'
+      File.open(output_filename, "w") { |file| file.write(log) }
+      puts "Done!"
       puts "Generated log placed in #{`pwd`.strip!}/#{output_filename}"
-
     end
 
+    # The full cycle of generation for whole project
+    # @return [String] The complete change log
     def generate_log_for_all_tags
-
       fetch_tags_dates
 
       if @options[:verbose]
-        puts "Sorting tags.."
+        puts "Sorting tags..."
       end
 
-      @all_tags.sort_by! { |x| self.get_time_of_tag(x) }.reverse!
+      @all_tags.sort_by! { |x| @fetcher.get_time_of_tag(x) }.reverse!
 
       if @options[:verbose]
-        puts "Generating log.."
+        puts "Generating log..."
       end
 
-
-      log = ''
+      log = ""
 
       if @options[:unreleased] && @all_tags.count != 0
-        unreleased_log = self.generate_log_between_tags(self.all_tags[0], nil)
+        unreleased_log = generate_log_between_tags(all_tags[0], nil)
         if unreleased_log
           log += unreleased_log
         end
       end
 
-      (1 ... self.all_tags.size).each { |index|
-        log += self.generate_log_between_tags(self.all_tags[index], self.all_tags[index-1])
+      (1...all_tags.size).each { |index|
+        log += generate_log_between_tags(all_tags[index], all_tags[index - 1])
       }
       if @all_tags.count != 0
-        log += generate_log_between_tags(nil, self.all_tags.last)
+        log += generate_log_between_tags(nil, all_tags.last)
       end
 
       log
     end
 
+    # Async fetching of all tags dates
     def fetch_tags_dates
       if @options[:verbose]
-        print "Fetching tags dates..\r"
+        print "Fetching tag dates...\r"
       end
 
       # Async fetching tags:
@@ -269,96 +265,46 @@ rescue
       i = 0
       all = @all_tags.count
       @all_tags.each { |tag|
-        # explicit set @tag_times_hash to write data safety.
         threads << Thread.new {
-          self.get_time_of_tag(tag, @tag_times_hash)
+          @fetcher.get_time_of_tag(tag)
           if @options[:verbose]
-            print "Fetching tags dates: #{i+1}/#{all}\r"
-            i+=1
+            print "Fetching tags dates: #{i + 1}/#{all}\r"
+            i += 1
           end
-
         }
       }
 
       print "                                 \r"
 
-      threads.each { |thr| thr.join }
-
-      if @options[:verbose]
-        puts 'Fetching tags: Done!'
-      end
-    end
-
-    def is_megred(number)
-begin
-         @github.pull_requests.merged? @options[:user], @options[:project], number
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
-    end
-
-    def get_all_tags
+      threads.each(&:join)
 
       if @options[:verbose]
-        print "Fetching tags...\r"
-      end
-
-      tags = []
-
-      begin
-         response = @github.repos.tags @options[:user], @options[:project]
-         page_i = 0
-         count_pages = response.count_pages
-         response.each_page do |page|
-           page_i += PER_PAGE_NUMBER
-           print "Fetching tags... #{page_i}/#{count_pages * PER_PAGE_NUMBER}\r"
-           tags.concat(page)
-         end
-         print "                               \r"
-         if @options[:verbose]
-           puts "Found #{tags.count} tags"
-         end
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
-
-
-
-      tags
-    end
-
-    def fetch_github_token
-      env_var = @options[:token] ? @options[:token] : (ENV.fetch 'CHANGELOG_GITHUB_TOKEN', nil)
-
-      unless env_var
-        puts "Warning: No token provided (-t option) and variable $CHANGELOG_GITHUB_TOKEN was not found.".yellow
-        puts "This script can make only 50 requests to GitHub API per hour without token!".yellow
+        puts "Fetching tags dates: #{i} Done!"
       end
-
-      @github_token ||= env_var
-
     end
 
+    # 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_log_between_tags(older_tag, newer_tag)
-      # older_tag nil - means it's first tag, newer_tag nil - means it unreleased section
       filtered_pull_requests = delete_by_time(@pull_requests, :actual_date, older_tag, newer_tag)
       filtered_issues = delete_by_time(@issues, :actual_date, older_tag, newer_tag)
 
-      newer_tag_name = newer_tag.nil? ? nil : newer_tag['name']
-      older_tag_name = older_tag.nil? ? nil : older_tag['name']
+      newer_tag_name = newer_tag.nil? ? nil : newer_tag["name"]
+      older_tag_name = older_tag.nil? ? nil : older_tag["name"]
 
       if @options[:filter_issues_by_milestone]
-        #delete excess irrelevant issues (according milestones)
+        # delete excess irrelevant issues (according milestones)
         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
 
       if filtered_issues.empty? && filtered_pull_requests.empty? && newer_tag.nil?
         # do not generate empty unreleased section
-        return ''
+        return ""
       end
 
-      self.create_log(filtered_pull_requests, filtered_issues, newer_tag, older_tag_name)
+      create_log(filtered_pull_requests, filtered_issues, newer_tag, older_tag_name)
     end
 
     def filter_by_milestone(filtered_issues, newer_tag_name, src_array)
@@ -367,18 +313,18 @@ rescue
         if issue.milestone.nil?
           true
         else
-          #check, that this milestone in tag list:
+          # check, that this milestone in tag list:
           @all_tags.find { |tag| tag.name == issue.milestone.title }.nil?
         end
       }
       unless newer_tag_name.nil?
 
-        #add missed issues (according milestones)
+        # add missed issues (according milestones)
         issues_to_add = src_array.select { |issue|
           if issue.milestone.nil?
             false
           else
-            #check, that this milestone in tag list:
+            # check, that this milestone in tag list:
             milestone_is_tag = @all_tags.find { |tag|
               tag.name == issue.milestone.title
             }
@@ -396,12 +342,17 @@ rescue
       filtered_issues
     end
 
-    def delete_by_time(array, hash_key, older_tag = nil, newer_tag = nil)
+    # Method filter issues, that belong only specified tag range
+    # @param [Array] array of issues to filter
+    # @param [Symbol] hash_key key of date value default is :actual_date
+    # @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
+    # @return [Array] filtered issues
+    def delete_by_time(array, hash_key = :actual_date, older_tag = nil, newer_tag = nil)
+      fail ChangelogGeneratorError, "At least one of the tags should be not nil!".red if older_tag.nil? && newer_tag.nil?
 
-      raise 'At least one of the tags should be not nil!' if (older_tag.nil? && newer_tag.nil?)
-
-      newer_tag_time = self.get_time_of_tag(newer_tag)
-      older_tag_time = self.get_time_of_tag(older_tag)
+      newer_tag_time = newer_tag && @fetcher.get_time_of_tag(newer_tag)
+      older_tag_time = older_tag && @fetcher.get_time_of_tag(older_tag)
 
       array.select { |req|
         if req[hash_key]
@@ -419,7 +370,6 @@ rescue
             tag_in_range_new = t <= newer_tag_time
           end
 
-
           tag_in_range = (tag_in_range_old) && (tag_in_range_new)
 
           tag_in_range
@@ -429,45 +379,38 @@ rescue
       }
     end
 
-    # @param [Array] pull_requests
-    # @param [Array] issues
-    # @param [String] older_tag_name
-    # @return [String]
+    # Generates log for section 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 of the newer tag. Could be nil for `Unreleased` section
+    # @param [String] older_tag_name Older tag, used for the links. Could be nil for last tag.
+    # @return [String] Ready and parsed section
     def create_log(pull_requests, issues, newer_tag, older_tag_name = nil)
+      newer_tag_time = newer_tag.nil? ? Time.new : @fetcher.get_time_of_tag(newer_tag)
+      newer_tag_name = newer_tag.nil? ? @options[:unreleased_label] : newer_tag["name"]
+      newer_tag_link = newer_tag.nil? ? "HEAD" : newer_tag_name
 
-      newer_tag_time = newer_tag.nil? ? nil : self.get_time_of_tag(newer_tag)
-      newer_tag_name = newer_tag.nil? ? nil : newer_tag['name']
-
-      github_site = options[:github_site] || 'https://github.com'
+      github_site = options[:github_site] || "https://github.com"
       project_url = "#{github_site}/#{@options[:user]}/#{@options[:project]}"
 
-      if newer_tag.nil?
-        newer_tag_name = @options[:unreleased_label]
-        newer_tag_link = 'HEAD'
-        newer_tag_time = Time.new
-      else
-        newer_tag_link = newer_tag_name
-      end
-
-      log = ''
-
-      log += generate_header(log, newer_tag_name, newer_tag_link, newer_tag_time, older_tag_name, project_url)
+      log = generate_header(newer_tag_name, newer_tag_link, newer_tag_time, older_tag_name, project_url)
 
       if @options[:issues]
         # Generate issues:
         issues_a = []
         enhancement_a = []
-        bugs_a =[]
+        bugs_a = []
 
         issues.each { |dict|
           added = false
           dict.labels.each { |label|
-            if label.name == 'bug'
+            if label.name == "bug"
               bugs_a.push dict
               added = true
               next
             end
-            if label.name == 'enhancement'
+            if label.name == "enhancement"
               enhancement_a.push dict
               added = true
               next
@@ -478,22 +421,26 @@ rescue
           end
         }
 
-        log += generate_log_from_array(enhancement_a, @options[:enhancement_prefix])
-        log += generate_log_from_array(bugs_a, @options[:bug_prefix])
-        log += generate_log_from_array(issues_a, @options[:issue_prefix])
+        log += generate_sub_section(enhancement_a, @options[:enhancement_prefix])
+        log += generate_sub_section(bugs_a, @options[:bug_prefix])
+        log += generate_sub_section(issues_a, @options[:issue_prefix])
       end
 
       if @options[:pulls]
         # Generate pull requests:
-        log += generate_log_from_array(pull_requests, @options[:merge_prefix])
+        log += generate_sub_section(pull_requests, @options[:merge_prefix])
       end
 
       log
     end
 
-    def generate_log_from_array(issues, prefix)
-      log = ''
-      if options[:simple_list].nil? && issues.any?
+    # @param [Array] issues List of issues on sub-section
+    # @param [String] prefix Nae of sub-section
+    # @return [String] Generate ready-to-go sub-section
+    def generate_sub_section(issues, prefix)
+      log = ""
+
+      if options[:simple_list] != true && issues.any?
         log += "#{prefix}\n\n"
       end
 
@@ -506,119 +453,51 @@ rescue
       log
     end
 
-    def generate_header(log, newer_tag_name, newer_tag_name2, newer_tag_time, older_tag_name, project_url)
+    # It generate one header for section with specific parameters.
+    #
+    # @param [String] newer_tag_name - name of newer tag
+    # @param [String] newer_tag_link - used for links. Could be same as #newer_tag_name or some specific value, like HEAD
+    # @param [Time] newer_tag_time - time, when newer tag created
+    # @param [String] older_tag_link - tag name, used for links.
+    # @param [String] project_url - url for current project.
+    # @return [String] - Generate one ready-to-add section.
+    def generate_header(newer_tag_name, newer_tag_link, newer_tag_time, older_tag_link, project_url)
+      log = ""
 
-      #Generate date string:
-      time_string = newer_tag_time.strftime @options[:format]
+      # Generate date string:
+      time_string = newer_tag_time.strftime @options[:dateformat]
 
       # Generate tag name and link
       if newer_tag_name.equal? @options[:unreleased_label]
-        log += "## [#{newer_tag_name}](#{project_url}/tree/#{newer_tag_name2})\n\n"
+        log += "## [#{newer_tag_name}](#{project_url}/tree/#{newer_tag_link})\n\n"
       else
-        log += "## [#{newer_tag_name}](#{project_url}/tree/#{newer_tag_name2}) (#{time_string})\n\n"
+        log += "## [#{newer_tag_name}](#{project_url}/tree/#{newer_tag_link}) (#{time_string})\n\n"
       end
 
-      if @options[:compare_link] && older_tag_name
+      if @options[:compare_link] && older_tag_link
         # Generate compare link
-        log += "[Full Changelog](#{project_url}/compare/#{older_tag_name}...#{newer_tag_name2})\n\n"
+        log += "[Full Changelog](#{project_url}/compare/#{older_tag_link}...#{newer_tag_link})\n\n"
       end
 
       log
     end
 
-    def get_time_of_tag(tag_name, tag_times_hash = @tag_times_hash)
-
-      if tag_name.nil?
-        return nil
-      end
-
-      if tag_times_hash[tag_name['name']]
-        return @tag_times_hash[tag_name['name']]
-      end
-
-begin
-         github_git_data_commits_get = @github.git_data.commits.get @options[:user], @options[:project], tag_name['commit']['sha']
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
-      time_string = github_git_data_commits_get['committer']['date']
-      @tag_times_hash[tag_name['name']] = Time.parse(time_string)
-    end
-
+    # Filter issues according labels
+    # @return [Array] Filtered issues
     def get_filtered_issues
+      filtered_issues = include_issues_by_labels(@issues)
 
-      issues = @issues
-
-      filtered_issues = issues
-
-      unless @options[:include_labels].nil?
-        filtered_issues = issues.select { |issue|
-          #add all labels from @options[:incluse_labels] array
-          (issue.labels.map { |label| label.name } & @options[:include_labels]).any?
-        }
-      end
-
-      unless @options[:exclude_labels].nil?
-        filtered_issues = filtered_issues.select { |issue|
-          #delete all labels from @options[:exclude_labels] array
-          !(issue.labels.map { |label| label.name } & @options[:exclude_labels]).any?
-        }
-      end
-
-      if @options[:add_issues_wo_labels]
-        issues_wo_labels = issues.select {
-          # add issues without any labels
-            |issue| !issue.labels.map { |label| label.name }.any?
-        }
-        filtered_issues |= issues_wo_labels
-      end
-
+      filtered_issues = exclude_issues_by_labels(filtered_issues)
 
       if @options[:verbose]
         puts "Filtered issues: #{filtered_issues.count}"
       end
 
       filtered_issues
-
-    end
-
-    def fetch_issues_and_pull_requests
-      if @options[:verbose]
-        print "Fetching closed issues...\r"
-      end
-      issues = []
-
-begin
-         response = @github.issues.list user: @options[:user], repo: @options[:project], state: 'closed', filter: 'all', labels: nil
-         page_i = 0
-         count_pages = response.count_pages
-         response.each_page do |page|
-           page_i += PER_PAGE_NUMBER
-           print "Fetching issues... #{page_i}/#{count_pages * PER_PAGE_NUMBER}\r"
-           issues.concat(page)
-         end
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
-
-
-
-      print "                               \r"
-
-      if @options[:verbose]
-        puts "Received issues: #{issues.count}"
-      end
-
-      # remove pull request from issues:
-      issues_wo_pr = issues.select { |x|
-        x.pull_request == nil
-      }
-      pull_requests = issues.select { |x|
-        x.pull_request != nil
-      }
-      return issues_wo_pr, pull_requests
     end
 
+    # Fetch event for issues and pull requests
+    # @return [Array] array of fetched issues
     def fetch_event_for_issues_and_pr
       if @options[:verbose]
         print "Fetching events for issues and PR: 0/#{@issues.count + @pull_requests.count}\r"
@@ -626,42 +505,11 @@ rescue
 
       # Async fetching events:
 
-      fetch_events_async(@issues + @pull_requests)
-
-      #to clear line from prev print
-      print "                                                            \r"
-
-      if @options[:verbose]
-        puts 'Fetching events for issues and PR: Done!'
-      end
-    end
-
-    def fetch_events_async(issues)
-      i = 0
-      max_thread_number = 50
-      threads = []
-      issues.each_slice(max_thread_number) { |issues_slice|
-        issues_slice.each { |issue|
-          threads << Thread.new {
-begin
-               obj = @github.issues.events.list user: @options[:user], repo: @options[:project], issue_number: issue['number']
-rescue
-         puts "Warning: GitHub API rate limit exceed (5000 per hour), change log may not contain some issues.".yellow
- end
-            issue[:events] = obj.body
-            print "Fetching events for issues and PR: #{i+1}/#{@issues.count + @pull_requests.count}\r"
-            i +=1
-          }
-        }
-        threads.each { |thr| thr.join }
-        threads = []
-      }
+      @fetcher.fetch_events_async(@issues + @pull_requests)
     end
-
   end
 
-  if __FILE__ == $0
-    GitHubChangelogGenerator::ChangelogGenerator.new.compund_changelog
+  if __FILE__ == $PROGRAM_NAME
+    GitHubChangelogGenerator::ChangelogGenerator.new.compound_changelog
   end
-
 end