vclog 1.1 → 1.2

data/lib/vclog/cli.rb

@@ -0,0 +1,220 @@
+module VCLog
+
+  require 'vclog/vcs'
+  require 'optparse'
+
+  # = vclog Command
+  #
+  # == SYNOPSIS
+  #
+  # VCLog provides cross-vcs ChangeLogs. It works by
+  # parsing the native changelog a VCS system produces
+  # into a common model, which then can be used to
+  # produce Changelogs in a variety of formats.
+  #
+  # VCLog currently support SVN and Git. CVS, Darcs and
+  # Mercurial/Hg are in the works.
+  #
+  # == EXAMPLES
+  #
+  # To produce a GNU-like changelog:
+  #
+  #  $ vclog
+  #
+  # For XML format:
+  #
+  #  $ vclog --xml
+  #
+  # Or for a micorformat-ish HTML:
+  #
+  #  $ vclog --html
+  #
+  # To use the library programmatically, please see the API documentation.
+
+  def self.run
+    begin
+      vclog
+    rescue => err
+      if $DEBUG
+        raise err
+      else
+        puts err.message
+        exit -1
+      end
+    end
+  end
+
+  #
+  def self.vclog
+    type    = :log
+    format  = :gnu
+    vers    = nil
+    style   = nil
+    output  = nil
+    title   = nil
+    version = nil
+    extra   = false
+    rev     = false
+    typed   = false
+
+    optparse = OptionParser.new do |opt|
+
+      opt.banner = "Usage: vclog [TYPE] [FORMAT] [OPTIONS] [DIR]"
+
+      opt.separator(" ")
+      opt.separator("OUTPUT TYPE (choose one):")
+
+      opt.on('--log', '--changelog', '-l', "changelog (default)") do
+        type = :log
+      end
+
+      opt.on('--rel', '--history', '-r', "release history") do
+        type = :rel
+      end
+
+      opt.on('--bump', '-b', "display a bumped version number") do
+        doctype = :bump
+      end
+
+      opt.on('--current', '-c', "display current version number") do
+        doctype = :curr
+      end
+
+      opt.separator(" ")
+      opt.separator("FORMAT (choose one):")
+
+      opt.on('--gnu', "GNU standard format (default)") do
+        format = :gnu
+      end
+
+      opt.on('--xml', "XML format") do
+        format = :xml
+      end
+
+      opt.on('--yaml', "YAML format") do
+        format = :yaml
+      end
+
+      opt.on('--json', "JSON format") do
+        format = :json
+      end
+
+      opt.on('--html', "HTML micro-like format") do
+        format = :html
+      end
+
+      opt.on('--rdoc', "RDoc format") do
+        format = :rdoc
+      end
+
+      opt.on('--markdown', '-m', "Markdown format") do
+        format = :markdown
+      end
+
+      opt.separator(" ")    
+      opt.separator("OTHER OPTIONS:")
+
+      #opt.on('--typed', "catagorize by commit type") do
+      #  typed = true
+      #end
+
+      opt.on('--title <TITLE>', "document title, used by some formats") do |string|
+        title = string
+      end
+
+      opt.on('--extra', '-e', "provide extra output, used by some formats") do
+        extra = true
+      end
+
+      opt.on('--version', '-v <NUM>', "current version to use for release history") do |num|
+        version = num
+      end
+
+      opt.on('--style [FILE]', "provide a stylesheet name (css or xsl) for xml and html formats") do |val|
+        style = val
+      end
+
+      opt.on('--id', "include revision ids (in formats that normally do not)") do
+        rev = true
+      end
+
+      # DEPRECATE
+      opt.on('--output', '-o [FILE]', "send output to a file instead of stdout") do |out|
+        output = out
+      end
+
+      opt.separator(" ")
+      opt.separator("STANDARD OPTIONS:")
+
+      opt.on('--debug', "show debugging infromation") do
+        $DEBUG = true
+      end
+
+      opt.on_tail('--help' , '-h', 'display this help information') do
+        puts opt
+        exit
+      end
+    end
+
+    optparse.parse!(ARGV)
+
+    root = ARGV.shift || Dir.pwd
+
+    vcs = VCLog::VCS.factory #(root)
+
+    case type
+    when :bump
+      puts vcs.bump(version)
+      exit
+    when :curr
+      puts vcs.tags.last.name #TODO: ensure latest
+      exit
+    when :log
+      log = vcs.changelog
+      #log = log.typed if typed  #TODO: ability to select types?
+    when :rel
+      log = vcs.history(:title=>title, :extra=>extra, :version=>version)
+    else
+      raise "huh?"
+      #log = vcs.changelog
+      #log = log.typed if typed  #TODO: ability to select types?
+    end
+
+    case format
+    when :xml
+      txt = log.to_xml(style)   # xsl stylesheet url
+    when :html
+      txt = log.to_html(style)  # css stylesheet url
+    when :yaml
+      txt = log.to_yaml
+    when :json
+      txt = log.to_json
+    when :markdown
+      txt = log.to_markdown(rev)
+    when :rdoc
+      txt = log.to_rdoc(rev)
+    else #:gnu
+      txt = log.to_gnu(rev)
+    end
+
+    if output
+      File.open(output, 'w') do |f|
+        f << txt
+      end
+    else
+      puts txt
+    end
+  end
+
+  #def self.changelog_file(file)
+  #  if file && File.file?(file)
+  #    file
+  #  else
+  #    Dir.glob('{history,changes,changelog}{,.*}', File::FNM_CASEFOLD).first
+  #  end
+  #end
+
+end
+
+# VCLog Copyright (c) 2008 Thomas Sawyer
+

