git-releaselog 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 567008c8838f03f01eef3ab47173418335f66749
+  data.tar.gz: 5a92522b789dfe71c4418de08d2afada0687e02a
+SHA512:
+  metadata.gz: 5c04a68c551ec6bf27e8c3cd611686656fb65608a91b1af0580c9de9938b18ed6f9b555841dc8663180843401d6e7e461bacd85f4cbc57a60dbe8ad9bd13a84c
+  data.tar.gz: 73d5c5d3251ce70bfedb2f8e8bae6f31c6000d14be7552077ba2cb1ef362abd6324de98be3cce9885be841345907ef759077b2a17a285ccb8653eb3e0fbf0523

data/bin/git-releaselog

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require "git-releaselog"
+require "docopt"
+
+doc = <<DOCOPT
+A script to generate release-notes from a git repository
+
+Commit messages are parsed for lines of the following format:
+
+`* fix: [<scope(optional)>] <description>`
+`* feat: [<scope(optional)>] <description>`
+`* gui: [<scope(optional)>] <description>`
+`* refactor: [<scope(optional)>] <description>`
+
+The descriptions are collected and printed as releaselog.
+
+Usage:
+#{__FILE__} [--complete][--debug][--format=<format>][--scope=<scope>]
+#{__FILE__} <from-ref> [--debug][--format=<format>][--scope=<scope>]
+#{__FILE__} <from-ref> <to-ref> [--debug][--format=<format>][--scope=<scope>]
+#{__FILE__} -h | --help
+#{__FILE__} --version
+
+Options:
+from-ref          Git-Ref from which should the log be generated. Can be a tag-name or commit-hash. Will default to the latest tag
+to-ref            Git-Ref to which the log should be generated. Can be a tag-name or commit-hash. Has to be newer than `from-ref`. Will default to head
+--scope=<scope>   The scope. Will only include releaselog entries with that scope or without scope.
+--format=<format> The format in which the output should be generated. Currently supports 'slack' and 'md' (for markdown)
+--complete        Traverses the whole git history and generates a releaselog for all tags
+-h --help         Show this screen.
+--version         Show version.
+--debug           Show debug output
+DOCOPT
+
+# Parse Commandline Arguments
+begin
+  args =  Docopt::docopt(doc, version: '0.6.0')
+rescue Docopt::Exit => e
+  puts e.message
+  exit
+end
+
+puts Releaselog.generate_releaselog(
+  repo_path: ".",
+  from_ref: args["<from-ref>"],
+  to_ref: args["<to-ref>"],
+  scope: args["--scope"],
+  format: args["--format"] || "slack",
+  generate_complete: args["--complete"],
+  verbose: (args["--debug"] ? true : false)
+)

data/lib/changelog.rb

@@ -0,0 +1,116 @@
+# 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

@@ -0,0 +1,123 @@
+#
+# 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

data/lib/git-releaselog.rb

@@ -0,0 +1,105 @@
+require "rugged"
+require "changelog_helpers"
+require "changelog"
+require "logger"
+
+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
+
+  # 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 from_ref
+    logger.info("Found Tag #{from_ref.name} to start from")
+  end
+
+  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|
+      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)]
+        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
+
+      # 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
+      else
+        logger.error("Unknown Format: `#{format}`")
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: git-releaselog
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Markus Chmelar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.23.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.23.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+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
+email: markus.chmelar@innovaptor.com
+executables:
+- git-releaselog
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/git-releaselog
+- lib/changelog.rb
+- lib/changelog_helpers.rb
+- lib/git-releaselog.rb
+homepage: https://github.com/iv-mexx/git-releaselog
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Generate a releaselog from a git repository
+test_files: []