git-releaselog 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 567008c8838f03f01eef3ab47173418335f66749
-  data.tar.gz: 5a92522b789dfe71c4418de08d2afada0687e02a
+  metadata.gz: 56cebe4847171a0bb6abab7e5cb47adb936f5a5b
+  data.tar.gz: dfbaf79e1bd1ccecdc6b3925a1cd213fb9d259ec
 SHA512:
-  metadata.gz: 5c04a68c551ec6bf27e8c3cd611686656fb65608a91b1af0580c9de9938b18ed6f9b555841dc8663180843401d6e7e461bacd85f4cbc57a60dbe8ad9bd13a84c
-  data.tar.gz: 73d5c5d3251ce70bfedb2f8e8bae6f31c6000d14be7552077ba2cb1ef362abd6324de98be3cce9885be841345907ef759077b2a17a285ccb8653eb3e0fbf0523
+  metadata.gz: 2b5ac5be3bc031e8c6bee5b9bd0b720f53cf77addb8b4c0a00ca8e06c73269d1ee792398bb921c5729a14625776af4619abc403d04199cdab40d19a5d7459eb5
+  data.tar.gz: a24b234e7cfea87d14a9995f1906e17387075aa4e1c386eab032ff23302daa9ae9847a5c6c3290150441ec2f802ec956bd8166a60f8f729721ac44a253ce8cd3

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Markus Chmelar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,144 @@
+# git-releaselog
+
+This tool generates release log from a git repository.
+
+Generally, I don't beliefe that its possible to generate good releaselog
+from an ordinary git log. 
+The git log usually contains very detailed, technical information, targeted
+at the maintainers of a project. 
+
+In contrast, the releaselog should be targetet at the users of a project and 
+should describe changes relevant to those users at a higher abstraction.
+
+Thats why this tool does not attempt to build a releaselog from normal commit
+messages but instead requires special keywords to mark notes that should 
+show up in the releaselog.
+
+These [keywords](#markup) can be used in commit messages. See the [Example](#example)
+section.
+
+## Usage
+
+The default use is to generate the releaselog starting from the last release 
+(the most recent tag) until now.
+
+* `git-releaselog`: will look up the most recent tag and will search all commits from this tag to `HEAD`. 
+
+If you want to controll the range of commits that should be searched, you can 
+specify a _commit-hash_ or _tag-name_, e.g.
+
+* `git-releaselog v1.0` will look up the commits starting from the tag with name `v1.0` to `HEAD`.
+* `git-releaselog v1.0 7c064bb` will look up the commits starting from the tag with name `v1.0` to the commit `7c064bb`.
+
+Alternatively, you can choose the generate the whole releaselog for the whole repo:
+
+* `git-releaselog --complete` will search the whole git log and group the changes nicely in sections by existing tags.
+
+To control the markup of the output, you can use these options (the default is slack):
+
+* `--slack` produces output that looks nice when copy/pasted into slack
+* `--md` produces markdown output in reverse order, e.g this repo's [releaselog]
+
+## Markup
+
+Entries that should show up in the releaselog must have a special format:
+
+`* <keyword>: [<optional-scope] <description>`
+
+The descriptions are extracted from the git history and grouped by keyword. 
+Currently, the following keynotes are supported
+
+* `fix`
+* `feat`
+* `gui`
+* `refactor`
+
+### Scope
+
+The releaselog can be limited to a certain __scope__. This is helpful when multiple projects / targets are in the same git repository (E.g. several targets of an app with a large shared codebase).
+
+When a scope is declared for the generation of the releaselog, only entries that are marked with that scope and entries without scope are included into the releaselog.
+
+### Example
+
+Given these lines in a commit message:
+
+```
+* feat: [project-x] add a new feature to project-x
+* fix: [project-y] fix a bug in project-y
+* fix: fix a bug that affected both projects
+```
+running
+```
+git-releaselog --scope project-x
+```
+will generate this releaselog:
+
+```
+*Features*
+* add a new feature to project-x
+
+*Fixes*
+* fix a bug that affected both projects
+```
+
+## Usage suggestion
+
+This is just what works best for us: 
+
+* Use guidelines for git commits, e.g. [AngularJS](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#commit)
+* Use the [Gitflow workflow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow)
+* Create Merge Requests for merging feature branches back to develop
+  * Feature branch / merge request should address specific features / fixes / ...
+  * The description of the merge request should contain markup for the releaselog
+  * The description of the merge request should be the commit message of the merge commit (done automatically e.g. by gitlab)
+
+The only additional step from our normal workflow is to use special markup for the change log in the description of a merge request. 
+Doing so enables the generation of change logs between arbitrary commits / releases
+
+## Example
+
+The following is an excerpt of the this repos git log:
+
+```
+commit fa40cdb51c674df8b4a564e283a601d50fcdd55f
+Author: MeXx <mexx@devsub.net>
+Date:   Tue May 26 14:04:09 2015 +0200
+
+    fix(repo): back to the local repo
+
+commit 1f4abe3399891cfd429e5aa474e6c414f7e2b3b2
+Author: MeXx <mexx@devsub.net>
+Date:   Tue May 26 14:02:47 2015 +0200
+
+    feat(releaselog): new feature to create a complete releaselog
+    
+    * feat: use the `--complete` parameter to generate a complete releaselog over all tags
+
+commit 61fe21959bb52ce09eaf1ee995650c8c4c3b073e
+Author: MeXx <mexx@devsub.net>
+Date:   Tue May 26 13:18:10 2015 +0200
+
+    refactor(searchChanges): moved the function to search the git log into a function
+
+commit d41dac909757b265d226589ead6a5a57aba5dc87
+Author: MeXx <mexx@devsub.net>
+Date:   Tue May 26 12:49:00 2015 +0200
+
+    feat(printing): nicer printing of the log
+```
+
+Notice, that commit `1f4abe3399891cfd429e5aa474e6c414f7e2b3b2` has an extra line with a `feat` keyword.
+The releaselog for these commits looks like this:
+`git-releaselog fa40cdb d41dac9 --md`
+
+```
+## Unreleased (_26.05.2015_)
+#### Fixes
+_No new Fixes_
+
+#### Features
+* use the `--complete` parameter to generate a complete releaselog over all tags
+```
+
+[releaselog]: CHANGELOG.md

data/bin/git-releaselog

@@ -34,13 +34,13 @@ DOCOPT
 
 # Parse Commandline Arguments
 begin
-  args =  Docopt::docopt(doc, version: '0.6.0')
+  args =  Docopt::docopt(doc, version: Releaselog::VERSION)
 rescue Docopt::Exit => e
   puts e.message
   exit
 end
 
-puts Releaselog.generate_releaselog(
+puts Releaselog::Releaselog.generate_releaselog(
   repo_path: ".",
   from_ref: args["<from-ref>"],
   to_ref: args["<to-ref>"],

data/lib/git-releaselog.rb

@@ -1,104 +1,115 @@
 require "rugged"
-require "changelog_helpers"
-require "changelog"
 require "logger"
+require "git-releaselog/changelog_helpers"
+require "git-releaselog/changelog"
+require "git-releaselog/version"
 
-class Releaselog
-  def self.generate_releaselog(options = {})
-  repo_path = options.fetch(:repo_path, '.')
-  from_ref_name = options.fetch(:from_ref, nil)
-  to_ref_name = options.fetch(:to_ref, nil)
-  scope = options.fetch(:scope, nil)
-  format = options.fetch(:format, 'slack')
-  generate_complete = options.fetch(:generate_complete, false)
-  verbose = options.fetch(:verbose, false)
-
-  # Initialize Logger
-  logger = Logger.new(STDOUT)
-  logger.level = verbose ?  Logger::DEBUG : Logger::ERROR
-
-  # Initialize Repo
-  begin
-    repo = Rugged::Repository.discover(repo_path)
-  rescue Rugged::OSError => e
-    puts ("Current directory is not a git repo")
-    logger.error(e.message)
-    exit
-  end
+module Releaselog
+  class Releaselog
+    def self.generate_releaselog(options = {})
+    repo_path = options.fetch(:repo_path, '.')
+    from_ref_name = options.fetch(:from_ref, nil)
+    to_ref_name = options.fetch(:to_ref, nil)
+    scope = options.fetch(:scope, nil)
+    format = options.fetch(:format, 'slack')
+    generate_complete = options.fetch(:generate_complete, false)
+    verbose = options.fetch(:verbose, false)
 
-  # Find if we're operating on tags
-  from_ref = tagWithName(repo, from_ref_name)
-  to_ref = tagWithName(repo, to_ref_name)
-  latest_tag = latestTagID(repo, logger)
+    # Initialize Logger
+    logger = Logger.new(STDOUT)
+    logger.level = verbose ?  Logger::DEBUG : Logger::ERROR
 
-  if from_ref
-    logger.info("Found Tag #{from_ref.name} to start from")
-  end
+    # Initialize Repo
+    begin
+      repo = Rugged::Repository.discover(repo_path)
+    rescue Rugged::OSError => e
+      puts ("Current directory is not a git repo")
+      logger.error(e.message)
+      exit
+    end
 
-  if to_ref
-    logger.info("Found Tag #{to_ref.name} to end at")
-  end
+    # Find if we're operating on tags
+    from_ref = tagWithName(repo, from_ref_name)
+    to_ref = tagWithName(repo, to_ref_name)
+    latest_tag = latestTagID(repo, logger)
 
-  if latest_tag
-    logger.info("Latest Tag found: #{latest_tag.name}")
-  end
+    if from_ref
+      logger.info("Found Tag #{from_ref.name} to start from")
+    end
 
-  if generate_complete && repo.tags.count > 0
-    sorted_tags = repo.tags.sort { |t1, t2| t1.target.time <=> t2.target.time }
-    changeLogs = []
-    sorted_tags.each_with_index do |tag, index|
-      if index == 0
-          # First Interval: Generate from start of Repo to the first Tag
-          changes = searchGitLog(repo, tag.target, repo.head.target, scope, logger)
-          logger.info("First Tag: #{tag.name}: #{changes.count} changes")
-          changeLogs += [Changelog.new(changes, tag, nil, nil, nil)]
-        else
-          # Normal interval: Generate from one Tag to the next Tag
-          previousTag = sorted_tags[index-1]
-          changes = searchGitLog(repo, tag.target, previousTag.target, scope, logger)
-          logger.info("Tag #{previousTag.name} to #{tag.name}: #{changes.count} changes")
-          changeLogs += [Changelog.new(changes, tag, previousTag, nil, nil)]
+    if to_ref
+      logger.info("Found Tag #{to_ref.name} to end at")
+    end
+
+    if latest_tag
+      logger.info("Latest Tag found: #{latest_tag.name}")
+    end
+
+    if generate_complete && repo.tags.count > 0
+      sorted_tags = repo.tags.sort { |t1, t2| t1.target.time <=> t2.target.time }
+      changeLogs = []
+      sorted_tags.each_with_index do |tag, index|
+        logger.error("Tag #{tag.name} with date #{tag.target.time}")
+
+        if index == 0
+            # First Interval: Generate from start of Repo to the first Tag
+            changes = searchGitLog(repo, nil, tag.target, scope, logger)
+            changeLogs += [Changelog.new(changes, nil, tag, nil, nil)]
+
+            logger.info("Parsing from start of the repo to #{tag.target.oid}")
+            logger.info("First Tag: #{tag.name}: #{changes.count} changes")
+          else
+            # Normal interval: Generate from one Tag to the next Tag
+            previousTag = sorted_tags[index-1]
+            changes = searchGitLog(repo, previousTag.target, tag.target, scope, logger)
+            changeLogs += [Changelog.new(changes, previousTag, tag, nil, nil)]
+
+            logger.info("Parsing from #{tag.target.oid} to #{previousTag.target.oid}")
+            logger.info("Tag #{previousTag.name} to #{tag.name}: #{changes.count} changes")
+          end
         end
-      end
 
-      if sorted_tags.count > 0
-        lastTag = sorted_tags.last
-        # Last Interval: Generate from last Tag to HEAD
-        changes = searchGitLog(repo, repo.head.target, lastTag.target, scope, logger)
-        logger.info("Tag #{lastTag.name} to HEAD: #{changes.count} changes")
-        changeLogs += [Changelog.new(changes, nil, lastTag, nil, nil)]
-      end
+        if sorted_tags.count > 0
+          lastTag = sorted_tags.last
+          # Last Interval: Generate from last Tag to HEAD
+          changes = searchGitLog(repo, lastTag.target, repo.head.target, scope, logger)
+          changeLogs += [Changelog.new(changes, lastTag, nil, nil, nil)]
 
-      # Print the changelog
-      if format == "md"
-        changeLogs.reverse.map { |log| "#{log.to_md}\n" }
-      elsif format == "slack"
-        changeLogs.reduce("") { |log, version| log + "1) #{version.to_slack}\n" }
-      else
-        logger.error("Unknown Format: `#{format}`")
-      end
-    else
-      # From which commit should the log be followed? Will default to the latest tag
-      commit_from = (from_ref && from_ref.target) || commit(repo, from_ref, logger) || latest_tag && (latest_tag.target)
-
-      # To which commit should the log be followed? Will default to HEAD
-      commit_to = (to_ref && to_ref.target) || commit(repo, to_ref, logger) || repo.head.target
-
-
-      changes = searchGitLog(repo, commit_from, commit_to, scope, logger)
-      # Create the changelog
-      log = Changelog.new(changes, from_ref, to_ref || latest_tag, commit_from, commit_to)
-
-      # Print the changelog
-      case format
-      when "md"
-        log.to_md
-      when "slack"
-        log.to_slack
-      when "raw"
-        log
+          logger.info("Parsing from #{lastTag.target.oid} to HEAD")
+          logger.info("Tag #{lastTag.name} to HEAD: #{changes.count} changes")
+        end
+
+        # Print the changelog
+        if format == "md"
+          changeLogs.reverse.map { |log| "#{log.to_md}\n" }
+        elsif format == "slack"
+          changeLogs.reduce("") { |log, version| log + "#{version.to_slack}\n" }
+        else
+          logger.error("Unknown Format: `#{format}`")
+        end
       else
-        logger.error("Unknown Format: `#{format}`")
+        # From which commit should the log be followed? Will default to the latest tag
+        commit_from = (from_ref && from_ref.target) || commit(repo, from_ref, logger) || latest_tag && (latest_tag.target)
+
+        # To which commit should the log be followed? Will default to HEAD
+        commit_to = (to_ref && to_ref.target) || commit(repo, to_ref, logger) || repo.head.target
+
+
+        changes = searchGitLog(repo, commit_from, commit_to, scope, logger)
+        # Create the changelog
+        log = Changelog.new(changes, from_ref, to_ref || latest_tag, commit_from, commit_to)
+
+        # Print the changelog
+        case format
+        when "md"
+          log.to_md
+        when "slack"
+          log.to_slack
+        when "raw"
+          log
+        else
+          logger.error("Unknown Format: `#{format}`")
+        end
       end
     end
   end

data/lib/git-releaselog/change.rb

@@ -0,0 +1,65 @@
+# A class for representing a change
+# A change can have a type (fix or feature) and a note describing the change
+module Releaselog
+  class Change
+    FIX = 1
+    FEAT = 2
+    GUI = 3
+    REFACTOR = 4
+
+    TOKEN_FIX = "* fix:"
+    TOKEN_FEAT = "* feat:"
+    TOKEN_GUI = "* gui:"
+    TOKEN_REFACTOR = "* refactor:"
+
+    def initialize(type, note)
+      @type = type
+      @note = note.strip
+    end
+
+    def type
+      @type
+    end
+
+    def note
+      @note
+    end
+
+    # Parse a single line as a `Change` entry
+    # If the line is formatte correctly as a change entry, a corresponding `Change` object will be created and returned,
+    # otherwise, nil will be returned.
+    # 
+    # The additional scope can be used to skip changes of another scope. Changes without scope will always be included.
+    def self.parse(line, scope = nil)
+      if line.start_with? Change::TOKEN_FEAT
+        self.new(Change::FEAT, line.split(Change::TOKEN_FEAT).last).check_scope(scope)
+      elsif line.start_with? Change::TOKEN_FIX
+        self.new(Change::FIX, line.split(Change::TOKEN_FIX).last).check_scope(scope)
+      elsif line.start_with? Change::TOKEN_GUI
+        self.new(Change::GUI, line.split(Change::TOKEN_GUI).last).check_scope(scope)
+      elsif line.start_with? Change::TOKEN_REFACTOR
+        self.new(Change::REFACTOR, line.split(Change::TOKEN_REFACTOR).last).check_scope(scope)
+      else
+        nil
+      end
+    end
+
+    # Checks the scope of the `Change` and the change out if the scope does not match.
+    def check_scope(scope = nil)
+      # If no scope is requested or the change has no scope include this change unchanged
+      return self unless scope
+      change_scope = /^\s*\[\w+\]/.match(@note)
+      return self unless change_scope
+
+      # change_scope is a string of format `[scope]`, need to strip the `[]` to compare the scope
+      if change_scope[0][1..-2] == scope
+        #  Change has the scope that is requested, strip the whole scope scope from the change note
+        @note = change_scope.post_match.strip
+        return self
+      else
+        #  Change has a different scope than requested
+        return nil
+      end
+    end
+  end
+end

data/lib/git-releaselog/changelog.rb

@@ -0,0 +1,118 @@
+# A class for representing a changelog consisting of several changes
+# over a certain timespan (between two commits)
+module Releaselog
+  class Changelog
+    def initialize(changes, tag_from = nil, tag_to = nil, from_commit = nil, to_commit = nil)
+      @changes_fix = changes.select { |c| c.type == Change::FIX }
+      @changes_feat = changes.select { |c| c.type == Change::FEAT }
+      @changes_gui = changes.select { |c| c.type == Change::GUI }
+      @changes_refactor = changes.select { |c| c.type == Change::REFACTOR }
+      @tag_from = tag_from
+      @tag_to = tag_to
+      @commit_from = from_commit
+      @commit_to = to_commit
+    end
+
+    # Returns a hash of the changes.
+    # The changes are grouped by change type into `fix`, `feature`, `gui`, `refactor`
+    # Each type is a list of changes where each change is the note of that change
+    def changes
+      {
+        fix: @changes_fix.map(&:note),
+        feature: @changes_feat.map(&:note),
+        gui: @changes_gui.map(&:note),
+        refactor: @changes_refactor.map(&:note)
+      }
+    end
+
+    # Display tag information about the tag that the changelog is created for
+    def tag_info
+      if @tag_to && @tag_to.name
+        yield("#{@tag_to.name}\n")
+      else
+        yield("Unreleased\n")
+      end
+    end
+
+    # Display tinformation about the commit the changelog is created for
+    def commit_info
+      if @commit_to
+        yield(@commit_to.time.strftime("%d.%m.%Y"))
+      else
+        yield("")
+      end
+    end
+
+    # Format each section from #sections.
+    #
+    # section_changes ... changes in the format of { section_1: [changes...], section_2: [changes...]}
+    # header_style ... is called for styling the header of each section
+    # entry_style ... is called for styling each item of a section
+    def sections(section_changes, header_style, entry_style)
+      str = ""
+      section_changes.each do |section_category, section_changes|
+        str << section(
+          section_changes,
+          section_category.to_s,
+          entry_style,
+          header_style
+        )
+      end
+      str
+    end
+
+    # Format a specific section.
+    #
+    # section_changes ... changes in the format of { section_1: [changes...], section_2: [changes...]}
+    # header ... header of the section
+    # entry_style ... is called for styling each item of a section
+    # header_style ... optional, since styled header can be passed directly; is called for styling the header of the section
+    def section(section_changes, header, entry_style, header_style = nil)
+      return "" unless section_changes.size > 0
+      str = ""
+
+      unless header.empty?
+        if header_style
+          str << header_style.call(header)
+        else
+          str << header
+        end
+      end
+
+      section_changes.each_with_index do |e, i|
+        str << entry_style.call(e, i)
+      end
+      str
+    end
+
+    # Render the Changelog with Slack Formatting
+    def to_slack
+      str = ""
+
+      str << tag_info { |t| t }
+      str << commit_info { |ci| ci.empty? ? "" : "(_#{ci}_)\n"  }
+      str << sections(
+        changes,
+        -> (header) { "*#{header.capitalize}*\n" },
+        -> (field, _index) { "\t- #{field}\n" }
+      )
+
+      str
+    end
+
+    # Render the Changelog with Markdown Formatting
+    def to_md
+      str = ""
+
+      str << tag_info { |t| "## #{t}" }
+      str << commit_info { |ci| ci.empty? ? "" : "(_#{ci}_)\n" }
+      str << sections(
+        changes,
+        -> (header) { "\n*#{header.capitalize}*\n" },
+        -> (field, _index) { "* #{field}\n" }
+      )
+
+      str
+    end
+  end
+end

data/lib/git-releaselog/changelog_helpers.rb

@@ -0,0 +1,61 @@
+#
+# Helper Functions for git-changelog script
+#
+require "git-releaselog/change"
+include Releaselog
+
+# check if the given refString (tag name or commit-hash) exists in the repo
+def commit(repo, refString, logger)
+  return unless refString != nil
+  begin
+    repo.lookup(refString)
+  rescue Rugged::OdbError => e
+    puts ("Commit `#{refString}` does not exist in Repo")
+    logger.error(e.message)
+    exit
+  rescue Exception => e
+    puts ("`#{refString}` is not a valid OID")
+    logger.error(e.message)
+    exit
+  end
+end
+
+# Returns the most recent tag
+def latestTagID(repo, logger)
+  return nil unless repo.tags.count > 0
+  sorted_tags = repo.tags.sort { |t1, t2| t1.target.time <=> t2.target.time }
+  sorted_tags.last
+end
+
+# Returns the tag with the given name (if exists)
+def tagWithName(repo, name)
+  tags = repo.tags.select { |t| t.name == name }
+  return tags.first unless tags.count < 1
+end
+
+# Parses a commit message and returns an array of Changes
+def parseCommit(commit, scope, logger)
+  logger.debug("Parsing Commit #{commit.oid}")
+  # Sepaerate into lines, remove whitespaces and filter out empty lines
+  lines = commit.message.lines.map(&:strip).reject(&:empty?)
+  # Parse the lines
+  lines.map{|line| Change.parse(line, scope)}.reject(&:nil?)
+end
+
+# Searches the commit log messages of all commits between `commit_from` and `commit_to` for changes
+def searchGitLog(repo, commit_from, commit_to, scope, logger)
+  # logger.info("Traversing git tree from commit #{commit_from.oid} to commit #{commit_to && commit_to ? commit_to.oid : '(no oid)'}")
+
+  # Initialize a walker that walks through the commits from the <from-commit> to the <to-commit>
+  walker = Rugged::Walker.new(repo)
+  walker.sorting(Rugged::SORT_DATE)
+  walker.push(commit_to) unless commit_to == nil
+  commit_from.parents.each do |parent|
+    walker.hide(parent)
+  end unless commit_from == nil
+
+  # Parse all commits and extract changes
+  changes = walker.map{ |c| parseCommit(c, scope, logger)}.reduce(:+) || []
+  logger.debug("Found #{changes.count} changes")
+  return changes
+end

data/lib/git-releaselog/version.rb

@@ -0,0 +1,5 @@
+module Releaselog
+    VERSION     = "0.7.0"
+    SUMMARY     = "Generate a releaselog from a git repository"
+    DESCRIPTION = "Write your releaselog as part of your usual commit messages. This tool generates a useful releaselog from marked lines in your git commit messages"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-releaselog
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Markus Chmelar
@@ -44,6 +44,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.23.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -66,10 +108,14 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - bin/git-releaselog
-- lib/changelog.rb
-- lib/changelog_helpers.rb
 - lib/git-releaselog.rb
+- lib/git-releaselog/change.rb
+- lib/git-releaselog/changelog.rb
+- lib/git-releaselog/changelog_helpers.rb
+- lib/git-releaselog/version.rb
 homepage: https://github.com/iv-mexx/git-releaselog
 licenses:
 - MIT

data/lib/changelog.rb

@@ -1,116 +0,0 @@
-# A class for representing a changelog consisting of several changes
-# over a certain timespan (between two commits)
-class Changelog
-  def initialize(changes, tag_from = nil, tag_to = nil, from_commit = nil, to_commit = nil)
-    @changes_fix = changes.select { |c| c.type == Change::FIX }
-    @changes_feat = changes.select { |c| c.type == Change::FEAT }
-    @changes_gui = changes.select { |c| c.type == Change::GUI }
-    @changes_refactor = changes.select { |c| c.type == Change::REFACTOR }
-    @tag_from = tag_from
-    @tag_to = tag_to
-    @commit_from = from_commit
-    @commit_to = to_commit
-  end
-
-  # Returns a hash of the changes.
-  # The changes are grouped by change type into `fix`, `feature`, `gui`, `refactor`
-  # Each type is a list of changes where each change is the note of that change
-  def changes
-    {
-      fix: @changes_fix.map(&:note),
-      feature: @changes_feat.map(&:note),
-      gui: @changes_gui.map(&:note),
-      refactor: @changes_refactor.map(&:note)
-    }
-  end
-
-  # Display tag information about the tag that the changelog is created for
-  def tag_info
-    if @tag_to && @tag_to.name
-      yield("#{@tag_to.name}")
-    else
-      yield("Unreleased")
-    end
-  end
-
-  # Display tinformation about the commit the changelog is created for
-  def commit_info
-    if @commit_to
-      yield(@commit_to.time.strftime("%d.%m.%Y"))
-    else
-      yield("")
-    end
-  end
-
-  # Format each section from #sections.
-  #
-  # section_changes ... changes in the format of { section_1: [changes...], section_2: [changes...]}
-  # header_style ... is called for styling the header of each section
-  # entry_style ... is called for styling each item of a section
-  def sections(section_changes, header_style, entry_style)
-    str = ""
-    section_changes.each do |section_category, section_changes|
-      str << section(
-        section_changes,
-        section_category.to_s,
-        entry_style,
-        header_style
-      )
-    end
-    str
-  end
-
-  # Format a specific section.
-  #
-  # section_changes ... changes in the format of { section_1: [changes...], section_2: [changes...]}
-  # header ... header of the section
-  # entry_style ... is called for styling each item of a section
-  # header_style ... optional, since styled header can be passed directly; is called for styling the header of the section
-  def section(section_changes, header, entry_style, header_style = nil)
-    return "" unless section_changes.size > 0
-    str = ""
-
-    unless header.empty?
-      if header_style
-        str << header_style.call(header)
-      else
-        str << header
-      end
-    end
-
-    section_changes.each_with_index do |e, i|
-      str << entry_style.call(e, i)
-    end
-    str
-  end
-
-  # Render the Changelog with Slack Formatting
-  def to_slack
-    str = ""
-
-    str << tag_info { |t| t }
-    str << commit_info { |ci| " (_#{ci}_)\n" }
-    str << sections(
-      changes,
-      -> (header) { "*#{header.capitalize}*\n" },
-      -> (field, _index) { "\t- #{field}\n" }
-    )
-
-    str
-  end
-
-  # Render the Changelog with Markdown Formatting
-  def to_md
-    str = ""
-
-    str << tag_info { |t| "## #{t}" }
-    str << commit_info { |ci| " (_#{ci}_)" }
-    str << sections(
-      changes,
-      -> (header) { "\n*#{header.capitalize}*\n" },
-      -> (field, _index) { "* #{field}\n" }
-    )
-
-    str
-  end
-end

data/lib/changelog_helpers.rb

@@ -1,123 +0,0 @@
-#
-# Helper Functions for git-changelog script
-#
-
-# A class for representing a change
-# A change can have a type (fix or feature) and a note describing the change
-class Change
-  FIX = 1
-  FEAT = 2
-  GUI = 3
-  REFACTOR = 4
-
-  TOKEN_FIX = "* fix:"
-  TOKEN_FEAT = "* feat:"
-  TOKEN_GUI = "* gui:"
-  TOKEN_REFACTOR = "* refactor:"
-
-  def initialize(type, note)
-    @type = type
-    @note = note.strip
-  end
-
-  def type
-    @type
-  end
-
-  def note
-    @note
-  end
-
-  # Parse a single line as a `Change` entry
-  # If the line is formatte correctly as a change entry, a corresponding `Change` object will be created and returned,
-  # otherwise, nil will be returned.
-  # 
-  # The additional scope can be used to skip changes of another scope. Changes without scope will always be included.
-  def self.parse(line, scope = nil)
-    if line.start_with? Change::TOKEN_FEAT
-      self.new(Change::FEAT, line.split(Change::TOKEN_FEAT).last).check_scope(scope)
-    elsif line.start_with? Change::TOKEN_FIX
-      self.new(Change::FIX, line.split(Change::TOKEN_FIX).last).check_scope(scope)
-    elsif line.start_with? Change::TOKEN_GUI
-      self.new(Change::GUI, line.split(Change::TOKEN_GUI).last).check_scope(scope)
-    elsif line.start_with? Change::TOKEN_REFACTOR
-      self.new(Change::REFACTOR, line.split(Change::TOKEN_REFACTOR).last).check_scope(scope)
-    else
-      nil
-    end
-  end
-
-  # Checks the scope of the `Change` and the change out if the scope does not match.
-  def check_scope(scope = nil)
-    # If no scope is requested or the change has no scope include this change unchanged
-    return self unless scope
-    change_scope = /^\s*\[\w+\]/.match(@note)
-    return self unless change_scope
-
-    # change_scope is a string of format `[scope]`, need to strip the `[]` to compare the scope
-    if change_scope[0][1..-2] == scope
-      #  Change has the scope that is requested, strip the whole scope scope from the change note
-      @note = change_scope.post_match.strip
-      return self
-    else
-      #  Change has a different scope than requested
-      return nil
-    end
-  end
-end
-
-# check if the given refString (tag name or commit-hash) exists in the repo
-def commit(repo, refString, logger)
-  return unless refString != nil
-  begin
-    repo.lookup(refString)
-  rescue Rugged::OdbError => e
-    puts ("Commit `#{refString}` does not exist in Repo")
-    logger.error(e.message)
-    exit
-  rescue Exception => e
-    puts ("`#{refString}` is not a valid OID")
-    logger.error(e.message)
-    exit
-  end
-end
-
-# Returns the most recent tag
-def latestTagID(repo, logger)
-  return nil unless repo.tags.count > 0
-  sorted_tags = repo.tags.sort { |t1, t2| t1.target.time <=> t2.target.time }
-  sorted_tags.last
-end
-
-# Returns the tag with the given name (if exists)
-def tagWithName(repo, name)
-  tags = repo.tags.select { |t| t.name == name }
-  return tags.first unless tags.count < 1
-end
-
-# Parses a commit message and returns an array of Changes
-def parseCommit(commit, scope, logger)
-  logger.debug("Parsing Commit #{commit.oid}")
-  # Sepaerate into lines, remove whitespaces and filter out empty lines
-  lines = commit.message.lines.map(&:strip).reject(&:empty?)
-  # Parse the lines
-  lines.map{|line| Change.parse(line, scope)}.reject(&:nil?)
-end
-
-# Searches the commit log messages of all commits between `commit_from` and `commit_to` for changes
-def searchGitLog(repo, commit_from, commit_to, scope, logger)
-  logger.info("Traversing git tree from commit #{commit_from.oid} to commit #{commit_to && commit_to.oid}")
-
-  # Initialize a walker that walks through the commits from the <from-commit> to the <to-commit>
-  walker = Rugged::Walker.new(repo)
-  walker.sorting(Rugged::SORT_DATE)
-  walker.push(commit_to)
-  commit_from.parents.each do |parent|
-    walker.hide(parent)
-  end unless commit_from == nil
-
-  # Parse all commits and extract changes
-  changes = walker.map{ |c| parseCommit(c, scope, logger)}.reduce(:+) || []
-  logger.debug("Found #{changes.count} changes")
-  return changes
-end