vclog 1.8.2 → 1.9.0

data/lib/vclog/change_point.rb

@@ -0,0 +1,77 @@
+module VCLog
+
+  # The Change class models an entry in a change log.
+  #
+  class ChangePoint
+
+    # Type of change, as assigned by hueristics.
+    attr_accessor :type
+
+    # The priority level of this change, as assigned by hueristics.
+    # This can be `nil`, as Heuristics will always make sure a
+    # commit has an inteer level before going out to template.
+    attr_accessor :level
+
+    # The descriptive label of this change, as assigned by hueristics.
+    attr_accessor :label
+
+    # ANSI color to apply. Actually this can be a list
+    # of any support ansi gem terms, but usually it's 
+    # just the color term, such as `:red`.
+    attr_accessor :color
+
+    #
+    def initialize(change, message)
+      @change  = change
+      @message = message.strip
+
+      @label = nil
+      @level = nil
+    end
+
+    # Change from which point is derived.
+    attr :change
+
+    # The point's message.
+    attr_accessor :message
+    alias_method :msg,  :message
+    alias_method :msg=, :message=
+
+    # Delegate missing methods to +change+.
+    def method_missing(s,*a,&b)
+      if @change.respond_to?(s)
+        @change.send(s,*a,&b)
+      else
+p caller
+        super(s,*a,&b)
+      end
+    end
+
+    # Change points do not have sub-points.
+    def points
+      []
+    end
+
+    # Apply heuristic rules to change.
+    def apply_heuristics(heuristics)
+      heuristics.apply(self)
+    end
+
+    #
+    def to_h
+      { 'author'   => change.author,
+        'date'     => change.date,
+        'id'       => change.id,
+        'message'  => message,
+        'type'     => type
+      }
+    end
+
+    #
+    def to_s(*)
+      message
+    end
+
+  end
+
+end

data/lib/vclog/changelog.rb

@@ -1,28 +1,31 @@
-module VCLog
+require 'vclog/core_ext'
+require 'vclog/change'
 
-  require 'vclog/facets'
-  require 'vclog/change'
+module VCLog
 
-  # Supports output formats:
-  #
-  #   xml
-  #   html
-  #   yaml
-  #   json
-  #   text
+  # A ChangeLog encapsulates a list of Change objects.
   #
   class ChangeLog
 
     include Enumerable
 
-    DIR = File.dirname(__FILE__)
+    #DIR = File.dirname(__FILE__)
 
+    #
     # Seconds in a day.
+    #
     DAY = 24*60*60
 
+    #
+    # Array of Change or ChangePoint instances.
     #
     attr :changes
 
+    #
+    # Setup new ChangeLog instance.
+    #
+    # @param [Array<Change>] changes
+    #   An array of Change objects.
     #
     def initialize(changes=nil)
       @changes = []
@@ -36,62 +39,89 @@ module VCLog
     #    when Change
     #      @changes << change
     #    else
-    #      @changes << Change.new(*change)
+    #      @changes << Change.new(change)
     #    end
     #  end
     #end
 
     # Add a change entry to the log.
-    def change(rev, date, who, note, type=nil)
-      @changes << Change.new(rev, date, who, note, type)
+    def change(data={})
+      @changes << Change.new(data)
     end
 
+    #
+    # Sort changes in place.
     #
     def sort!(&block)
       changes.sort!(&block)
     end
 
+    #
+    # Iterate over each change.
     #
     def each(&block)
       changes.each(&block)
     end
 
+    #
+    # Is the changelog void of any changes?
     #
     def empty?
       changes.empty?
     end
 
+    #
+    # Return the number of changes in the changelog.
     #
     def size
       changes.size
     end
 
+    #
+    # And a change to the changelog.
     #
     def <<(entry)
-      raise unless Change===entry
-      @changes << entry
+      case entry
+      when Change, ChangePoint
+        @changes << entry
+      else
+        #raise "Not a Change ro ChangePoint instance - #{entry.inspect}"
+      end
     end
 
-    # Return a new changelog with entries that have a specified type.
-    # TODO: Be able to specify which types to include or omit.
-    #def typed
-    #  self.class.new(changes.select{ |e| e.type })
-    #end
+    #
+    # Return a new changelog with entries having a level higer or
+    # equal to the given level.
+    #
+    def above(level)
+      above = changes.select{ |entry| entry.level >= level }
+      self.class.new(above)
+    end
 
