historian 0.0.1

data/lib/historian/git.rb

@@ -0,0 +1,189 @@
+require 'shellwords'
+require 'tempfile'
+require 'fileutils'
+
+class Historian::Git
+  class Hooker
+    attr_accessor :hook, :repo_dir
+
+    def initialize(repo_dir, hook)
+      self.repo_dir = repo_dir
+      self.hook = hook
+    end
+
+    def create_hook_script
+      File.open(hook_script, "w") do |f|
+        f.puts "#!/bin/bash"
+        f.puts "historian #{hook.to_s} $@"
+      end
+      File.chmod 0755, hook_script
+    end
+
+    def create_hook_scripts_dir
+      Dir.mkdir hook_scripts_dir unless File.directory? hook_scripts_dir
+    end
+
+    def create_hook_wrapper_script
+      File.open(hook_wrapper_script, "w") do |f|
+        script = <<-EOF
+          #!/bin/bash
+          #
+          # Git hook modified by Historian. Do not modify this file.
+          # Add more hooks in the #{hook_to_git}.d directory.
+          #
+          BASE=`dirname $0`
+          for S in $BASE/#{hook_to_git}.d/*
+          do
+          $S $@ || exit $?
+          done
+        EOF
+        f.puts script.gsub(/^\s+/,'')
+      end
+      File.chmod 0755, hook_wrapper_script
+    end
+
+    def other_git_hook_exists?
+      File.exists?(hook_wrapper_script) && !File.directory?(hook_scripts_dir)
+    end
+
+    def hook_script
+      File.join hook_scripts_dir, "historian"
+    end
+
+    def hook_scripts_dir
+      File.join hooks_dir, hook_to_git + ".d"
+    end
+
+    def hook_to_git
+      hook.to_s.gsub "_", "-"
+    end
+
+    def hook_wrapper_script
+      File.join hooks_dir, hook_to_git
+    end
+
+    def hooks_dir
+      File.join repo_dir, ".git", "hooks"
+    end
+
+    def install
+      create_hook_scripts_dir
+      create_hook_script
+      create_hook_wrapper_script
+    end
+
+    def installed?
+      File.exists? hook_script
+    end
+
+    def preserve_original
+      create_hook_scripts_dir
+      FileUtils.cp hook_wrapper_script, File.join(hook_scripts_dir, "original")
+    end
+
+    def update
+      create_hook_script
+    end
+  end
+
+
+  attr_reader :repo_directory, :history
+
+  def bundle_history_file
+    amend_history_changes
+  end
+
+  def initialize(dir, history)
+    @repo_directory = dir
+    @history = history
+  end
+
+  def install_hook(hook)
+    hook = Hooker.new(repo_directory, hook)
+    if hook.other_git_hook_exists?
+      hook.preserve_original
+      hook.install
+      :adapted
+    elsif !hook.installed?
+      hook.install
+      :created
+    else
+      hook.update
+      :exists
+    end
+  end
+
+  def tag_release
+    commit_history_changes if history_dirty?
+    ensure_history_has_release
+    Tempfile.open("historian") do |file|
+      file.puts commit_message_for_tag
+      file.flush
+      git "tag", "-a", tag, "-F", file.path
+    end
+  end
+
+protected
+
+  def amend_history_changes
+    Tempfile.open("historian") do |file|
+      git "add", history.path
+      git "commit", history.path, "--amend", "-C", "HEAD"
+    end
+  end
+
+  def commit_history_changes
+    Tempfile.open("historian") do |file|
+      file.puts commit_message_for_history
+      file.flush
+      git "add", history.path
+      git "commit", history.path, "-F", file.path
+    end
+  end
+
+  def history_dirty?
+    git("status", "--porcelain", history.path) =~ /^.M/
+  end
+
+  def hook_invokes_command?(command)
+    return false unless File.exists?(hook_script_for command)
+    lines = File.readlines(hook_script_for command).collect { |l| l.chomp }
+    lines.first == "#!/bin/bash" && lines.grep("historian #{command} $@")
+  end
+
+  def hook_script_for(hook)
+    File.join repo_directory, ".git/hooks", hook.to_s.gsub("_", "-")
+  end
+
+  def tag
+    'v' + history.current_version
+  end
+
+  def release_name
+    history.current_release_name
+  end
+
+  def commit_message_for_history
+    "update history for release"
+  end
+
+  def commit_message_for_tag
+    message = "tagged #{tag}"
+    if release_name
+      message += %{ "#{release_name}"}
+    end
+    message + "\n\n" + history.release_log
+  end
+
+  def ensure_history_has_release
+    if !history.changelog.empty?
+      history.release
+      commit_history_changes
+    end
+  end
+
+  def git(*args)
+    Dir.chdir repo_directory
+    %x(git #{args.collect { |a| Shellwords.escape a }.join " "})
+  end
+end

data/lib/historian/history_file.rb

@@ -0,0 +1,209 @@
+module Historian
+  module HistoryFile
+    # Example:
+    #
+    #   history = File.open("History.txt", "w+") # (empty file!)
+    #   history.extend Historian::HistoryFile
+    #   history.next_version # => "0.0.1"
+    #   history.update_history :minor => "added whizbangery",
+    #                          :release => "Awesome Release"
+    #   history.rewind
+    #   puts history.read
+    #     ## 0.1.0 Awesome Release - 2010/12/12
+    #
+    #     ### Minor Changes
+    #     * added whizbangery
+    #
+    # Note that the "w+" mode is critically important if you're
+    # extending a File object. The IO instance must be both
+    # readable and writeable.
+
+    SECTION_HEADERS = {
+      :major => "Major Changes",
+      :minor => "Minor Changes",
+      :patch => "Bugfixes"
+    }
+
+    # The pending changelog for the next release. See also #release_log.
+    def changelog
+      return "" unless changes? || @release
+
+      log = []
+      if @release
+        release_string = @release === true ? "" : " " + @release
+        date_string = " - " + Time.now.strftime("%Y/%m/%d")
+        log << "== #{next_version}#{release_string}#{date_string}"
+      else
+        log << "== In Git"
+      end
+      [ :major, :minor, :patch ].each do |significance|
+        unless changes[significance].empty?
+          log << "\n=== #{SECTION_HEADERS[significance]}"
+          changes[significance].each { |change| log << "* #{change}" }
+        end
+      end
+      log.join("\n")
+    end
+
+    def changes #:nodoc:
+      @changes ||= {
+        :major => [],
+        :minor => [],
+        :patch => []
+      }
+    end
+
+    # Whether there are changes since the last release
+    def changes?
+      parse unless parsed?
+      changes.find { |(k,v)| !v.empty? }
+    end
+
+    # The current (most-recently released) version number in "x.y.z" format
+    def current_version
+      parse unless parsed?
+      @current_version || "0.0.0"
+    end
+
+    # The next (upcoming release) version number, based on what
+    # pending changes currently exist. Major changes will increment
+    # the major number, else minor changes will increment the minor
+    # number, else the patch number is incremented.
+    def next_version
+      parse unless parsed?
+      (major, minor, patch) = current_version.split(".").collect { |n| n.to_i }
+      if !changes[:major].empty?
+        major += 1
+        patch = minor = 0
+      elsif !changes[:minor].empty?
+        minor += 1
+        patch = 0
+      else
+        patch += 1
+      end
+      "%d.%d.%d" % [ major, minor, patch ]
+    end
+
+    # whether the history file has already been parsed
+    def parsed?
+      @parsed
+    end
+
+    # Parse the entire history file. There's generally no
+    # need to call this method -- it should be called automatically
+    # when needed.
+    def parse
+      rewind
+      @changes = nil
+      @buffer = []
+      @release_log = []
+      state = :gathering_current_history
+      significance = nil
+      each_line do |line|
+        if state == :gathering_current_history
+          case line
+          when /^== ([0-9]+\.[0-9]+\.[0-9]+)(.*)/
+            state = :gathering_previous_release_log
+            @release_log << line
+            @buffer << line
+            @current_version = $1
+            if $2 =~ %r{ (.*) - [0-9]{4}/[0-9]{2}/[0-9]{2}}
+              @current_release_name = $1
+            end
+          when /^=== (.*)$/
+            significance = significance_for $1
+          when /^\* (.+)$/
+            if significance
+              changes[significance] << $1
+            else
+              raise ParseError.new "no significance preceeding history entry '#{$1}'"
+            end
+          when /^\s*$/, /^== In Git$/
+            #noop
+          else
+            raise ParseError.new("invalid history format: #{line}")
+          end
+        elsif state == :gathering_previous_release_log
+          if line =~ /^== ([0-9]+\.[0-9]+\.[0-9]+)(.*)/
+            state = :gathering_remainder
+          else
+            @release_log << line
+          end
+          @buffer << line
+        else
+          @buffer << line
+        end
+      end
+      @release_log = @release_log.join
+      @parsed = true
+    end
+
+    # Alias for update_history :release => true
+    def release
+      update_history :release => true
+    end
+
+    # If a release was just performed, this will return the changelog
+    # of the release. Otherwise, this is always nil.
+    def release_log
+      parse unless parsed?
+      @release_log
+    end
+
+    # Returns the name of the current release, either as parsed
+    # from the history file, or as provided if a release was
+    # recently performed.
+    def current_release_name
+      parse unless parsed?
+      @current_release_name
+    end
+
+    # Update the release history with new release information.
+    # Accepts a hash with any (or all) of four key-value pairs.
+    # [:major] a message describing a major change
+    # [:major] a message describing a minor change
+    # [:patch] a message describing a bugfix or other tiny change
+    # [:release] indicates this history should be updated for a new release, if present. If true, the release has no name, but if a string is provided the release will be annotated with the string
+    #
+    # To add multiple history entries of the same type, call
+    # this method mutiple times.
+    #
+    # *Note*: this method rewrites the entire IO instance to
+    # prepend the new history information.
+    def update_history(history)
+      parse unless parsed?
+      @release = history.delete(:release)
+      history.each do |(significance,message)|
+        changes[significance] << message
+      end
+      rewrite
+    end
+
+
+  protected
+
+    def rewrite #:nodoc:
+      rewind
+      puts changelog
+      puts ["\n"] * 2
+      puts @buffer
+      truncate pos
+      if @release
+        @release_log = changelog
+        @current_release_name = @release if @release.kind_of?(String)
+        parse
+        @release = nil
+        @changes = nil
+      end
+    end
+
+    def significance_for(string)
+      @@translation ||= SECTION_HEADERS.invert
+      if @@translation[string]
+        return @@translation[string]
+      else
+        raise ParseError.new("unknown significance '#{string}'")
+      end
+    end
+  end
+end

data/lib/historian/version.rb

@@ -0,0 +1,3 @@
+module Historian
+  VERSION = "0.0.1"
+end

data/spec/example_history.txt

@@ -0,0 +1,24 @@
+This is some text at the top of the history file. It should be left alone.
+
+== In Git
+
+This is a release section, representing in-progress (unreleased changes). This
+paragraph should be left alone.
+
+=== A Section
+* this is an entry in a section
+
+This is more freeform text. A section, like the one above, categorizes the
+information in the list below it. Common section names might include things
+like "New Features", "Bugfixes", "Minor Enhancements", etc.
+
+=== Another Section
+* this is an entry too
+* and another entry
+
+== 1.0.0 2009-01-01
+
+This is some freeform text that is part of an entirely different release section.
+Specifically, this is release 1.0.0, which it should be possible to find via
+'historian status 1.0.0'. The status command should ignore the date.
+

data/spec/fixtures/after_0_0_2

@@ -0,0 +1,16 @@
+== In Git
+
+=== Bugfixes
+* bugfix #1
+
+
+== 0.0.2 Bubbling Baboon
+
+=== Bugfixes
+* more fur
+
+
+== 0.0.1 Addled Adder
+
+=== Bugfixes
+* more scales

data/spec/fixtures/after_0_0_2_changelog

@@ -0,0 +1,6 @@
+== In Git
+
+=== Bugfixes
+* bugfix #1
+* bugfix #2
+