churn 0.0.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+tmp

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dan Mayer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,32 @@
+= churn
+
+A Project to give the churn file, class, and method for a project for a given checkin
+This will allow us over time to give the number of times a file, class, or method is changing during the life of a project.
+
+TODO:
+* SVN only supports file
+* make storage directory configurable instead of using tmp
+* allow passing in directories to churn, directories to ignore
+* add a bin/ with args passed as well as just the rake task
+* todo add a filter that allows for other files besides. *.rb
+
+Usage:
+* 'gem install churn'
+* on any project you want to use churn, add "require 'churn'" to your rake file
+* run 'rake churn' to view the current output, file churn history is immediate, class and method churn builds up a history as it is run on each revision
+* temporary files with class / method churn history are stored in /tmp, to clear churn history delete them
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Dan Mayer. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+require 'lib/tasks/churn_tasks'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "churn"
+    gem.summary = %Q{Providing additional churn metrics over the original metric_fu churn}
+    gem.description = %Q{High method and class churn has been shown to have increased bug and error rates. This gem helps you know what is changing a lot so you can do additional testing, code review, or refactoring to try to tame the volatile code. }
+    gem.email = "Danmayer@gmail.com"
+    gem.homepage = "http://github.com/danmayer/churn"
+    gem.authors = ["Dan Mayer"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "churn #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/churn.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'tasks', 'churn_tasks')

data/lib/churn/churn_calculator.rb

@@ -0,0 +1,209 @@
+require 'chronic'
+require 'sexp_processor'
+require 'ruby_parser'
+require 'json'
+require 'fileutils'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'source_control'
+require 'git_analyzer'
+require 'svn_analyzer'
+require 'location_mapping'
+require 'churn_history'
+
+module Churn
+
+  class ChurnCalculator
+
+    def initialize(options={})
+      start_date = options.fetch(:start_date) { '3 months ago' }
+      @minimum_churn_count = options.fetch(:minimum_churn_count) { 5 }
+      @source_control = set_source_control(start_date)
+      @revision_changes = {}
+      @method_changes   = {}
+      @class_changes    = {}
+    end
+
+    def report(print = true)
+      self.emit 
+      self.analyze
+      print ? self.to_s : self.to_h
+    end
+    
+    def emit
+      @changes   = parse_log_for_changes.reject {|file, change_count| change_count < @minimum_churn_count}
+      @revisions = parse_log_for_revision_changes  
+    end 
+
+    def analyze
+      @changes = @changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @changes = @changes.map {|file_path, times_changed| {:file_path => file_path, :times_changed => times_changed }}
+
+      calculate_revision_changes
+
+      @method_changes = @method_changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @method_changes = @method_changes.map {|method, times_changed| {'method' => method, 'times_changed' => times_changed }}
+      @class_changes  = @class_changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @class_changes  = @class_changes.map {|klass, times_changed| {'klass' => klass, 'times_changed' => times_changed }}
+    end
+
+    def to_h
+      hash                        = {:churn => {:changes => @changes}}
+      hash[:churn][:class_churn]  = @class_changes
+      hash[:churn][:method_churn] = @method_changes
+      #detail the most recent changes made this revision
+      if @revision_changes[@revisions.first]
+        changes = @revision_changes[@revisions.first]
+        hash[:churn][:changed_files]   = changes[:files]
+        hash[:churn][:changed_classes] = changes[:classes]
+        hash[:churn][:changed_methods] = changes[:methods]
+      end
+      #TODO crappy place to do this but save hash to revision file but while entirely under metric_fu only choice
+      ChurnHistory.store_revision_history(@revisions.first, hash)
+      hash
+    end
+
+    def to_s
+      hash   = to_h
+      result = seperator 
+      result +="* Revision Changes \n"
+      result += seperator
+      result += "files: \n"
+      result += display_array(hash[:churn][:changed_files])
+      result += "\nclasses: \n"
+      result += display_array(hash[:churn][:changed_classes])
+      result += "\nmethods: \n"
+      result += display_array(hash[:churn][:changed_methods])
+      result += seperator 
+      result +="* Project Churn \n"
+      result += seperator
+      result += "files: \n"
+      result += display_array(hash[:churn][:changes])
+      result += "\nclasses: \n"
+      result += display_array(hash[:churn][:class_churn])
+      result += "\nmethods: \n"
+      result += display_array(hash[:churn][:method_churn])
+    end
+
+    private
+
+    def display_array(array)
+      result = ""
+      array.each { |element| result += " * #{element.inspect}\n" } if array
+      result
+    end
+
+    def seperator
+      "*"*70+"\n"
+    end
+
+    def self.git?
+      system("git branch")
+    end
+
+    def set_source_control(start_date)
+      if self.class.git?
+        GitAnalyzer.new(start_date)
+      elsif File.exist?(".svn")
+        SvnAnalyzer.new(start_date)
+      else
+        raise "Churning requires a subversion or git repo"
+      end
+    end
+
+    def calculate_revision_changes
+      @revisions.each do |revision|
+        if revision == @revisions.first
+          #can't iterate through all the changes and tally them up
+          #it only has the current files not the files at the time of the revision
+          #parsing requires the files
+          changed_files, changed_classes, changed_methods = calculate_revision_data(revision)
+        else
+          changed_files, changed_classes, changed_methods = ChurnHistory.load_revision_data(revision)
+        end
+        calculate_changes!(changed_methods, @method_changes) if changed_methods
+        calculate_changes!(changed_classes, @class_changes) if changed_classes
+        
+        @revision_changes[revision] = { :files => changed_files, :classes => changed_classes, :methods => changed_methods }
+      end
+    end
+
+    def calculate_revision_data(revision)
+      changed_files   = parse_logs_for_updated_files(revision, @revisions)
+      
+      changed_classes = []
+      changed_methods = []
+      changed_files.each do |file_changes|
+        if file_changes.first.match(/.*\.rb/)
+          classes, methods = get_changes(file_changes)
+          changed_classes += classes
+          changed_methods += methods
+        end
+      end
+      changed_files   = changed_files.map { |file, lines| file }
+      [changed_files, changed_classes, changed_methods]
+    end
+
+    def calculate_changes!(changed_objs, total_changes)
+      if changed_objs
+        changed_objs.each do |change|
+          total_changes.include?(change) ? total_changes[change] = total_changes[change]+1 : total_changes[change] = 1
+        end
+      end
+      total_changes
+    end
+
+    def get_changes(change)
+      file = change.first
+      breakdown = LocationMapping.new
+      breakdown.get_info(file)
+      changes = change.last
+      classes = changes_for_type(changes, breakdown.klasses_collection)
+      methods = changes_for_type(changes, breakdown.methods_collection)
+      classes = classes.map{ |klass| {'file' => file, 'klass' => klass} }
+      methods = methods.map{ |method| {'file' => file, 'klass' => get_klass_for(method), 'method' => method} }
+      [classes, methods]
+    rescue => error
+      [[],[]]
+    end
+
+    def get_klass_for(method)
+      method.gsub(/(#|\.).*/,'')
+    end
+
+    def changes_for_type(changes, item_collection)
+      changed_items  = []
+      item_collection.each_pair do |item, item_lines|
+        item_lines = item_lines[0].to_a
+        changes.each do |change_range|
+          item_lines.each do |line|
+            changed_items << item if change_range.include?(line) && !changed_items.include?(item)
+          end
+        end
+      end
+      changed_items
+    end
+    
+    def parse_log_for_changes
+      changes = {}
+      
+      logs = @source_control.get_logs
+      logs.each do |line|
+        changes[line] ? changes[line] += 1 : changes[line] = 1
+      end
+      changes
+    end
+
+    def parse_log_for_revision_changes
+      @source_control.get_revisions
+    end
+    
+    def parse_logs_for_updated_files(revision, revisions)
+      #SVN doesn't support this
+      return {} unless @source_control.respond_to?(:get_updated_files_change_info)
+      @source_control.get_updated_files_change_info(revision, revisions)
+    end
+
+  end
+
+end

data/lib/churn/churn_history.rb

@@ -0,0 +1,25 @@
+module Churn
+
+  class ChurnHistory
+    
+    def self.store_revision_history(revision, hash_data)
+      FileUtils.mkdir 'tmp' unless File.directory?('tmp')
+      File.open("tmp/#{revision}.json", 'w') {|f| f.write(hash_data.to_json) }
+    end
+
+    def self.load_revision_data(revision)
+      #load revision data from scratch folder if it exists
+      filename = "tmp/#{revision}.json"
+      if File.exists?(filename)
+        json_data = File.read(filename)
+        data      = JSON.parse(json_data)
+        changed_files   = data['churn']['changed_files']
+        changed_classes = data['churn']['changed_classes']
+        changed_methods = data['churn']['changed_methods']
+      end
+      [changed_files, changed_classes, changed_methods]
+    end
+
+  end
+
+end

data/lib/churn/git_analyzer.rb

@@ -0,0 +1,73 @@
+module Churn
+
+  class GitAnalyzer < SourceControl
+    def get_logs
+      `git log #{date_range} --name-only --pretty=format:`.split(/\n/).reject{|line| line == ""}
+    end
+    
+    def get_revisions
+      `git log #{date_range} --pretty=format:"%H"`.split(/\n/).reject{|line| line == ""}
+    end
+    
+    def get_updated_files_from_log(revision, revisions)
+      current_index = revisions.index(revision)
+      previous_index = current_index+1
+      previous_revision = revisions[previous_index] unless revisions.length < previous_index
+      if revision && previous_revision
+        `git diff #{revision} #{previous_revision} --unified=0`.split(/\n/).select{|line| line.match(/^@@/) || line.match(/^---/) || line.match(/^\+\+\+/) }
+      else
+        []
+      end
+    end
+
+    def get_updated_files_change_info(revision, revisions)
+      updated     = {}
+      logs        = get_updated_files_from_log(revision, revisions)
+      recent_file = nil
+      logs.each do |line|
+        if line.match(/^---/) || line.match(/^\+\+\+/)
+          recent_file = get_recent_file(line)
+          updated[recent_file] = [] unless updated.include?(recent_file)
+        elsif line.match(/^@@/)
+          removed_range = get_changed_range(line, '-')
+          added_range   = get_changed_range(line, '\+')
+          updated[recent_file] << removed_range
+          updated[recent_file] << added_range
+        else
+          puts line.match(/^---/)
+          raise "git diff lines that don't match the two patterns aren't expected: '#{line}'"
+        end
+      end
+      updated
+    end
+    
+    private
+
+    def get_changed_range(line, matcher)
+      change_start = line.match(/#{matcher}[0-9]+/)
+      change_end   = line.match(/#{matcher}[0-9]+,[0-9]+/)
+      change_start = change_start.to_s.gsub(/#{matcher}/,'')
+      change_end   = change_end.to_s.gsub(/.*,/,'')
+
+      range  = if change_end && change_end!=''
+                 (change_start.to_i..(change_start.to_i+change_end.to_i))
+               else
+                 (change_start.to_i..change_start.to_i)
+               end
+      range
+    end
+
+    def get_recent_file(line)
+      line = line.gsub(/^--- /,'').gsub(/^\+\+\+ /,'').gsub(/^a\//,'').gsub(/^b\//,'')
+    end
+
+    def date_range
+      if @start_date
+        date = Chronic.parse(@start_date)
+        "--after=#{date.strftime('%Y-%m-%d')}"
+      end
+    end
+    
+  end
+
+end

data/lib/churn/location_mapping.rb

@@ -0,0 +1,49 @@
+module Churn
+  
+  class LocationMapping < SexpProcessor
+    
+    attr_reader :klasses_collection, :methods_collection
+    
+    def initialize()
+      super
+      @klasses_collection  = {}
+      @methods_collection  = {}
+      @parser              = RubyParser.new
+      self.auto_shift_type = true
+    end
+    
+    def get_info(file)
+      ast = @parser.process(File.read(file), file)
+      process ast
+    end
+    
+    def process_class(exp)
+      name           = exp.shift
+      start_line     = exp.line
+      last_line      = exp.last.line
+      name           = name if name.is_a?(Symbol)
+      name           = name.values.value if name.is_a?(Sexp) #deals with cases like class Test::Unit::TestCase
+      @current_class = name
+      @klasses_collection[name.to_s] = [] unless @klasses_collection.include?(name)
+      @klasses_collection[name.to_s] << (start_line..last_line)
+      analyze_list exp
+      s()
+    end
+    
+    def analyze_list exp
+      process exp.shift until exp.empty?
+    end
+    
+    def process_defn(exp)
+      name        = exp.shift
+      start_line  = exp.line
+      last_line   = exp.last.line
+      full_name   = "#{@current_class}##{name}"
+      @methods_collection[full_name] = [] unless @methods_collection.include?(full_name)
+      @methods_collection[full_name] << (start_line..last_line)
+      return s(:defn, name, process(exp.shift), process(exp.shift))
+    end
+
+  end
+
+end

data/lib/churn/source_control.rb

@@ -0,0 +1,9 @@
+module Churn
+
+  class SourceControl
+    def initialize(start_date=nil)
+      @start_date = start_date
+    end
+  end
+
+end

data/lib/churn/svn_analyzer.rb

@@ -0,0 +1,22 @@
+module Churn
+
+  class Svn < SourceControl
+    def get_logs
+      `svn log #{date_range} --verbose`.split(/\n/).map { |line| clean_up_svn_line(line) }.compact
+    end
+
+    private
+    def date_range
+      if @start_date
+        date = Chronic.parse(@start_date)
+        "--revision {#{date.strftime('%Y-%m-%d')}}:{#{Time.now.strftime('%Y-%m-%d')}}"
+      end
+    end
+
+    def clean_up_svn_line(line)
+      m = line.match(/\W*[A,M]\W+(\/.*)\b/)
+      m ? m[1] : nil
+    end
+  end
+
+end

data/lib/tasks/churn_tasks.rb

@@ -0,0 +1,20 @@
+def report_churn()
+  require File.join(File.dirname(__FILE__), '..', 'churn', 'churn_calculator')
+  Churn::ChurnCalculator.new({:minimum_churn_count => 3}).report
+end
+
+desc "Report the current churn for the project"
+task :churn do
+  report = report_churn()
+  puts report
+ #  puts "entire report"
+#   puts report.inspect.to_s
+#   puts "_"*50
+#   puts "changed classes: #{report[:churn][:changed_classes].inspect}"
+#   puts "_"*50
+#   puts "cahnged methods: #{report[:churn][:changed_methods].inspect}"
+#   puts "_"*50
+#   put
+#  s "method churn: #{report[:churn][:method_churn].inspect}"
+end
+

data/test/data/churn_calculator.rb

@@ -0,0 +1,217 @@
+require 'chronic'
+require 'sexp_processor'
+require 'ruby_parser'
+require 'json'
+require 'fileutils'
+require 'lib/churn/source_control'
+require 'lib/churn/git_analyzer'
+require 'lib/churn/svn_analyzer'
+require 'lib/churn/location_mapping'
+require 'lib/churn/churn_history'
+
+module Churn
+
+  class ChurnCalculator
+
+    def initialize(options={})
+      start_date = options.fetch(:start_date) { '3 months ago' }
+      @minimum_churn_count = options.fetch(:minimum_churn_count) { 5 }
+      puts start_date
+      if self.class.git?
+        @source_control = GitAnalyzer.new(start_date)
+      elsif File.exist?(".svn")
+        @source_control = SvnAnalyzer.new(start_date)
+      else
+        raise "Churning requires a subversion or git repo"
+      end
+      @revision_changes = {}
+      @method_changes   = {}
+      @class_changes    = {}
+    end
+
+    def report
+      self.emit 
+      self.analyze
+      self.to_h
+    end
+    
+    def emit
+      @changes   = parse_log_for_changes.reject {|file, change_count| change_count < @minimum_churn_count}
+      @revisions = parse_log_for_revision_changes  
+    end 
+
+    def analyze
+      @changes = @changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @changes = @changes.map {|file_path, times_changed| {:file_path => file_path, :times_changed => times_changed }}
+
+      calculate_revision_changes
+
+      @method_changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @method_changes          = @method_changes.map {|method, times_changed| {'method' => method, 'times_changed' => times_changed }}
+      @class_changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @class_changes          = @class_changes.map {|klass, times_changed| {'klass' => klass, 'times_changed' => times_changed }}
+    end
+
+    def to_h
+      hash                        = {:churn => {:changes => @changes}}
+      hash[:churn][:method_churn] = @method_changes
+      hash[:churn][:class_churn]  = @class_changes
+      #detail the most recent changes made this revision
+      if @revision_changes[@revisions.first]
+        changes = @revision_changes[@revisions.first]
+        hash[:churn][:changed_files]   = changes[:files]
+        hash[:churn][:changed_classes] = changes[:classes]
+        hash[:churn][:changed_methods] = changes[:methods]
+      end
+      #TODO crappy place to do this but save hash to revision file but while entirely under metric_fu only choice
+      revision = @revisions.first
+      ChurnHistory.store_revision_history(revision, hash)
+      hash
+    end
+
+    private
+
+    def self.git?
+      system("git branch")
+    end
+
+    def calculate_revision_changes
+      @revisions.each do |revision|
+        if revision == @revisions.first
+          #can't iterate through all the changes and tally them up
+          #it only has the current files not the files at the time of the revision
+          #parsing requires the files
+          changed_files, changed_classes, changed_methods = calculate_revision_data(revision)
+        else
+          changed_files, changed_classes, changed_methods = ChurnHistory.load_revision_data(revision)
+        end
+        calculate_changes!(changed_methods, @method_changes) if changed_methods
+        calculate_changes!(changed_classes, @class_changes) if changed_classes
+        
+        @revision_changes[revision] = { :files => changed_files, :classes => changed_classes, :methods => changed_methods }
+      end
+    end
+
+    def calculate_revision_data(revision)
+      changed_files   = parse_logs_for_updated_files(revision, @revisions)
+      
+      changed_classes = []
+      changed_methods = []
+      changed_files.each do |file|
+        classes, methods = get_changes(file)
+        changed_classes += classes
+        changed_methods += methods
+      end
+      changed_files   = changed_files.map { |file, lines| file }
+      [changed_files, changed_classes, changed_methods]
+    end
+
+    def calculate_changes!(changed, total_changes)
+      if changed
+        changed.each do |change|
+          total_changes.include?(change) ? total_changes[change] = total_changes[change]+1 : total_changes[change] = 1
+        end
+      end
+      total_changes
+    end
+
+    def get_changes(change)
+      begin
+        file = change.first
+        breakdown = LocationMapping.new
+        breakdown.get_info(file)
+        changes = change.last
+        classes = changes_for_type(changes, breakdown, :classes)
+        methods = changes_for_type(changes, breakdown, :methods)
+        #todo move to method
+        classes = classes.map{ |klass| {'file' => file, 'klass' => klass} }
+        methods = methods.map{ |method| {'file' => file, 'klass' => get_klass_for(method), 'method' => method} }
+        [classes, methods]
+      rescue => error
+        [[],[]]
+      end
+    end
+
+    def get_klass_for(method)
+      method.gsub(/(#|\.).*/,'')
+    end
+
+    def changes_for_type(changes, breakdown, type)
+      item_collection = if type == :classes
+                          breakdown.klasses_collection
+                        elsif type == :methods
+                          breakdown.methods_collection
+                        end
+      changed_items  = []
+      item_collection.each_pair do |item, item_lines|
+        item_lines = item_lines[0].to_a
+        changes.each do |change_range|
+          item_lines.each do |line|
+            changed_items << item if change_range.include?(line) && !changed_items.include?(item)
+          end
+        end
+      end
+      changed_items
+    end
+    
+    def parse_log_for_changes
+      changes = {}
+      
+      logs = @source_control.get_logs
+      logs.each do |line|
+        changes[line] ? changes[line] += 1 : changes[line] = 1
+      end
+      changes
+    end
+
+    def parse_log_for_revision_changes
+      @source_control.get_revisions
+    end
+    
+    def parse_logs_for_updated_files(revision, revisions)
+      updated     = {}
+      recent_file = nil
+
+      #SVN doesn't support this
+      return updated unless @source_control.respond_to?(:get_updated_files_from_log)
+      logs = @source_control.get_updated_files_from_log(revision, revisions)
+      logs.each do |line|
+        if line.match(/^---/) || line.match(/^\+\+\+/)
+          line = line.gsub(/^--- /,'').gsub(/^\+\+\+ /,'').gsub(/^a\//,'').gsub(/^b\//,'')
+          unless updated.include?(line)
+            updated[line] = [] 
+          end
+          recent_file = line
+        elsif line.match(/^@@/)
+          #TODO cleanup / refactor
+          #puts "#{recent_file}: #{line}"
+          removed        = line.match(/-[0-9]+/)
+          removed_length = line.match(/-[0-9]+,[0-9]+/)
+          removed        = removed.to_s.gsub(/-/,'')
+          removed_length = removed_length.to_s.gsub(/.*,/,'')
+          added          = line.match(/\+[0-9]+/)
+          added_length   = line.match(/\+[0-9]+,[0-9]+/)
+          added          = added.to_s.gsub(/\+/,'')
+          added_length   = added_length.to_s.gsub(/.*,/,'')
+          removed_range  = if removed_length && removed_length!=''
+                             (removed.to_i..(removed.to_i+removed_length.to_i))
+                           else
+                             (removed.to_i..removed.to_i)
+                           end
+          added_range    = if added_length && added_length!=''
+                             (added.to_i..(added.to_i+added_length.to_i))
+                           else
+                             (added.to_i..added.to_i)
+                           end
+          updated[recent_file] << removed_range
+          updated[recent_file] << added_range
+        else
+          raise "git diff lines that don't match the two patterns aren't expected"
+        end
+      end
+      updated
+    end
+
+  end
+
+end

data/test/data/test_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'construct'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'churn/churn_calculator'
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+class Test::Unit::TestCase
+  include Construct::Helpers
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'construct'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'churn/churn_calculator'
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+class Test::Unit::TestCase
+  include Construct::Helpers
+end

data/test/unit/churn_calculator_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class ChurnCalculatorTest < Test::Unit::TestCase
+ 
+  should "use minimum churn count" do
+    within_construct do |container|
+      Churn::ChurnCalculator.stubs(:git?).returns(true)
+      churn = Churn::ChurnCalculator.new({:minimum_churn_count => 3})
+ 
+      churn.stubs(:parse_log_for_changes).returns([['file.rb', 4],['less.rb',1]])
+      churn.stubs(:parse_log_for_revision_changes).returns(['revision'])
+      churn.stubs(:analyze)
+      report = churn.report(false)
+      assert_equal 1, report[:churn][:changes].length
+      assert_equal ["file.rb", 4], report[:churn][:changes].first
+    end
+  end
+
+  should "analize sorts changes" do
+    within_construct do |container|
+      Churn::ChurnCalculator.stubs(:git?).returns(true)
+      churn = Churn::ChurnCalculator.new({:minimum_churn_count => 3})
+ 
+      churn.stubs(:parse_log_for_changes).returns([['file.rb', 4],['most.rb', 9],['less.rb',1]])
+      churn.stubs(:parse_log_for_revision_changes).returns(['revision'])
+      report = churn.report(false)
+      assert_equal 2, report[:churn][:changes].length
+      top = {:file_path => "most.rb", :times_changed => 9}
+      assert_equal top, report[:churn][:changes].first
+      bottom = {:file_path => "file.rb", :times_changed => 4}
+      assert_equal bottom, report[:churn][:changes].last
+    end
+  end
+
+  should "have correct changed_files data" do
+    within_construct do |container|
+      Churn::ChurnCalculator.stubs(:git?).returns(true)
+      churn = Churn::ChurnCalculator.new({:minimum_churn_count => 3})
+      
+      churn.stubs(:parse_log_for_changes).returns([['less.rb',1]])
+      churn.stubs(:parse_log_for_revision_changes).returns(['first'])
+      churn.stubs(:parse_logs_for_updated_files).returns(['fake_file.rb'])
+      report = churn.report(false)
+      assert_equal ["fake_file.rb"], report[:churn][:changed_files]
+    end
+  end
+
+  should "have correct changed classes and methods data" do
+    within_construct do |container|
+      Churn::ChurnCalculator.stubs(:git?).returns(true)
+      churn = Churn::ChurnCalculator.new({:minimum_churn_count => 3})
+      
+      churn.stubs(:parse_log_for_changes).returns([['less.rb',1]])
+      churn.stubs(:parse_log_for_revision_changes).returns(['first'])
+      churn.stubs(:parse_logs_for_updated_files).returns(['fake_file.rb'])
+      klasses = [{"klass"=>"LocationMapping", "file"=>"lib/churn/location_mapping.rb"}]
+      methods = [{"klass"=>"LocationMapping", "method"=>"LocationMapping#process_class", "file"=>"lib/churn/location_mapping.rb"}]
+      churn.stubs(:get_changes).returns([klasses,methods])
+      report = churn.report(false)
+      assert_equal [{"klass"=>"LocationMapping", "method"=>"LocationMapping#process_class", "file"=>"lib/churn/location_mapping.rb"}], report[:churn][:changed_methods]
+      assert_equal [{"klass"=>"LocationMapping", "file"=>"lib/churn/location_mapping.rb"}], report[:churn][:changed_classes]
+    end
+  end
+
+  should "have correct churn method and classes at 1 change" do
+    within_construct do |container|
+      Churn::ChurnCalculator.stubs(:git?).returns(true)
+      churn = Churn::ChurnCalculator.new({:minimum_churn_count => 3})
+      
+      churn.stubs(:parse_log_for_changes).returns([['less.rb',1]])
+      churn.stubs(:parse_log_for_revision_changes).returns(['first'])
+      churn.stubs(:parse_logs_for_updated_files).returns(['fake_file.rb'])
+      klasses = [{"klass"=>"LocationMapping", "file"=>"lib/churn/location_mapping.rb"}]
+      methods = [{"klass"=>"LocationMapping", "method"=>"LocationMapping#process_class", "file"=>"lib/churn/location_mapping.rb"}]
+      churn.stubs(:get_changes).returns([klasses,methods])
+      report = churn.report(false)
+      assert_equal [{"method"=>{"klass"=>"LocationMapping", "method"=>"LocationMapping#process_class", "file"=>"lib/churn/location_mapping.rb"}, "times_changed"=>1}], report[:churn][:method_churn]
+      assert_equal [{"klass"=>{"klass"=>"LocationMapping", "file"=>"lib/churn/location_mapping.rb"}, "times_changed"=>1}], report[:churn][:class_churn]
+    end
+  end
+  
+end

data/test/unit/churn_history_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class ChurnHistoryTest < Test::Unit::TestCase
+ 
+  should "store results" do
+    within_construct do |container|
+      Churn::ChurnHistory.store_revision_history('aaa','data')
+      assert File.exists?('tmp/aaa.json')
+      data = File.read('tmp/aaa.json')
+      assert data.match(/data/)
+    end
+  end
+ 
+  should "restores results" do
+    within_construct do |container|
+      container.file('tmp/aaa.json', '{"churn":{"changes":[{"file_path":".gitignore","times_changed":2},{"file_path":"lib\/churn.rb","times_changed":2},{"file_path":"Rakefile","times_changed":2},{"file_path":"README.rdoc","times_changed":2},{"file_path":"lib\/churn\/source_control.rb","times_changed":1},{"file_path":"lib\/churn\/svn_analyzer.rb","times_changed":1},{"file_path":"lib\/tasks\/churn_tasks.rb","times_changed":1},{"file_path":"LICENSE","times_changed":1},{"file_path":"test\/churn_test.rb","times_changed":1},{"file_path":"lib\/churn\/locationmapping.rb","times_changed":1},{"file_path":"lib\/churn\/git_analyzer.rb","times_changed":1},{"file_path":".document","times_changed":1},{"file_path":"test\/test_helper.rb","times_changed":1},{"file_path":"lib\/churn\/churn_calculator.rb","times_changed":1}],"method_churn":[],"changed_files":[".gitignore","lib\/churn\/source_control.rb","lib\/tasks\/churn_tasks.rb","lib\/churn\/svn_analyzer.rb","Rakefile","README.rdoc","lib\/churn\/locationmapping.rb","lib\/churn\/git_analyzer.rb","\/dev\/null","lib\/churn\/churn_calculator.rb","lib\/churn.rb"],"class_churn":[],"changed_classes":[{"klass":"ChurnTest","file":"test\/churn_test.rb"},{"klass":"ChurnCalculator","file":"lib\/churn\/churn_calculator.rb"}],"changed_methods":[{"klass":"","method":"#report_churn","file":"lib\/tasks\/churn_tasks.rb"}]}}')
+      changed_files, changed_classes, changed_methods = Churn::ChurnHistory.load_revision_data('aaa')
+      assert changed_files.include?("lib/churn/source_control.rb")
+      assert_equal 2, changed_classes.length
+      assert_equal 1, changed_methods.length
+    end
+  end
+  
+end

data/test/unit/git_analyzer_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class GitAnalyzerTest < Test::Unit::TestCase
+  
+  should "parses logs correctly" do
+    git_analyzer = Churn::GitAnalyzer.new
+    revision     = 'first'
+    revisions    = ['first']
+    lines        = ["--- a/lib/churn/churn_calculator.rb", "+++ b/lib/churn/churn_calculator.rb", "@@ -18,0 +19 @@ module Churn"]
+    git_analyzer.stubs(:get_updated_files_from_log).returns(lines)
+    updated = git_analyzer.get_updated_files_change_info(revision, revisions)
+    expected_hash = {"lib/churn/churn_calculator.rb"=>[18..18, 19..19]}
+    assert_equal = updated
+  end
+  
+end
+

data/test/unit/location_mapping_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class LocationMappingTest < Test::Unit::TestCase
+  
+  #todo unfortunately it looks like ruby parser can't handle construct tmp dirs
+  #<Pathname:/private/var/folders/gl/glhHkYYSGgG5nb6+4OG0yU+++TI/-Tmp-/construct_container-56784-851001101/fake_class.rb>
+  #(rdb:1) p locationmapping.get_info(file.to_s)
+  #RegexpError Exception: invalid regular expression; there's no previous pattern, to which '+' would define cardinality at 2: /^+++/
+
+  should "location_mapping gets correct classes info" do
+    file = 'test/data/churn_calculator.rb'
+    locationmapping = Churn::LocationMapping.new
+    locationmapping.get_info(file.to_s)
+    klass_hash = {"ChurnCalculator"=>[14..215]}
+    assert_equal klass_hash, locationmapping.klasses_collection
+  end
+
+  should "location_mapping gets correct methods info" do
+    file = 'test/data/churn_calculator.rb'
+    locationmapping = Churn::LocationMapping.new
+    locationmapping.get_info(file.to_s)
+    methods_hash = {"ChurnCalculator#report"=>[32..36], "ChurnCalculator#emit"=>[38..41], "ChurnCalculator#changes_for_type"=>[139..155], "ChurnCalculator#get_klass_for"=>[135..137], "ChurnCalculator#calculate_changes!"=>[109..116], "ChurnCalculator#analyze"=>[43..53], "ChurnCalculator#calculate_revision_data"=>[95..107], "ChurnCalculator#calculate_revision_changes"=>[78..93], "ChurnCalculator#parse_logs_for_updated_files"=>[171..213], "ChurnCalculator#to_h"=>[55..70], "ChurnCalculator#parse_log_for_revision_changes"=>[167..169], "ChurnCalculator#get_changes"=>[118..133], "ChurnCalculator#parse_log_for_changes"=>[157..165], "ChurnCalculator#initialize"=>[16..30]}
+    assert_equal methods_hash, locationmapping.methods_collection
+  end
+  
+  should "location_mapping gets correct classes info for test helper files" do
+    file = 'test/data/test_helper.rb'
+    locationmapping = Churn::LocationMapping.new
+    locationmapping.get_info(file.to_s)
+    klass_hash = {"TestCase"=>[12..14]}
+    assert_equal klass_hash, locationmapping.klasses_collection
+  end
+  
+end
+

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: churn
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Dan Mayer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-08 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "High method and class churn has been shown to have increased bug and error rates. This gem helps you know what is changing a lot so you can do additional testing, code review, or refactoring to try to tame the volatile code. "
+email: Danmayer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/churn.rb
+- lib/churn/churn_calculator.rb
+- lib/churn/churn_history.rb
+- lib/churn/git_analyzer.rb
+- lib/churn/location_mapping.rb
+- lib/churn/source_control.rb
+- lib/churn/svn_analyzer.rb
+- lib/tasks/churn_tasks.rb
+- test/data/churn_calculator.rb
+- test/data/test_helper.rb
+- test/test_helper.rb
+- test/unit/churn_calculator_test.rb
+- test/unit/churn_history_test.rb
+- test/unit/git_analyzer_test.rb
+- test/unit/location_mapping_test.rb
+has_rdoc: true
+homepage: http://github.com/danmayer/churn
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Providing additional churn metrics over the original metric_fu churn
+test_files: 
+- test/data/churn_calculator.rb
+- test/data/test_helper.rb
+- test/test_helper.rb
+- test/unit/churn_calculator_test.rb
+- test/unit/churn_history_test.rb
+- test/unit/git_analyzer_test.rb
+- test/unit/location_mapping_test.rb