+    #
     # Return a new changelog with entries occuring after the
     # given date limit.
+    #
     def after(date_limit)
       after = changes.select{ |entry| entry.date > date_limit + DAY }
       self.class.new(after)
     end
 
+    #
     # Return a new changelog with entries occuring before the
     # given date limit.
+    #
     def before(date_limit)
       before = changes.select{ |entry| entry.date <= date_limit + DAY }
       self.class.new(before)
     end
 
+    # Return a new changelog with entries that have a specified type.
+    # TODO: Be able to specify which types to include or omit.
+    #def typed
+    #  self.class.new(changes.select{ |e| e.type })
+    #end
+
     #
     def by_type
       mapped = {}
@@ -133,173 +163,15 @@ module VCLog
     #  mapped
     #end
 
-    def to_h
-      map{ |change| change.to_h }
-    end
-
-
-    # O U T P U T  F O R M A T S
-
-    #
-
-#    def to_gnu(rev=false)
-#      x = []
-#      by_date.each do |date, date_changes|
-#        date_changes.by_author.each do |author, author_changes|
-#          x << %[#{date}  #{author}\n]
-#          #author_changes = author_changes.sort{|a,b| b.date <=> a.date}
-#          author_changes.each do |entry|
-#            if entry.type
-#              msg = "#{entry.message} [#{entry.type}]".tabto(10)
-#            else
-#              msg = "#{entry.message}".tabto(10)
-#            end
-#            msg << " (#{entry.revision})" if rev
-#            msg[8] = '*'
-#            x << msg
-#          end
-#        end
-#        x << "\n"
-#      end
-#      return x.join("\n")
-#    end
-
-=begin
     #
-
-    def to_gnu(rev=false)
-      tmp = File.read(File.join(DIR, 'templates', 'changelog.gnu'))
-      erb = ERB.new(tmp)
-      erb.result(binding)
-    end
-
+    # Convert to list of hash.
     #
-
-    def to_yaml
-      require 'yaml'
-      changes.to_yaml
-    end
-
+    # @return [Array<Hash>]
     #
-
-    def to_json
-      require 'json'
-      changes.to_json
-    end
-=end
-
-=begin
+    # @todo Not a Hash! Need to rename method.
     #
