# Copyright (C) 2020 by the Georgia Tech Research Institute (GTRI)
# This software may be modified and distributed under the terms of
# the BSD 3-Clause license. See the LICENSE file for details.
defmodule GitHelper do
@moduledoc """
Collection of lower-level functions for analyzing outputs from git command.
"""
require Logger
@type contrib_count :: %{String.t() => integer}
@doc """
parse_diff/1: returns the relevant information contained in the last array position of a diff array
"""
@spec parse_diff([String.t()]) :: {:ok, non_neg_integer, non_neg_integer, non_neg_integer}
def parse_diff(list) do
last = List.last(list)
last_trimmed = String.trim(last)
commit_info = String.split(last_trimmed, ", ")
file_string = Enum.at(commit_info, 0)
if file_string == nil do
{:ok, 0, 0, 0}
else
insertion_string = Enum.at(commit_info, 1)
if insertion_string == nil do
[file_num | _tail] = String.split(file_string, " ")
{:ok, String.to_integer(file_num), 0, 0}
else
deletion_string = Enum.at(commit_info, 2)
if deletion_string == nil do
[file_num | _tail] = String.split(file_string, " ")
[insertion_num | _tail] = String.split(insertion_string, " ")
{:ok, String.to_integer(file_num), String.to_integer(insertion_num), 0}
else
[file_num | _tail] = String.split(file_string, " ")
[insertion_num | _tail] = String.split(insertion_string, " ")
[deletion_num | _tail] = String.split(deletion_string, " ")
{:ok, String.to_integer(file_num), String.to_integer(insertion_num),
String.to_integer(deletion_num)}
end
end
end
end
@doc """
get_avg_tag_commit_tim_diff/1: return the average time between commits within each subarray representing a tag
"""
def get_avg_tag_commit_time_diff(list) do
get_avg_tag_commit_time_diff(list, [])
end
@doc """
get_total_tag_commit_time_diff/1: return the total time between commits within each subarray representing a tag
"""
def get_total_tag_commit_time_diff(list) do
get_total_tag_commit_time_diff(list, [])
end
@doc """
split_commits_by_tag/1: returns a list with sublists arranged by tag
"""
def split_commits_by_tag(list) do
split_commits_by_tag(list, [])
end
@doc """
get_contributor_counts/1: Gets the number of contributions belonging to each author and return a map of %{name => number}
"""
def get_contributor_counts(list) do
counts = get_contributor_counts(list, %{})
counts
end
@doc """
det_filtered_contributor_count/2: Gets the resolved list of contributers, return count and list
"""
@spec get_filtered_contributor_count(contrib_count, non_neg_integer) ::
{:ok, non_neg_integer, [contrib_count]}
def get_filtered_contributor_count(map, total) do
filtered_list =
Enum.filter(
map,
fn {_key, value} ->
value / total >= 1 / Kernel.map_size(map)
end
)
length = Kernel.length(filtered_list)
{:ok, length, filtered_list}
end
@spec parse_shortlog(String.t()) :: [Contributor.t()]
def parse_shortlog(log) do
split_shortlog(log)
|> Enum.map(fn contributor ->
{name, email, count} = parse_header(contributor)
{merges, commits} = parse_commits(contributor)
{count, _} = Integer.parse(count)
%Contributor{
name: String.trim(name),
email: String.trim(email),
count: count,
merges: merges,
commits: commits
}
end)
|> filter_contributors()
end
defp split_shortlog(log) do
log
|> String.trim()
|> String.split(~r{\n\n})
end
def parse_header(contributor) do
header =
contributor
|> String.split("\n")
|> Enum.at(0)
|> (&Regex.scan(~r{(\d*|[^<]+)<([^;]*)>.\(([^:]+)\)}, &1)).()
cond do
length(header) == 0 ->
Logger.error("Failed to process: " <> contributor)
{"Could not process", "Could not process", "0"}
true ->
header = Enum.at(header, 0)
{Enum.at(header, 1), Enum.at(header, 2), Enum.at(header, 3)}
end
end
defp parse_commits(contributor) do
[_ | commits] = String.split(contributor, "\n")
commits = Enum.map(commits, fn commit -> String.trim(commit) end)
merges = Enum.count(commits, &(&1 =~ ~r/^(merge)+/i))
{merges, commits}
end
defp split_commits_by_tag([], current) do
{:ok, current}
end
defp split_commits_by_tag([first | rest], []) do
split_commits_by_tag(rest, [[first]])
end
defp split_commits_by_tag([first | rest], current) do
[head | _tail] = first
if String.contains?(head, "tag") do
new_current = [[first] | current]
split_commits_by_tag(rest, new_current)
else
[current_head | current_tail] = current
new_current = [[first | current_head] | current_tail]
split_commits_by_tag(rest, new_current)
end
end
defp get_total_tag_commit_time_diff([first | tail], accumulator) do
{:ok, time} = TimeHelper.sum_ts_diff(first)
ret = [time | accumulator]
get_total_tag_commit_time_diff(tail, ret)
end
defp get_total_tag_commit_time_diff([], accumulator) do
{:ok, accumulator}
end
defp get_avg_tag_commit_time_diff([first | tail], accumulator) do
{:ok, time} = TimeHelper.sum_ts_diff(first)
ret = [time / Kernel.length(first) | accumulator]
get_avg_tag_commit_time_diff(tail, ret)
end
defp get_avg_tag_commit_time_diff([], accumulator) do
{:ok, accumulator}
end
defp get_contributor_counts([head | tail], accumulator) do
if head == "" do
get_contributor_counts(tail, accumulator)
else
maybe_new_key = Map.put_new(accumulator, String.trim(head), 0)
{_num, new_value} =
Map.get_and_update(maybe_new_key, head, fn current_value ->
if current_value == nil do
{0, 1}
else
{current_value, current_value + 1}
end
end)
get_contributor_counts(tail, new_value)
end
end
defp get_contributor_counts([], accumulator) do
{:ok, accumulator}
end
defp name_sorter(x) do
# Create a name metric to compare with
10 * length(String.split(x, " ")) + String.length(x)
end
defp filter_contributors([]) do
[]
end
@spec filter_contributors([Contributor.t()]) :: [Contributor.t()]
defp filter_contributors(list) do
is_author = fn x, y -> String.downcase(x.email) == String.downcase(y.email) end
# Divide the list
cur_contrib = for item <- list, is_author.(item, hd(list)) == true, do: item
other = for item <- list, is_author.(item, hd(list)) == false, do: item
# Determine the best name
# for now, just the first one
name_list = for a <- cur_contrib, do: a.name
best_name =
Enum.sort_by(name_list, &name_sorter/1, &>=/2)
|> Enum.at(0)
# Create the new contributor object
contrib_ret = %Contributor{
name: best_name,
email: hd(list).email,
commits: List.flatten(for a <- cur_contrib, do: a.commits),
merges: Enum.sum(for a <- cur_contrib, do: a.merges),
count: Enum.sum(for a <- cur_contrib, do: a.count)
}
[contrib_ret | filter_contributors(other)]
end
end
