todidnt 0.2.0 → 0.3.1

data/README.md

@@ -20,14 +20,12 @@ Then, run `todidnt` in any Git repository directory:
 TODO[1]
 ----
 
-- Optimizing blame step
 - Filtering by author, label
-- Fancy formatted reports
 - TODO stats
 
 Credit
 ----
 
-Paul Battley (@threedaymonk) for initial idea/implementation and witty name.
+Paul Battley (@threedaymonk) for initial idea and witty name.
 
 1: Oh, the irony.

data/lib/todidnt/cache.rb

@@ -0,0 +1,48 @@
+require 'tilt'
+require 'erb'
+require 'fileutils'
+require 'json'
+
+module Todidnt
+  class Cache
+    CACHE_PATH = '.todidnt/cache'
+
+    attr_reader :time, :data
+
+    def initialize(data)
+      @time = Time.now.to_i
+      @data = data
+    end
+
+    def self.save(key, data)
+      # Create the destinateion folder unless it already exists.
+      FileUtils.mkdir_p(CACHE_PATH)
+
+      File.open("#{CACHE_PATH}/#{key}", 'w') do |file|
+        file.write(Marshal.dump(Cache.new(data)))
+      end
+    end
+
+    def self.load(key)
+      return nil unless exists?(key)
+
+      begin
+        raw_cache = File.open("#{CACHE_PATH}/#{key}").read
+        Marshal.load(raw_cache)
+      rescue Exception
+        puts "Cache file was malformed; skipping..."
+        nil
+      end
+    end
+
+    def self.exists?(key)
+      File.exists?("#{CACHE_PATH}/#{key}")
+    end
+
+    def self.clear!
+      Dir.glob("#{CACHE_PATH}/*").each do |file|
+        File.delete(file)
+      end
+    end
+  end
+end

data/lib/todidnt/git_command.rb

@@ -1,16 +1,18 @@
+require 'subprocess'
+
 module Todidnt
   class GitCommand
     def initialize(command, options)
       @command = command
       @options = options
-    end
 
-    def output_lines
-      run!.strip.split(/\n/)
+      @process = Subprocess::Process.new(command_with_options, :stdout => Subprocess::PIPE)
     end
 
-    def run!
-      `git #{command_with_options}`
+    def execute!(&blk)
+      @process.stdout.each_line do |line|
+        yield line.chomp
+      end
     end
 
     def command_with_options
@@ -20,7 +22,7 @@ module Todidnt
         full_command << " #{option.join(' ')}"
       end
 
-      full_command
+      "git #{full_command}"
     end
   end
 end

data/lib/todidnt/git_history.rb