data/lib/vclog/history.rb

@@ -0,0 +1,314 @@
+module VCLog
+
+  require 'vclog/facets'
+  require 'vclog/changelog'
+  require 'vclog/tag'
+  require 'vclog/release'
+
+  # = Release History Class
+  #
+  # A Release History is very similar to a ChangeLog.
+  # It differs in that it is divided into releases with
+  # version, release date and release note.
+  #
+  # The release version, date and release note can be
+  # descerened from the underlying SCM by identifying
+  # the hard tag commits.
+  # 
+  # But we can also extract the release information from a
+  # release history file, if provided. And it's release
+  # information should take precidence. ???
+  #
+  #
+  # TODO: Extract output formating from delta parser.
+  #
+  class History
+
+    attr :vcs
+
+    attr_accessor :marker
+
+    attr_accessor :title
+
+    # Current working version.
+    attr_accessor :version
+
+    attr_accessor :extra
+
+    #
+    def initialize(vcs, opts={})
+      @vcs = vcs
+      @marker    = opts[:marker]  || "#"
+      @title     = opts[:title]   || "RELEASE HISTORY"
+      @extra     = opts[:extra]
+      @version   = opts[:version]
+    end
+
+    # Tag list from version control system.
+    def tags
+      @tags ||= vcs.tags
+    end
+
+    # Change list from version control system.
+    def changes
+      @changes ||= vcs.changes
+    end
+
+    # Changelog object
+    def changelog
+      @changlog ||= vcs.changelog #ChangeLog.new(changes)
+    end
+
+    #
+    def releases
+      @releases ||= (
+        rel = []
+
+        tags = tags()
+
+        ver  = vcs.bump(version)
+        time = ::Time.now
+        user = ENV['USER']  # TODO: get user name from vcs
+
+        tags << Tag.new(ver, time, user, "FIXME")
+
+        # TODO: Do we need to add a Time.now tag?
+        # add current verion to release list (if given)
+        #previous_version = tags[0].name
+        #if current_version < previous_version  # TODO: need to use natural comparision
+        #  raise ArgumentError, "Release version is less than previous version (#{previous_version})."
+        #end
+        #rels << [current_version, current_release || Time.now]
+        #rels = rels.uniq      # only uniq releases
+
+        # sort by release date
+        tags = tags.sort{ |a,b| a.date <=> b.date }
+
+        # organize into deltas
+        deltas, last = [], nil
+        tags.each do |tag|
+          deltas << [last, tag]
+          last = tag
+        end
+
+        # gather changes for each delta and build log
+        deltas.each do |gt, lt|
+          if gt
+            gt_vers, gt_date = gt.name, gt.date
+            lt_vers, lt_date = lt.name, lt.date
+            #gt_date = Time.parse(gt_date) unless Time===gt_date
+            #lt_date = Time.parse(lt_date) unless Time===lt_date
+            log = changelog.after(gt_date).before(lt_date)
+          else
+            lt_vers, lt_date = lt.name, lt.date
+            #lt_date = Time.parse(lt_date) unless Time===lt_date
+            log = changelog.before(lt_date)
+          end
+
+          rel << Release.new(lt, log.changes)
+        end
+        rel
+      )
+    end
+
+    #
+    def to_s(rev=false)
+      to_gnu(rev)
+    end
+
+    # TODO: What would GNU history be?
+    def to_gnu(rev=false)
+      to_markdown(rev)
+    end
+
+    # Translate history into an XML document.
+    def to_xml(xsl=nil)
+      require 'rexml/document'
+      xml = REXML::Document.new('<history></history>')
+      #xml << REXML::XMLDecl.default
+      root = xml.root
+      releases.each do |release|
+        rel = root.add_element('release')
+        tel = rel.add_element('tag')
+        tel.add_element('name').add_text(release.tag.name)
+        tel.add_element('date').add_text(release.tag.date.to_s)
+        tel.add_element('author').add_text(release.tag.author)
+        tel.add_element('message').add_text(release.tag.message)
+        cel = rel.add_element('changes')
+        release.changes.sort{|a,b| b.date <=> a.date}.each do |entry|
+          el = cel.add_element('entry')
+          el.add_element('date').add_text(entry.date.to_s)
+          el.add_element('author').add_text(entry.author)
+          el.add_element('type').add_text(entry.type)
+          el.add_element('revision').add_text(entry.revision)
+          el.add_element('message').add_text(entry.message)
+        end
+      end
+      out = String.new
+      fmt = REXML::Formatters::Pretty.new
+      fmt.compact = true
+      fmt.write(xml, out)
+      #
+      txt  = %[<?xml version="1.0"?>\n]
+      txt += %[<?xml-stylesheet href="#{xsl}" type="text/xsl" ?>\n] if xsl
+      txt += out
+      txt
+    end
+
+    # Translate history into a HTML document.
+    #
+    # TODO: Need to add some headers.
+    #
+    def to_html(css=nil)
+      require 'rexml/document'
+      xml = REXML::Document.new('<div class="history"></div>')
+      #xml << REXML::XMLDecl.default
+      root = xml.root
+      releases.each do |release|
+        rel = root.add_element('div')
+        rel.add_attribute('class', 'release')
+        tel = rel.add_element('div')
+        tel.add_attribute('class', 'tag')
+        tel.add_element('div').add_text(release.tag.name).add_attribute('class', 'name')
+        tel.add_element('div').add_text(release.tag.date.to_s).add_attribute('class', 'date')
+        tel.add_element('div').add_text(release.tag.author).add_attribute('class', 'author')
+        tel.add_element('div').add_text(release.tag.message).add_attribute('class', 'message')
+        cel = rel.add_element('ul')
+        cel.add_attribute('class', 'changes')
+        release.changes.sort{|a,b| b.date <=> a.date}.each do |entry|
+          el = cel.add_element('li')
+          el.add_attribute('class', 'entry')
+          el.add_element('div').add_text(entry.date.to_s).add_attribute('class', 'date')
+          el.add_element('div').add_text(entry.author).add_attribute('class', 'author')
+          el.add_element('div').add_text(entry.type).add_attribute('class', 'type')
+          el.add_element('div').add_text(entry.revision).add_attribute('class', 'revision')
+          el.add_element('div').add_text(entry.message).add_attribute('class', 'message')
+        end
+      end
+      out = String.new
+      fmt = REXML::Formatters::Pretty.new
+      fmt.compact = true
+      fmt.write(xml, out)
+      #
+      x = []
+      x << %[<html>]
+      x << %[<head>]
+      x << %[  <title>ChangeLog</title>]
+      x << %[  <style>]
+      x << %[    body{font-family: sans-serif;}]
+      x << %[    #changelog{width:800px;margin:0 auto;}]
+      x << %[    li{padding: 10px;}]
+      x << %[    .date{font-weight: bold; color: gray; float: left; padding: 0 5px;}]
+      x << %[    .author{color: red;}]
+      x << %[    .message{padding: 5 0; font-weight: bold;}]
+      x << %[    .revision{font-size: 0.8em;}]
+      x << %[  </style>]
+      x << %[  <link rel="stylesheet" href="#{css}" type="text/css">] if css
+      x << %[</head>]
+      x << %[<body>]
+      x << out
+      x << %[</body>]
+      x << %[</html>]
+      x.join("\n")
+    end
+
+    # Translate history into a YAML document.
+    def to_yaml(*args)
+      require 'yaml'
+      releases.to_yaml(*args)
+    end
+
+    # Translate history into a JSON document.
+    def to_json
+      require 'json'
+      releases.to_json
+    end
+
+    # Translate history into a Markdown formatted document.
+    def to_markdown(rev=false)
+      to_markup('#', rev)
+    end
+
+    # Translate history into a RDoc formatted document.
+    def to_rdoc(rev=false)
+      to_markup('=', rev)
+    end
+
+    #
+    def to_markup(marker, rev=false)
+      entries = []
+      releases.each do |release|
+        tag     = release.tag
+        changes = release.changes
+        change_text = to_markup_changes(changes, rev)
+        unless change_text.strip.empty?
+          if extra
+            entries << "#{marker*2} #{tag.name} / #{tag.date.strftime('%Y-%m-%d')}\n\n#{tag.message}\n\nChanges:\n\n#{change_text}"
+          else
+            entries << "#{marker*2} #{tag.name} / #{tag.date.strftime('%Y-%m-%d')}\n\n#{change_text}"
+          end
+        end
+      end
+      # reverse entries order and make into document
+      marker + " #{title}\n\n" +  entries.reverse.join("\n")
+    end
+
+  private
+
+    #
+    def to_markup_changes(changes, rev=false)
+      groups = changes.group_by{ |e| e.type_number }
+      string = ""
+      5.times do |n|
+        entries = groups[n]
+        next if !entries
+        next if entries.empty?
+        string << "* #{entries.size} #{entries[0].type_phrase}\n\n"
+        entries.sort!{|a,b| a.date <=> b.date }
+        entries.each do |entry|
+          #string << "== #{date}  #{who}\n\n"  # no email :(
+          if rev
+            text = "#{entry.message} (##{entry.revision})"
+          else
+            text = "#{entry.message}"
+          end
+          text = text.tabto(6)
+          text[4] = '*'
+          #entry = entry.join(' ').tabto(6)
+          #entry[4] = '*'
+          string << text
+          string << "\n"
+        end
+        string << "\n"
+      end
+      string
+    end
+
+=begin
+    # Extract release tags from a release file.
+    #
+    # TODO: need to extract message (?)
+    #
+    def releases_from_file(file)
+      return [] unless file
+      clog = File.read(file)
+      tags = clog.scan(/^(==|##)(.*?)$/)
+      rels = tags.collect do |t|
+        parse_version_tag(t[1])
+      end
+      @marker = tags[0][0]
+      return rels
+    end
+
+    #
+    def parse_version_tag(tag)
+      version, date = *tag.split('/')
+      version, date = version.strip, date.strip
+      return version, date
+    end
+=end
+
+  end
+
+end
+