-    alias_method :to_s, :to_gnu
-
-    # Translate changelog into a XML document.
-
-    def to_xml(xsl=nil)
-      tmp = File.read(File.join(DIR, 'templates', 'changelog.xml'))
-      erb = ERB.new(tmp)
-      erb.result(binding)
-    end
-
-    # Create an HTML formated changelog.
-    # +css+ reference defaults to 'log.css'
-
-    def to_html(css=nil)
-      tmp = File.read(File.join(DIR, 'templates', 'changelog.html'))
-      erb = ERB.new(tmp)
-      erb.result(binding)
-    end
-
-    # Translate history into a RDoc formatted document.
-
-    def to_rdoc(rev=false)
-      tmp = File.read(File.join(DIR, 'templates', 'changelog.rdoc'))
-      erb = ERB.new(tmp)
-      erb.result(binding)
-    end
-
-    # Translate history into a Markdown formatted document.
-
-    def to_markdown(rev=false)
-      tmp = File.read(File.join(DIR, 'templates', 'changelog.markdown'))
-      erb = ERB.new(tmp)
-      erb.result(binding)
-    end
-=end
-
-=begin
-    # Create an XML formated changelog.
-    # +xsl+ reference defaults to 'log.xsl'
-    def to_xml(xsl=nil)
-      xsl = 'log.xsl' if xsl.nil?
-      x = []
-      x << %[<?xml version="1.0"?>]
-      x << %[<?xml-stylesheet href="#{xsl}" type="text/xsl" ?>] if xsl
-      x << %[<log>]
-      changes.sort{|a,b| b.date <=> a.date}.each do |entry|
-        x << %[<entry>]
-        x << %[  <date>#{entry.date}</date>]
-        x << %[  <author>#{escxml(entry.author)}</author>]
-        x << %[  <revision>#{escxml(entry.revision)}</revision>]
-        x << %[  <type>#{escxml(entry.type)}</type>]
-        x << %[  <message>#{escxml(entry.message)}</message>]
-        x << %[</entry>]
-      end
-      x << %[</log>]
-      return x.join("\n")
-    end
-=end
-
-=begin
-    def to_html(css=nil)
-      css = 'log.css' if css.nil?
-      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 << %[  <div class="changelog">]
-      x << %[    <h1>ChangeLog</h1>]
-      x << %[    <ul class="log">]
-      changes.sort{|a,b| b.date <=> a.date}.each do |entry|
-        x << %[  <li class="entry">]
-        x << %[    <div class="date">#{entry.date}</div>]
-        x << %[    <div class="author">#{escxml(entry.author)}</div>]
-        x << %[    <div class="type">#{escxml(entry.type)}</div>]
-        x << %[    <div class="message">#{escxml(entry.message)}</div>]
-        x << %[    <div class="revision">##{escxml(entry.revision)}</div>]
-        x << %[  </li>]
-      end
-      x << %[    </ul>]
-      x << %[  </div>]
-      x << %[</body>]
-      x << %[</html>]
-      return x.join("\n")
-    end
-=end
-
-  private
-
-    #
-    def h(input)
-       result = input.to_s.dup
-       result.gsub!("&", "&amp;")
-       result.gsub!("<", "&lt;")
-       result.gsub!(">", "&gt;")
-       result.gsub!("'", "&apos;")
-       #result.gsub!("@", "&at;")
-       result.gsub!("\"", "&quot;")
-       return result
+    def to_h
+      map{ |change| change.to_h }
     end
 
   end
@@ -308,118 +180,8 @@ end
 
 
 
-
-
-
-
-
-
-
-=begin
-    #
-    def format_rel(file, current_version=nil, current_release=nil, rev=false)
-      log = []
-      # collect releases already listed in changelog file
-      rels = releases(file)
-      # add current verion to release list (if given)
-      previous_version = rels[0][0]
-      if current_version < previous_version
-        raise ArgumentError, "Release version is less than previous version (#{previous_version})."
-      end
-      #case current_version
-      #when 'major'
-      #    v = previous_verison.split(/\W/)
-      #    v[0] = v[0].succ
-      #    current_version = v.join('.')
-      #when 'minor'
-      #    v = previous_verison.split(/\W/)
-      #    v[1] = v[1].succ
-      #    current_version = v.join('.')
-      #  end
-      #end
-      rels << [current_version, current_release || Time.now]
-      # make sure all release date are Time objects
-      rels = rels.collect{ |v,d| [v, Time===d ? d : Time.parse(d)] }
-      # only uniq releases
-      rels = rels.uniq
-      # sort by release date
-      rels = rels.to_a.sort{ |a,b| a[1] <=> b[1] }
-      # organize into deltas
-      deltas, last = [], nil
-      rels.each do |rel|
-        deltas << [last, rel]
-        last = rel
-      end
-      # gather changes for each delta and build log
-      deltas.each do |gt, lt|
-        if gt
-          gt_vers, gt_date = *gt
-          lt_vers, lt_date = *lt
-          #gt_date = Time.parse(gt_date) unless Time===gt_date
-          #lt_date = Time.parse(lt_date) unless Time===lt_date
-          changes = after(gt_date).before(lt_date)
-        else
-          lt_vers, lt_date = *lt
-          #lt_date = Time.parse(lt_date) unless Time===lt_date
-          changes = before(lt_date)
-        end
-        reltext = changes.format_rel_types(rev)
-        unless reltext.strip.empty?
-          log << "#{marker} #{lt_vers} / #{lt_date.strftime('%Y-%m-%d')}\n\n#{reltext}"
-        end
-      end
-      # reverse log order and make into document
-      marker[0,1] + " #{title}\n\n" +  log.reverse.join("\n")
-    end
-
-    #
-    def format_rel_types(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].label}\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
-
-    #
-    def releases(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
+# TODO: THIS IS HERE AS A REMINDER ABOUT TEH XSL TEMPLATE.
+#       WHAT TO DO WITH IT?
 
 =begin
     ###################