@@ -0,0 +1,248 @@
+module Todidnt
+  class GitHistory
+
+    attr_accessor :blames
+
+    def initialize
+      @history = []
+      @blames = {}
+      @unmatched_deletions = []
+    end
+
+    def timeline!
+      # TODO: It would probably be better/simpler to just Marshal the
+      # GitHistory object itself.
+      if Cache.exists?(:history)
+        puts "Found cached history..."
+
+        cache = Cache.load(:history)
+
+        @history = cache.data[:history]
+        @blames = cache.data[:blames]
+        @unmatched_deletions = cache.data[:unmatched_deletions]
+
+        last_commit = cache.data[:last_commit]
+      end
+
+      new_commit = analyze(last_commit)
+      if new_commit != last_commit
+        # If there's any new history, update the cache.
+        to_cache = {
+          last_commit: new_commit,
+          history: @history,
+          blames: @blames,
+          unmatched_deletions: @unmatched_deletions
+        }
+
+        Cache.save(:history, to_cache)
+      end
+
+      if @unmatched_deletions.length > 0
+        puts "Warning: there are some unmatched TODO deletions."
+      end
+
+      bucket
+    end
+
+    private
+
+    def analyze(last_commit=nil)
+      if last_commit
+        puts "Going through history starting at #{last_commit}..."
+        commit_range = ["#{last_commit}...HEAD"]
+      else
+        puts "Going through history..."
+      end
+
+      command = GitCommand.new(:log, [['-G', 'TODO'], commit_range, ['--format="COMMIT %an %ae %at %h"'], ['-p'], ['-U0'], ['--no-merges'], ['--reverse']].compact)
+
+      patch_additions = []
+      patch_deletions = []
+      metadata = nil
+      filename = nil
+      commit = nil
+      seen_commits = Set.new
+      count = 0
+
+      command.execute! do |line|
+        if (diff = /diff --git a\/(.*) b\/(.*)/.match(line))
+          filename = diff[1]
+        elsif (diff = /^\+(.*TODO.*)/.match(line))
+          patch_additions << diff[1] unless filename =~ TodoLine::IGNORE
+        elsif (diff = /^\-(.*TODO.*)/.match(line))
+          patch_deletions << diff[1] unless filename =~ TodoLine::IGNORE
+        elsif (summary = /^COMMIT (.*) (.*) (.*) (.*)/.match(line))
+          count += 1
+          $stdout.write "\r#{count} commits analyzed..."
+
+          unless commit.nil? || seen_commits.include?(commit)
+            flush(metadata, patch_additions, patch_deletions)
+            seen_commits << commit
+          end
+
+          patch_additions = []
+          patch_deletions = []
+
+          commit = summary[4]
+          metadata = {
+            name: summary[1],
+            time: summary[3].to_i,
+          }
+        end
+      end
+
+      if commit
+        puts
+        flush(metadata, patch_additions, patch_deletions)
+      end
+
+      return commit || last_commit # return the last commit hash we were on
+    end
+
+    def flush(metadata, patch_additions, patch_deletions)
+      name = metadata[:name]
+      time = metadata[:time]
+
+      # Put the additions in the blame hash so when someone removes we
+      # can tell who the original author was. Mrrrh, this isn't going to
+      # work if people add the same string (pretty common e.g. # TODO).
+      # We can figure this out later thoug.
+      patch_additions.each do |line|
+        @blames[line] ||= []
+        @blames[line] << {name: name, time: time}
+      end
+
+      deletions_by_author = {}
+      patch_deletions.each do |line|
+        author = @blames[line] && @blames[line].pop
+
+        if author
+          deletions_by_author[author[:name]] ||= 0
+          deletions_by_author[author[:name]] += 1
+        else
+          @unmatched_deletions << line
+        end
+      end
+
+      @history << {
+        :timestamp => time,
+        :author => name,
+        :additions => patch_additions.count,
+        :deletions => deletions_by_author[name] || 0
+      }
+
+      deletions_by_author.delete(name)
+      deletions_by_author.each do |author, deletion_count|
+        @history << {
+          :timestamp => time,
+          :author => author,
+          :additions => 0,
+          :deletions => deletion_count
+        }
+      end
+    end
+
+    def bucket
+      @history.sort_by! {|slice| slice[:timestamp]}
+      min_commit_date = Time.at(@history.first[:timestamp])
+      max_commit_date = Time.at(@history.last[:timestamp])
+
+      timespan = max_commit_date - min_commit_date
+
+      # Figure out what the interval should be based on the total timespan.
+      if timespan > 86400 * 365 * 10 # 10+ years
+        interval = 86400 * 365 # years
+      elsif timespan > 86400 * 365 * 5 # 5-10 years
+        interval = 86400 * (365 / 2) # 6 months
+      elsif timespan > 86400 * 365 # 2-5 years
+        interval = 86400 * (365 / 4) # 3 months
+      elsif timespan > 86400 * 30 * 6 # 6 months-3 year
+        interval = 86400 * 30 # months
+      elsif timespan > 86400 * 1 # 1 month - 6 months
+        interval = 86400 * 7
+      else # 0 - 2 months
+        interval = 86400 # days
+      end
+
+      original_interval_start = Time.new(min_commit_date.year, min_commit_date.month, min_commit_date.day).to_i
+      interval_start = original_interval_start
+      interval_end = interval_start + interval
+
+      puts "Finalizing timeline..."
+      buckets = []
+      current_bucket_authors = {}
+      bucket_total = 0
+
+      # Add the first bucket of 0
+      buckets << {
+        :timestamp => Time.at(interval_start).strftime('%D'),
+        :authors => {},
+        :total => 0
+      }
+
+      i = 0
+      # Going through the entire history of +/-'s of TODOs.
+      while i < @history.length
+        should_increment = false
+        slice = @history[i]
+        author = slice[:author]
+
+        # Does the current slice exist inside the bucket we're currently
+        # in? If so, add it to the author's total and go to the next slice.
+        if slice[:timestamp] >= interval_start && slice[:timestamp] < interval_end
+          current_bucket_authors[author] ||= 0
+          current_bucket_authors[author] += slice[:additions] - slice[:deletions]
+          bucket_total += slice[:additions] - slice[:deletions]
+          should_increment = true
+        end
+
+        # If we're on the last slice, or the next slice would have been
+        # in a new bucket, finish the current bucket.
+        if i == (@history.length - 1) || @history[i + 1][:timestamp] >= interval_end
+          buckets << {
+            :timestamp => ([Time.at(interval_end), max_commit_date].min).strftime('%D'),
+            :authors => current_bucket_authors,
+            :total => bucket_total
+          }
+          interval_start += interval
+          interval_end += interval
+
+          current_bucket_authors = current_bucket_authors.clone
+        end
+
+        i += 1 if should_increment
+      end
+
+      authors = Set.new
+      contains_other = false
+      buckets.each do |bucket|
+        significant_authors = {}
+        other_count = 0
+        bucket[:authors].each do |author, count|
+          # Only include the author if they account for more than > 3% of
+          # the TODOs in this bucket.
+          if count > bucket[:total] * 0.03
+            significant_authors[author] = count
+            authors << author
+          else
+            other_count += count
+          end
+        end
+
+        if other_count > 0
+          significant_authors['Other'] = other_count
+          contains_other = true
+        end
+
+        bucket[:authors] = significant_authors
+      end
+
+      if contains_other
+        authors << 'Other'
+      end
+
+      [buckets, authors]
+    end
+
+  end
+end

