gitstats-ruby 1.0.0

data/README.markdown

@@ -0,0 +1,53 @@
+# gitstats-ruby
+
+gitstats-ruby is a clone of http://gitstats.sourceforce.net written in ruby. It's written to support templates and should be easily extendable.
+
+## Installation
+
+Right now you have to clone this repository until I upload a gem to rubygems.
+
+    git clone https://github.com/chrisistuff/gitstats-ruby.git
+
+## Getting started
+
+The basic usage is quite simple. Just run gitstats with the git directory as parameter. If you want to generate stats of more than one repository just list them one after another. Note that this will generate only one statistic but consider the commits from all repositories.
+Additionally you can also specify a name and a ref for each repository. To do this please use the following format: `<name>:<path to repository>:<ref>`.
+For example:
+
+    gitstats gitstats-ruby:.:master
+
+For more options please read sections about caching below or run `gitstats -h`.
+
+## Caching
+
+gitstats-ruby implements two types of caches but one of them is just useful when developing new statistic classes. The one useful for the end-user is the stats-cache and the other one (for the devs) is the commit-cache.
+
+### stats-cache
+
+The stats-cache caches the statistic objects used internally. This drastically improves the speed of incremental updates because only the new commits have to be taken into account. To activate this cache pass the `-c` command line flag. By default this creates the stats-cache file in the output directory. If you want to use another file you can specify it by using `--statcache <filename>`.
+
+Please note that this cache can only be used when working on the same repositories as used in the previous run. Identification is done using the repository name or, if not specified, using the given (not relative!) path.
+
+### commit-cache
+
+As already mentioned this cache is only useful if you want to develope new statistic classes. It works by caching the internal commit objects to a per repository file that can be reread when running again. This is especially useful if you experiment with big repositories (i.e. the linux kernel with ~275000 commits) where this cache is about twice as fast as the `git log` command used internally.
+
+This cache can be activated with the `-C` command line flag. By default the commitcache is written into the output directory (./stats by default). If you want to use another directory you can specify it by using `--commitcache <directory name>`.
+
+## Examples
+
+* [gitstats-ruby](http://chrisistuff.github.com/gitstats-ruby/gitstats-ruby/)
+* [Linux](http://chrisistuff.github.com/gitstats-ruby/linux/)
+
+## Dependencies
+
+* [HAML](http://haml-lang.com)
+* [SASS](http://sass-lang.com)
+* [Compass](http://compass-style.org)
+* [Gnuplot (GEM)](http://rubygems.org/gems/gnuplot)
+* [Gnuplot binary](http://www.gnuplot.info/)
+
+## License
+
+See LICENSE
+

data/bin/gitstats

@@ -0,0 +1,176 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ftools'
+require 'rubygems'
+
+require 'haml'
+require 'sass'
+require 'compass'
+require 'gnuplot'
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
+require 'gitstats'
+
+$options = {
+  :out => 'stats',
+  :template => nil,
+  :verbose => false,
+  :debug => false,
+  :quiet => false,
+  :cache => false,
+  :statcache => nil,
+  :commitcache => nil,
+  :commitcache_dir => nil,
+  :future => true,
+  :maxage => 0,
+  :withmail => false,
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: gitstats.rb [options] <[name1:]gitdir1[:ref1]> [<[name2:]gitdir2[:ref2]> ...]'
+
+  opts.on('-o', '--out=arg', 'output directory') do |arg|
+    $options[:out] = arg
+  end
+
+  opts.on('-t', '--template=arg', 'template directory') do |arg|
+    $options[:template] = arg
+  end
+
+  opts.on('-c', '--[no-]cache', 'use the statcache file') do |arg|
+    $options[:cache] = arg
+  end
+
+  opts.on('-C', '--[no-]commitcache', 'use the commit cache') do |arg|
+    $options[:commitcache] = arg
+  end
+
+  opts.on('-s', '--statcache=arg', 'statcache file to use') do |arg|
+    $options[:statcache] = arg
+  end
+
+  opts.on('--commitcache=arg', 'commit cache directory to use') do |arg|
+    $options[:commitcache_dir] = arg
+  end
+
+  opts.on('--[no-]future', 'count future commits') do |arg|
+    $options[:future] = arg
+  end
+
+  opts.on('-m', '--max-age=arg', Integer, 'set max age of commit in days') do |arg|
+    $options[:maxage] = arg
+  end
+
+  opts.on('--[no-]mail', 'include mail in author names') do |arg|
+    $options[:withmail] = arg
+  end
+
+  opts.on('-v', '--[no-]verbose', 'verbose mode') do |arg|
+    $options[:verbose] = arg
+  end
+
+  opts.on('-q', '--[no-]quiet', 'quiet mode') do |arg|
+    $options[:quiet] = arg
+  end
+
+  opts.on('-d', '--[no-]debug', 'print debug messages') do |arg|
+    $options[:debug] = arg
+  end
+
+  opts.on_tail('-h', '--help', 'this help') do
+    puts opts
+    exit 0
+  end
+end
+
+parser.parse!
+
+if $options[:quiet] && $options[:verbose]
+  STDERR.puts 'cannot specify --quiet and --verbose at the same time!'
+  exit 1
+end
+
+$options[:statcache] = File.join($options[:out], '.statcache') if $options[:statcache].nil?
+$options[:commitcache_dir] = $options[:out] if $options[:commitcache_dir].nil?
+$options[:template] = File.expand_path(File.join(File.dirname(__FILE__), '..', 'template')) if $options[:template].nil?
+
+FileUtils.mkdir_p($options[:out])
+
+stat = nil
+cache_loaded = false
+if $options[:cache]
+  begin
+    puts 'trying to load cache ...' unless $options[:quiet]
+    stat = Marshal::load(IO::readlines($options[:statcache]).join(''))
+    stat.clear_repos
+    cache_loaded = true
+  rescue
+  end
+end
+
+if stat.nil?
+  if ARGV.empty?
+    puts parser
+    exit 1
+  end
+
+  stat = StatGen.new
+end
+
+if cache_loaded
+  if stat.include_mail != $options[:withmail]
+    puts 'cannot change --[no-]mail option when using statcache'
+    exit 1
+  end
+
+  if stat.future != $options[:future]
+    puts 'cannot change --[no-]future option when using statcache'
+    exit 1
+  end
+
+  if stat.maxage != $options[:maxage] * 24 * 60 * 60
+    puts 'cannot change --max-age option when using statcache'
+    exit 1
+  end
+end
+
+Author::include_mail = $options[:withmail]
+stat.include_mail = $options[:withmail]
+stat.verbose = $options[:verbose]
+stat.debug = $options[:debug]
+stat.quiet = $options[:quiet]
+stat.future = $options[:future]
+stat.maxage = $options[:maxage] * 24 * 60 * 60
+stat.commitcache = $options[:commitcache] ? $options[:commitcache_dir] : nil
+
+ARGV.each do |path|
+  name, path, ref = path.split(':')
+  path ||= name
+  ref ||= 'HEAD'
+  stat << [name, path, ref]
+end
+
+if cache_loaded
+  unless stat.check_repostate
+    puts 'cannot use cache when working on different repositories!'
+    exit 1
+  end
+end
+
+puts 'fetching statistics ...' unless $options[:quiet]
+begin
+  stat.calc
+ensure
+  if $options[:cache]
+    puts 'writing cache ...' unless $options[:quiet]
+    cache = Marshal::dump(stat)
+    File.new($options[:statcache], 'w').write(cache)
+  end
+end
+
+puts 'rendering ...' unless $options[:quiet]
+renderer = Renderer.new($options[:template], $options[:out], $options[:verbose])
+renderer.render(stat)
+

data/gitstats-ruby.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = 'gitstats-ruby'
+  s.version     = '1.0.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Christoph Plank']
+  s.email       = ['chrisistuff@gmail.com']
+  s.homepage    = 'http://rubygems.org/gems/gitstats-ruby'
+  s.summary     = %q{Generates statistics of git repositories}
+  s.description = %q{Generates statistics of git repositories like http://gitstats.sourceforge.net but with a more extendable and flexible backend system}
+  s.has_rdoc    = false
+
+  s.add_dependency 'haml'
+  s.add_dependency 'sass'
+  s.add_dependency 'compass'
+  s.add_dependency 'gnuplot'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/lib/gitstats.rb

@@ -0,0 +1,18 @@
+require 'gitstats/author'
+require 'gitstats/yearmonth'
+require 'gitstats/git'
+
+require 'gitstats/stats'
+require 'gitstats/stats/commit'
+require 'gitstats/stats/commit/author'
+require 'gitstats/stats/commit/time'
+require 'gitstats/stats/file'
+require 'gitstats/stats/file/filetype'
+
+require 'gitstats/statgen'
+
+require 'gitstats/renderer'
+require 'gitstats/renderer/haml'
+require 'gitstats/renderer/sass'
+require 'gitstats/renderer/gnuplot'
+

data/lib/gitstats/author.rb

@@ -0,0 +1,41 @@
+class Author
+  include Comparable
+
+  def self.include_mail=(include_mail)
+    @@include_mail = include_mail
+  end
+
+  def self.include_mail
+    @@include_mail ||= false
+    @@include_mail
+  end
+
+  attr_reader :name
+  attr_reader :email
+
+  def initialize(name, email)
+    @name = name
+    @email = email
+  end
+
+  def <=>(b)
+    to_i <=> b.to_i
+  end
+
+  def to_s
+    if self.class.include_mail
+      "#{name} <#{email}>"
+    else
+      name
+    end
+  end
+
+  def eql?(b)
+    to_s.hash == b.to_s.hash
+  end
+
+  def hash
+    to_s.hash
+  end
+end
+

data/lib/gitstats/git.rb

@@ -0,0 +1,158 @@
+class Git
+  attr_reader :name
+  attr_reader :base
+  attr_reader :ref
+
+  def initialize(name, base, ref = 'HEAD', debug = false, cachefile = nil)
+    @name = name
+    @base = base
+    @ref = ref
+    @debug = debug
+    @cachefile = cachefile
+  end
+
+  def open_cache
+    @cache = File.new(@cachefile, 'a')
+  end
+
+  def close_cache
+    unless @cache.nil?
+      @cache.close
+      @cache = nil
+    end
+  end
+
+  def write_cache(commit)
+    obj = Marshal.dump(commit)
+    raise "Object too large" if obj.size > 65535
+
+    str = ((obj.size >> 8) & 0xff).chr
+    str += (obj.size & 0xff).chr
+    str += obj
+
+    @cache.write(str)
+    @cache.flush
+  end
+
+  def read_cache
+    f = File.new(@cachefile)
+    while(!f.eof?)
+      tmp = f.read(2)
+      len = (tmp[0] << 8) + tmp[1]
+      obj = f.read(len)
+      raise "Read short object" if obj.size != len
+      yield Marshal.load(obj)
+    end
+    f.close
+  end
+
+  def get_commits(last = nil, &block)
+    if last.nil?
+      range = @ref
+      unless @cachefile.nil?
+        begin
+          read_cache do |commit|
+            block.call(commit)
+            last = commit
+          end
+          range = "#{last[:hash]}..#{@ref}"
+        rescue
+        end
+      end
+    else
+      range = "#{last}..#{@ref}"
+    end
+
+    open_cache unless @cachefile.nil?
+
+    commit = nil
+    sh("git log --reverse --summary --numstat --pretty=format:\"HEADER: %at %ai %H %T %aN <%aE>\" #{range}") do |line|
+      if line =~ /^HEADER:/
+        unless commit.nil?
+          write_cache(commit) unless @cachefile.nil?
+          block.call(commit)
+        end
+
+        parts = line.split(' ', 8)
+        parts.shift
+
+        commit = Hash.new
+        commit[:time] = Time.at(parts[0].to_i)
+        commit[:timezone] = parts[3]
+        commit[:hash] = parts[4]
+        commit[:tree] = parts[5]
+        name = nil
+        email = ''
+        match = /^(.+) <(.+)>$/.match(parts[6])
+        if match.nil?
+          name = parts[6]
+        else
+          name, email = match.captures
+        end
+        commit[:author] = Author.new(name, email)
+        commit[:files_added] = 0
+        commit[:files_deleted] = 0
+        commit[:lines_added] = 0
+        commit[:lines_deleted] = 0
+      elsif line == ''
+        write_cache(commit) unless @cachefile.nil?
+        block.call(commit)
+        commit = nil
+      elsif line =~ /^ /
+        if line =~ /^ create/
+          commit[:files_added] += 1
+        elsif line =~ /^ delete/
+          commit[:files_deleted] += 1
+        end
+      else
+        match = /^(\d+)\s+(\d+)/.match(line)
+        unless match.nil?
+          added, deleted = match.captures
+          commit[:lines_added] += added.to_i
+          commit[:lines_deleted] += deleted.to_i
+        end
+      end
+    end
+
+    unless commit.nil?
+      write_cache(commit) unless @cachefile.nil?
+      block.call(commit)
+    end
+
+  ensure
+    close_cache unless @cachefile.nil?
+  end
+
+  def get_files(ref = nil, &block)
+    ref ||= @ref
+
+    sh("git ls-tree -r -l #{ref}").split(/\n/).each do |line|
+      parts = line.split(/\s+/, 5)
+      next if parts[1] != 'blob'
+
+      file = Hash.new
+      file[:hash] = parts[2]
+      file[:size] = parts[3].to_i
+      file[:name] = parts[4]
+
+      block.call(file)
+    end
+  end
+
+  private
+  def sh(cmd, &block)
+    puts cmd if @debug
+    Dir.chdir(@base) do
+      if block.nil?
+        `#{cmd}`
+      else
+        IO.popen(cmd) do |io|
+          io.each_line do |line|
+            block.call(line.chomp)
+          end
+        end
+      end
+    end
+  end
+end
+