script.rb

require 'rubygems'
require 'logger'
require 'rugged'
require 'git'
require 'awesome_print'
require 'terminal-table'

# Include diff, difffile classes
load 'diff.rb'
load 'difffile.rb'
load 'helper.rb'
load 'debug_helper.rb'
load 'file_output_helper.rb'

# Global array to store all the diffs
diffs_array = []

orig_path = Dir.pwd

git_repo_url = ARGV[0]
# Handling cases if input is local git directory or remote https directory
if git_repo_url.include? "https"
    project_name = git_repo_url.split('/')
    project_name = project_name.last
    # For repo_URL - https://github.com/jshint/jshint.git, strip .git part too
    project_name = project_name.split('.')
    if project_name.size > 2
      project_name.pop
      project_name = project_name.join('.')
    else
      project_name = project_name.first
    end
    
    puts " ---> Cloning your project repo. -> " + git_repo_url.to_s
    puts "-------------------------------------------------"
    Dir.chdir "/tmp"
    system("rm -rf #{project_name}")
    system("git clone #{git_repo_url}")
    puts "-----------------------------"
    git_repo_path = "/tmp/" + project_name.to_s
else
    git_repo_path = ARGV[0]
    project_name = git_repo_url.split('/')
    project_name = project_name.last
end

# Send console output to console.out
Dir.chdir "#{orig_path}"
stdout_filename = "Logs/" + project_name + "-console.log"
# Keep a dup of STDOUT for later use
old_stdout = $stdout.dup
$stdout.reopen(stdout_filename, "w")

# Initialize both libraries
$rubygit_gem_repo = Git.open(git_repo_path, :log => Logger.new(STDOUT))
$rugged_repo = Rugged::Repository.new(git_repo_path)

head_commit = $rubygit_gem_repo.log(1)
head_commit = head_commit.to_a
head_commit = head_commit[0]
head_commit_sha = head_commit.sha

# Get all the commits for the project
commit_list = $rubygit_gem_repo.log(nil)
commit_list_array = commit_list.to_a
commit_list_array.reverse!

# Calculate the # of total commits
num_commits = commit_list_array.count

msg_revert_commits = [] # Calculate the number of commits which have revert in their message
merge_commits = []      # Calculating # of merges
commit_list_array.each do |commit|
  msg_revert_commits << commit if commit.message.include? 'revert'
  merge_commits << commit      if commit.parents.size > 1
end
num_commits_revert_msg = msg_revert_commits.count
num_merges = merge_commits.count

# ----------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------

$stdout = old_stdout.dup
print " ---> Gathering information about commits. Please wait."
10.times { print "." ; sleep(1.0/10)} ; puts "."
puts "# Commits = " + num_commits.to_s
puts "# Commits with revert in message = " + num_commits_revert_msg.to_s
puts "# of Merge Commits = " + num_merges.to_s
puts "-----------------------------"
print " ---> Looking for reverts - complete and partial & cherry-picks."
5.times { print "." ; sleep(1.0/10)}
puts "\nLooked at # commits so far = "
$stdout.reopen(stdout_filename, "w")

num_commits = commit_list_array.size
start_target_history_count = (ARGV[1].nil? == false) ? ARGV[1].to_i : 0
end_target_history_count = (ARGV[2].nil? == false) ? ARGV[2].to_i : num_commits - 1

counter = 0
total_counter = 0
for i in start_target_history_count...end_target_history_count
  prev_commit = commit_list_array[i]
  next_commit = commit_list_array[i+1]

  if ( num_commits > 10 )
    counter = counter + 1
    total_counter = total_counter + 1
    if ( ( counter % (num_commits / 10) ) == 0)
      $stdout = old_stdout.dup
      print "# #{total_counter} -> "
      $stdout.reopen(stdout_filename, "w")
    end
  end
  # Handling for empty-tree state, as it's generated by Rugged API. No SHA field, rather an OID field
  prev_sha = ( prev_commit.respond_to?("sha") ) ? prev_commit.sha : prev_commit.oid
  next_sha = next_commit.sha

  # Using the ruby-git gem for diff between commits
  diff_bw_commits = $rubygit_gem_repo.diff(prev_sha, next_sha)

  diff = Diff.new(prev_sha, next_sha, diff_bw_commits)
  diff.generate_difffiles_and_stats
  diffs_array << diff
end

# ----------------------------------------------------------------------------------
# ------------------      CHECK FOR REVERTS       ----------------------------------
# --------------------  & Find cherry picks  ---------------------------------------
# ----------------------------------------------------------------------------------

$stdout = old_stdout.dup
5.times { print "." ; sleep(1.0/10)} ; puts "."
$stdout.reopen(stdout_filename, "w")

full_reverts = 0
partial_reverts = 0
full_cps = 0
partial_cps = 0

# The final answer - Array of diff pairs
cp_diffs = []
partial_cp_diffs = []
revert_diffs = []
partial_revert_diffs = []

# Keep a hash for the diff_pair that you have visited so far
# If you have 4 commits, you'll have 3 diffs say 1,2,3
# You will have combinations
# (3,1), (3,2), (3,3)
# (2,1), (2,2), (2,3)
# (1,1), (1,2), (1,3)
# We should not look at (1,3) once we've visited (3,1)
# and but obvious, dont look at (1,1), (2,2) and (3,3)
visited = {}