data/lib/todidnt/html_generator.rb

@@ -13,7 +13,7 @@ module Todidnt
 
     def self.generate_common
       # Create the destination folder unless it already exists.
-      Dir.mkdir(DESTINATION_PATH) unless Dir.exists?(DESTINATION_PATH)
+      FileUtils.mkdir_p(DESTINATION_PATH)
 
       # Copy over directories (e.g. js, css) to the destination.
       common_dirs = []

data/lib/todidnt/todo_line.rb

@@ -2,52 +2,38 @@ module Todidnt
   class TodoLine
     IGNORE = %r{assets/js|third_?party|node_modules|jquery|Binary|vendor}
 
-    attr_reader :filename, :line_number, :content, :author, :timestamp
+    attr_reader :filename, :line_number, :raw_content
+    attr_accessor :author, :timestamp
 
     def self.all(expressions)
       options = [['-n']]
       expressions.each { |e| options << ['-e', e] }
 
-      grep = GitCommand.new(:grep, options)
-      grep.output_lines.map do |line|
+      lines = []
+
+      command = GitCommand.new(:grep, options)
+      command.execute! do |line|
         filename, line_number, content = line.split(/:/, 3)
         unless filename =~ IGNORE
-          lines = self.new(filename, line_number.to_i, content.strip[0..100])
+          lines << self.new(filename, line_number.to_i, content)
         end
-      end.compact
+      end
+
+      lines
     end
 
-    def initialize(filename, line_number, content)
+    def initialize(filename, line_number, raw_content)
       @filename = filename
       @line_number = line_number
-      @content = content
-    end
-
-    # TODO: This logic should probably be moved out somewhere else
-    def populate_blame
-      options = [
-        ['--line-porcelain'],
-        ['-L', "#{@line_number},#{@line_number}"],
-        ['-w'],
-        [@filename]
-      ]
-
-      blame = GitCommand.new(:blame, options)
-      blame.output_lines.each do |line|
-        if (author = /author (.*)/.match(line))
-          @author = author[1]
-        elsif (author_time = /author-time (.*)/.match(line))
-          @timestamp = author_time[1].to_i
-        end
-      end
+      @raw_content = raw_content
     end
 
     def pretty_time
       Time.at(@timestamp).strftime('%F')
     end
 
-    def pretty
-      "#{pretty_time} (#{author}, #{filename}:#{line_number}): #{content}"
+    def content
+      raw_content.strip[0..100]
     end
 
     def to_hash

data/lib/todidnt.rb

