rubycut-vclog 1.9.4

data/lib/vclog/adapters/hg.rb

@@ -0,0 +1,129 @@
+require 'vclog/adapters/abstract'
+
+module VCLog
+
+  module Adapters
+
+    # Mercurial Adapter
+    #
+    class Hg < Abstract
+
+      #
+      # Collect changes.
+      #
+      def extract_changes
+        list = []
+        changelog = `hg log -v`.strip
+        changes = changelog.split("\n\n\n")
+        changes.each do |entry|
+          settings = parse_entry(entry)
+          list << Change.new(settings)
+        end
+        list
+      end
+
+      #
+      # Collect tags.
+      #
+      # @todo Extract first commit prior to tag and provide it with Tag object.
+      #
+      def extract_tags
+        list = []
+        if File.exist?('.hgtags')
+          File.readlines('.hgtags').each do |line|
+            rev, tag = line.strip.split(' ')
+            entry = `hg log -v -r #{rev}`.strip
+            settings = parse_entry(entry)
+            settings[:name] = tag
+            list << Tag.new(settings)
+          end
+        end
+        list
+      end
+
+      #
+      # Username.
+      #
+      # @todo check .hgrc for user.
+      #
+      def user
+        ENV['HGUSER'] || ENV['USER']
+      end
+
+      #
+      # User's email address.
+      #
+      # @todo check .hgrc for email.
+      #
+      def email
+        ENV['HGEMAIL'] || ENV['EMAIL']
+      end
+
+      #
+      # URI of repository.
+      #
+      def uri
+        @uri ||= `hg showconfig paths.default`.strip
+      end
+
+      # @deprecated
+      alias_method :repository, :uri
+
+      #
+      #
+      #
+      def uuid
+        nil
+      end
+
+      #
+      # TODO: Will multi-line messages work okay this way?
+      #
+      def tag(ref, label, date, msg)
+        file = tempfile("message", msg)
+        date = date.strftime('%Y-%m-%d') unless String===date
+
+        cmd  = %[hg tag -r #{ref} -d #{date} -m "$(cat #{file})" #{label}]
+
+        puts cmd if $DEBUG
+        `#{cmd}` unless $DRYRUN
+      end
+
+     private
+
+      #
+      # Parse log entry.
+      #
+      def parse_entry(entry)
+        settings = {}
+
+        entry.strip!
+
+        if md = /^changeset:(.*?)$/.match(entry)
+          settings[:id] = md[1].strip
+        end
+
+        if md = /^date:(.*?)$/.match(entry)
+          settings[:date] = Time.parse(md[1].strip)
+        end
+
+        if md = /^user:(.*?)$/.match(entry)
+          settings[:who] = md[1].strip
+        end
+
+        if md = /^files:(.*?)$/.match(entry)
+          settings[:files] = md[1].strip.split(' ')
+        end
+
+        if md = /^description:(.*?)\Z/m.match(entry)
+          settings[:msg] = md[1].strip
+        end
+
+        return settings
+      end
+
+    end
+
+  end
+
+end

data/lib/vclog/adapters/svn.rb

@@ -0,0 +1,155 @@
+require 'vclog/adapters/abstract'
+
+module VCLog
+
+  module Adapters
+
+    # SVN Adapter.
+    #
+    # NOTE: Unfortunately the SVN adapater is very slow. If hits the server
+    # every time the 'svn log' command is issued. When generating a History
+    # that's two hits for every tag. If anyone knows a better way please have
+    # at it --maybe future versions of SVN will improve the situation.
+    #
+    class Svn < Abstract
+
+      def initialize(root)
+        begin
+          require 'xmlsimple'
+        rescue LoadError
+          raise LoadError, "VCLog requires xml-simple for SVN support."
+        end
+        super(root)
+      end
+
+      # Extract changes.
+      def extract_changes
+        log = []
+
+        xml = `svn log -v --xml`.strip
+
+        commits = XmlSimple.xml_in(xml, {'KeyAttr' => 'rev'})
+        commits = commits['logentry']
+
+        commits.each do |com|
+          rev  = com['revision']
+          msg  = [com['msg']].flatten.compact.join('').strip
+          who  = [com['author']].flatten.compact.join('').strip
+          date = [com['date']].flatten.compact.join('').strip
+
+          files = com['paths'].map{ |h| h['path'].map{ |y| y['content'] } }.flatten
+
+          next if msg.empty?
+          next if msg == "*** empty log message ***"
+
+          date = Time.parse(date)
+
+          log << Change.new(:id=>rev, :date=>date, :who=>who, :msg=>msg, :files=>files)
+        end
+
+        log
+      end
+
+      # Extract tags.
+      def extract_tags
+        list = []
+        tagdir = tag_directory
+
+        if tagdir
+          tags = Dir.entries(tagdir).select{ |e| e.index('.') != 0 && e =~ /\d(.*)$/ }
+        else
+          tags = []
+        end
+
+        tags.each do |path|
+          dir = File.join(tagdir, path)
+
+          # using yaml, but maybe use xml instead?
+          info = `svn info #{dir}`
+          info = YAML.load(info)
+          md = /(\d.*)$/.match(info['Path'])
+          name = md ? md[1] : path
+          date = info['Last Changed Date']
+          who  = info['Last Changed Author']
+          rev  = info['Revision']
+
+          # get last commit
+          xml = `svn log -l1 --xml #{dir}`
+          commits = XmlSimple.xml_in(xml, {'KeyAttr' => 'rev'})
+          commit = commits['logentry'].first
+
+          msg  = [commit["msg"]].flatten.compact.join('').strip
+          date = [commit["date"]].flatten.compact.join('').strip
+
+          list << Tag.new(:name=>name, :id=>rev, :date=>date, :who=>who, :msg=>msg)
+        end
+        list
+      end
+
+      # This isn't perfect, but is there really anyway for it to be?
+      # It ascends up the current directory tree looking for the 
+      # best candidate for a tags directory.
+      def tag_directory
+        fnd = nil
+        dir = root
+        while dir != '/' do
+          entries = Dir.entries(dir)
+          if entries.include?('.svn')
+            if entries.include?('tags')
+              break(fnd = File.join(dir, 'tags'))
+            else
+              entries = entries.reject{ |e| e.index('.') == 0 }
+              entries = entries.reject{ |e| e !~ /\d$/ }
+              break(fnd = dir) unless entries.empty?
+            end
+          else
+            break(fnd=nil)
+          end
+          dir = File.dirname(dir)
+        end
+        fnd
+      end
+
+      #
+      def user
+        @email ||= `svn propget svn:author`.strip
+      end
+
+      # TODO: Best solution to SVN email?
+      def email
+        @email ||= ENV['EMAIL']
+      end
+
+      #
+      def repository
+        info['Repository Root']
+      end
+
+      #
+      def uuid
+        info['Repository UUID']
+      end
+
+      # TODO: Need to effect svn tag date. How?
+      def tag(ref, label, date, message)
+        file = tempfile("message", message)
+
+        Dir.chdir(root) do
+          cmd = %[svn copy -r #{ref} -F "#{mfile.path}" . #{tag_directory}/#{label}]
+          puts cmd if $DEBUG
+          `#{cmd}` unless $DRYRUN
+        end
+      end
+
+      private
+
+      #
+      def info
+        @info ||= YAML.load(`svn info`.strip)
+      end
+
+    end
+
+  end
+
+end

data/lib/vclog/change.rb

@@ -0,0 +1,207 @@
+require 'vclog/change_point'
+
+module VCLog
+
+  # The Change class models an entry in a change log.
+  #
+  class Change
+
+    include Comparable
+
+    # Commit revision/reference id.
+    attr_accessor :id
+
+    # Date/time of commit.
+    attr_accessor :date
+
+    # Committer.
+    attr_accessor :author
+
+    # Commit message.
+    attr_accessor :message
+
+    # List of files changed in the commit.
+    attr_accessor :files
+
+    # 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
+
+    # Setup new Change instance.
+    def initialize(data={})
+      @type  = :default
+      @level = nil
+      @label = nil
+      @color = []
+
+      data.each do |k,v|
+        __send__("#{k}=", v) if respond_to?("#{k}=")
+      end
+    end
+
+    #
+    # Set authors attributes, ensuring the value is stripped of white space.
+    #
+    def author=(author)
+      @author = author.strip
+    end
+
+    #
+    # Set date attribute, converting vale given to an instance of Time.
+    #
+    def date=(date)
+      @date = parse_date(date)
+    end
+
+    #
+    # Set the commit message.
+    #
+    def message=(msg)
+      @message = msg
+
+      lines = msg.lines.to_a
+      @summary = lines.first.strip
+      @details = lines[1..-1].join('').strip
+
+      msg
+    end
+
+    #
+    # Set the ANSI color terms.
+    #
+    # @param [Symbol,Array<Symbol>] code
+    #   An ANSI gem recognized term, or array of such.
+    #
+    def color=(code)
+      @color = [code].flatten
+    end
+
+    #
+    def type=(type)
+      @type = type.to_sym
+    end
+
+    # Alternate name for id.
+    alias_method :rev,  :id
+    alias_method :rev=, :id=
+
+    # Alternate name for id.
+    alias_method :revision,  :id
+    alias_method :revision=, :id=
+
+    # Alternate name for id.
+    alias_method :ref,  :id
+    alias_method :ref=, :id=
+
+    # Alternate name for id.
+    alias_method :reference,  :id
+    alias_method :reference=, :id=
+
+    # Alternate name for message.
+    alias_method :msg,  :message
+    alias_method :msg=, :message=
+
+    # Alias for author.
+    alias_method :who,  :author
+    alias_method :who=, :author=
+
+    attr_reader :summary
+
+    attr_reader :details
+
+    #
+    # Compare changes by date.
+    #
+    def <=>(other)
+      other.date <=> date
+    end
+
+    #
+    # Inspection string of change object.
+    #
+    def inspect
+      "#<Change:#{object_id} #{date}>"
+    end
+
+    #
+    # Convert to Hash.
+    #
+    def to_h
+      { 'author'   => self.author,
+        'date'     => self.date,
+        'id'       => self.id,
+        'message'  => self.message,
+        'type'     => self.type
+      }
+    end
+
+    #
+    # Apply heuristic rules to change.
+    #
+    def apply_heuristics(heuristics)
+      heuristics.apply(self)
+    end
+
+    #
+    # Parse point entries from commit message. Point entries
+    # are outlined changes via line that start with an asterisk.
+    #
+    def points
+      @points ||= parse_points
+    end
+
+    #
+    # Output message with optional adjustments.
+    #
+    def to_s(opts={})
+      if opts[:summary]
+        summary
+      else
+        message.strip
+      end
+    end
+
+   private
+
+    #
+    # Convert given +date+ into Time instance.
+    #
+    # @param [String,Data,Time] date
+    #   A valid data/time string or object.
+    #
+    def parse_date(date)
+      case date
+      when Time
+        date
+      else
+        Time.parse(date.to_s)
+      end
+    end
+
+    #
+    # Split message into individual points.
+    #
+    # @todo Improve the parsing of point messages.
+    #
+    def parse_points
+      point_messages = message.split(/^\*/)
+      point_messages.map do |msg|
+        ChangePoint.new(self, msg)
+      end
+    end
+
+  end
+
+end