diffs_array.reverse_each do |diff|
  # For each diff starting from the latest, start comparison with the first
  diffs_array.each do |cmp_diff|
    next if diff == cmp_diff # No point looking at the same diff

    # Checkpoint - Number of difffiles should be equal
    next if diff.num_difffiles == 0 || cmp_diff.num_difffiles == 0

    diff_pair = [diff, cmp_diff].sort!
    # If you have already visited this pair, don't work again on it
    next if visited[diff_pair] == true

    # Mark this diff_pair as visited
    visited[diff_pair] = true

    match, partial_match = CompareDiffPatch(diff, cmp_diff, {"cp"=>false, "revert"=>true})
    if match == true
      # Case 1: Full revert
      if partial_match.nil?
        full_reverts = full_reverts + 1
        revert_diff_pair = {}
        revert_diff_pair[:diff] = diff
        revert_diff_pair[:cmp_diff] = cmp_diff
        revert_diffs << revert_diff_pair
      else
        partial_reverts = partial_reverts + 1
        partial_revert_diff_pair = {}
        partial_revert_diff_pair[:diff] = diff
        partial_revert_diff_pair[:cmp_diff] = cmp_diff
        partial_revert_diffs << [ partial_revert_diff_pair, partial_match ]
      end
    end

    match, partial_match = CompareDiffPatch(diff, cmp_diff, {"cp"=>true, "revert"=>false})
    if match == true
      # Case 1: Full cp
      if partial_match.nil?
        full_cps = full_cps + 1
        cp_diff_pair = {}
        cp_diff_pair[:diff] = diff
        cp_diff_pair[:cmp_diff] = cmp_diff
        cp_diffs << cp_diff_pair
      else
        partial_cps = partial_cps + 1
        partial_cp_diff_pair = {}
        partial_cp_diff_pair[:diff] = diff
        partial_cp_diff_pair[:cmp_diff] = cmp_diff
        partial_cp_diffs << [ partial_cp_diff_pair, partial_match ]
      end
    end
  end
end

$stdout = old_stdout.dup
puts "# Reverts - complete = " + full_reverts.to_s
puts "# Reverts - partial  = " + partial_reverts.to_s
puts "-----------------------------"
puts "# Cherry-picks - complete = " + full_cps.to_s
puts "# Cherry-picks - partial  = " + partial_cps.to_s
puts "-----------------------------"
$stdout.reopen(stdout_filename, "w")

# ----------------------------------------------------------------------------------
# ---------------------   Output Complete Reverts   --------------------------------
# ----------------------------------------------------------------------------------
reverts_log_file_name         = "Logs/" + project_name + "-reverts.log"
OutputCompleteReverts( reverts_log_file_name, full_reverts, revert_diffs)

# ----------------------------------------------------------------------------------
# ----------------------   Output Partial Reverts   --------------------------------
# ----------------------------------------------------------------------------------
partial_reverts_log_file_name = "Logs/" + project_name + "-partial-reverts.log"
OutputPartialReverts( partial_reverts_log_file_name, partial_reverts, partial_revert_diffs)

# ----------------------------------------------------------------------------------
# ---------------------   Output Complete Cherry-picks   ---------------------------
# ----------------------------------------------------------------------------------
full_cps_log_file_name         = "Logs/" + project_name + "-cherry-picks.log"
OutputCompleteCherryPicks( full_cps_log_file_name, full_cps, cp_diffs)

# ----------------------------------------------------------------------------------
# ----------------------   Output Partial Cherry-picks   ---------------------------
# ----------------------------------------------------------------------------------
partial_cherrypicks_log_file_name = "Logs/" + project_name + "-partial-cherrypicks.log"
OutputPartialCherryPicks( partial_cherrypicks_log_file_name, partial_cps, partial_cp_diffs)

# ----------------------------------------------------------------------------------
# ---------------------------   Output Merges   ------------------------------------
# ----------------------------------------------------------------------------------
merges_log_file_name = "Logs/" + project_name + "-merges.log"
OutputMerges( merges_log_file_name, merge_commits)

# ----------------------------------------------------------------------------------
# ----------------------------   Output All Results --------------------------------
# ----------------------------------------------------------------------------------

$stdout = old_stdout.dup
print " ---> One last touch, magic in-progress ."
10.times { print "." ; sleep(1.0/10)} ; puts "."
puts "-----------------------------"
puts " ---> The results are :-"

results_file_name = "Logs/" + project_name + "-results.txt"
op_file = File.open(results_file_name, "w")
rows = []
rows << [ '  ProjectName', project_name ]
rows << [ '  RepoURL', git_repo_url ]
rows << [ '  HEAD SHA', head_commit_sha ]
rows << [ '# Commits', num_commits ]
rows << [ '# Merges', num_merges]
rows << [ '# Reverts - Message', num_commits_revert_msg ]
rows << [ '# Reverts - Complete', full_reverts ]
rows << [ '# Reverts - Partial', partial_reverts ]
rows << [ '# Cherrypicks - Complete', full_cps ]
rows << [ '# Cherrypicks - Partial', partial_cps ]
table = Terminal::Table.new :title => "#{project_name}-results", :rows => rows
puts table
op_file.puts table

# ----------------------------------------------------------------------------------
# ----------------------------------   Cleanup -------------------------------------
# ----------------------------------------------------------------------------------

Dir.chdir "/tmp"
system("rm -rf #{project_name}")