@@ -1,6 +1,8 @@
+require 'todidnt/cache'
 require 'todidnt/git_repo'
 require 'todidnt/git_command'
 require 'todidnt/todo_line'
+require 'todidnt/git_history'
 require 'todidnt/html_generator'
 
 require 'chronic'
@@ -8,229 +10,47 @@ require 'launchy'
 
 module Todidnt
   class CLI
-    VALID_COMMANDS = %w{all overdue history}
+    VALID_COMMANDS = %w{generate clear}
 
     def self.run(command, options)
+      command ||= 'generate'
+
       if command && VALID_COMMANDS.include?(command)
         self.send(command, options)
       elsif command
         $stderr.puts("Sorry, `#{command}` is not a valid command.")
         exit
-      else
-        $stderr.puts("You must specify a command! Try `todidnt all`.")
-      end
-    end
-
-    def self.all(options)
-      all_lines = self.all_lines(options).sort_by(&:timestamp)
-
-      puts "\nOpening results..."
-
-      file_path = HTMLGenerator.generate(:all, :all_lines => all_lines)
-      Launchy.open("file://#{file_path}")
-    end
-
-    def self.overdue(options)
-      date = Chronic.parse(options[:date] || 'now', :context => :past)
-      if date.nil?
-        $stderr.puts("Invalid date passed: #{options[:date]}")
-        exit
-      else
-        puts "Finding overdue TODOs (created before #{date.strftime('%F')})..."
-      end
-
-      all_lines = self.all_lines(options)
-
-      puts "\nResults:"
-      all_lines.sort_by do |line|
-        line.timestamp
-      end.select do |line|
-        line.timestamp < date.to_i
-      end.each do |line|
-        puts line.pretty
       end
     end
 
-    def self.all_lines(options)
+    def self.generate(options)
       GitRepo.new(options[:path]).run do |path|
-        puts "Running in #{path || 'current directory'}..."
-        lines = TodoLine.all(["TODO"])
-        puts "Found #{lines.count} TODOs. Blaming..."
-
-        lines.each_with_index do |todo, i|
-          todo.populate_blame
-          $stdout.write "\rBlamed: #{i}/#{lines.count}"
-        end
-
-        lines
-      end
-    end
-
-    def self.history(options)
-      GitRepo.new(options[:path]).run do |path|
-        log = GitCommand.new(:log, [['-G', 'TODO'], ['--format="COMMIT %an %ae %at"'], ['-p'], ['-U0']])
-
-        history = []
-
-        blame_hash = {}
-
-        puts "Going through log..."
-        patch_additions = []
-        patch_deletions = []
-        filename = nil
-        total = log.output_lines.count
-
-        log.output_lines.reverse.each do |line|
-          if (summary = /^COMMIT (.*) (.*) (.*)/.match(line))
-            name = summary[1]
-            email = summary[2]
-            time = summary[3]
-
-            unless filename =~ TodoLine::IGNORE
-              # Put the additions in the blame hash so when someone removes we
-              # can tell who the original author was. Mrrrh, this isn't going to
-              # work if people add the same string (pretty common e.g. # TODO).
-              # We can figure this out later though.
-              patch_additions.each do |line|
-                blame_hash[line] ||= []
-                blame_hash[line] << name
-              end
-
-              deletions_by_author = {}
-              patch_deletions.each do |line|
-                author = blame_hash[line] && blame_hash[line].pop
-
-                if author
-                  deletions_by_author[author] ||= 0
-                  deletions_by_author[author] += 1
-                else
-                  puts "BAD BAD can't find original author: #{line}"
-                end
-              end
+        history = GitHistory.new
+        buckets, authors = history.timeline!
 
-              history << {
-                :timestamp => time.to_i,
-                :author => name,
-                :additions => patch_additions.count,
-                :deletions => deletions_by_author[name] || 0
-              }
-
-              deletions_by_author.delete(name)
-              deletions_by_author.each do |author, deletion_count|
-                history << {
-                  :timestamp => time.to_i,
-                  :author => author,
-                  :additions => 0,
-                  :deletions => deletion_count
-                }
-              end
-            end
-
-            patch_additions = []
-            patch_deletions = []
-          elsif (diff = /diff --git a\/(.*) b\/(.*)/.match(line))
-            filename = diff[1]
-          elsif (diff = /^\+(.*TODO.*)/.match(line))
-            patch_additions << diff[1]
-          elsif (diff = /^\-(.*TODO.*)/.match(line))
-            patch_deletions << diff[1]
-          end
-        end
-
-        history.sort_by! {|slice| slice[:timestamp]}
-        min_commit_date = Time.at(history.first[:timestamp])
-        max_commit_date = Time.at(history.last[:timestamp])
-
-        timespan = max_commit_date - min_commit_date
-
-        # Figure out what the interval should be based on the total timespan.
-        if timespan > 86400 * 365 * 10 # 10+ years
-          interval = 86400 * 365 # years
-        elsif timespan > 86400 * 365 * 5 # 5-10 years
-          interval = 86400 * (365 / 2) # 6 months
-        elsif timespan > 86400 * 365 # 2-5 years
-          interval = 86400 * (365 / 4) # 3 months
-        elsif timespan > 86400 * 30 * 6 # 6 months-3 year
-          interval = 86400 * 30 # months
-        elsif timespan > 86400 * 1 # 1 month - 6 months
-          interval = 86400 * 7
-        else # 0 - 2 months
-          interval = 86400 # days
-        end
-
-        original_interval_start = Time.new(min_commit_date.year, min_commit_date.month, min_commit_date.day).to_i
-        interval_start = original_interval_start
-        interval_end = interval_start + interval
-
-        puts "Finalizing timeline..."
-        buckets = []
-        current_bucket_authors = {}
-        bucket_total = 0
-
-        i = 0
-        # Going through the entire history of +/-'s of TODOs.
-        while i < history.length
-          should_increment = false
-          slice = history[i]
-          author = slice[:author]
-
-          # Does the current slice exist inside the bucket we're currently
-          # in? If so, add it to the author's total and go to the next slice.
-          if slice[:timestamp] >= interval_start && slice[:timestamp] < interval_end
-            current_bucket_authors[author] ||= 0
-            current_bucket_authors[author] += slice[:additions] - slice[:deletions]
-            bucket_total += slice[:additions] - slice[:deletions]
-            should_increment = true
-          end
-
-          # If we're on the last slice, or the next slice would have been
-          # in a new bucket, finish the current bucket.
-          if i == (history.length - 1) || history[i + 1][:timestamp] >= interval_end
-            buckets << {
-              :timestamp => Time.at(interval_start).strftime('%D'),
-              :authors => current_bucket_authors,
-              :total => bucket_total
-            }
-            interval_start += interval
-            interval_end += interval
-
-            current_bucket_authors = current_bucket_authors.clone
-          end
-
-          i += 1 if should_increment
-        end
-
-        authors = Set.new
-        contains_other = false
-        buckets.each do |bucket|
-          significant_authors = {}
-          other_count = 0
-          bucket[:authors].each do |author, count|
-            # Only include the author if they account for more than > 3% of
-            # the TODOs in this bucket.
-            if count > bucket[:total] * 0.03
-              significant_authors[author] = count
-              authors << author
-            else
-              other_count += count
-            end
-          end
-
-          if other_count > 0
-            significant_authors['Other'] = other_count
-            contains_other = true
+        lines = TodoLine.all(["TODO"])
+        lines.each do |todo|
+          blames = history.blames[todo.raw_content]
+
+          if blames && (metadata = blames.pop)
+            todo.author = metadata[:name]
+            todo.timestamp = metadata[:time]
+          else
+            todo.author = "(Not yet committed)"
+            todo.timestamp = Time.now.to_i
           end
-
-          bucket[:authors] = significant_authors
-        end
-
-        if contains_other
-          authors << 'Other'
         end
 
+        file_path = HTMLGenerator.generate(:all, :all_lines => lines.sort_by(&:timestamp).reverse)
         file_path = HTMLGenerator.generate(:history, :data => {:history => buckets.map {|h| h[:authors].merge('Date' => h[:timestamp]) }, :authors => authors.to_a})
         Launchy.open("file://#{file_path}")
       end
     end
+
+    def self.clear(options)
+      puts "Deleting cache..."
+      Cache.clear!
+      puts "Done!"
+    end
   end
 end