public static List <GitChangelogItem> ParseCommitMessages(GitCommit message, ChangelogSettings settings)
{
List <GitChangelogItem> items = new List <GitChangelogItem>();
var defaultCategory = settings.Categories.FirstOrDefault(c => c.IsDefault)?.DisplayName;
var summaryCategory = settings.Categories.FirstOrDefault(c => c.IsSummary)?.DisplayName;
foreach (var line in message.GetMessageLines())
{
var messageLine = new GitCommitMessageLine(line);
GitChangelogItem cm = new GitChangelogItem();
cm.Commit = message;
var category = GetCategory(settings, cm, messageLine) ?? defaultCategory;
if (string.IsNullOrEmpty(category))
{
continue;
}
if (!string.IsNullOrEmpty(summaryCategory) && category.Equals(summaryCategory))
{
cm.PartOfSummary = true;
}
cm.Category = category;
cm.Links = GetLinkText(settings, cm, messageLine);
cm.Message = GetMessage(settings, cm, messageLine);
items.Add(cm);
}
return(items);
}
public static List <GitVersion> GetVersions(ChangelogSettings settings)
{
Tag previousTag = null;
List <GitVersion> versions = new List <GitVersion>();
using (var repo = new Repository(settings.GitRepoLocation))
{
foreach (var tag in repo.Tags)
{
if (settings.VersionFilter.IsMatch(tag.FriendlyName))
{
versions.Add(CreateVersion(tag.FriendlyName, previousTag?.CanonicalName, tag.CanonicalName, settings));
previousTag = tag;
}
}
}
if (previousTag != null)
{
versions.Add(CreateVersion(null, previousTag.CanonicalName, null, settings));
}
versions.Reverse();
return(versions);
}
/// <summary>
/// Pass in your changelog settings to generate a changelog
/// </summary>
/// <param name="settings">The settings to be used during generation</param>
/// <returns>The return code</returns>
public int GenerateChangelog(ChangelogSettings settings)
{
var gitFolder = Path.Combine(settings.GitRepoLocation, ".git");
if (!Directory.Exists(gitFolder))
{
Console.Error.WriteLine($"Could not detect .git folder in {settings.GitRepoLocation}");
Console.Error.WriteLine($"Without a git folder the history can not be analyzed");
return(1);
}
GitChangelog changelog = GitChangelog.Generate(settings);
var content = changelog.GetChangeLogText();
if (settings.TestMode)
{
Console.WriteLine(content);
}
else
{
File.WriteAllText(settings.ChangelogLocation, content);
}
return(0);
}
public string GetText(ChangelogSettings settings)
{
var template = settings.Templates.VersionTemplate;
template = template.Replace("{Version}", Name);
return(template);
}
public string GetText(ChangelogSettings settings)
{
var template = settings.Templates.CategoryTemplate;
template = template.Replace("{Category}", Name);
return(template);
}
private int GenerateChangelog(ChangelogCommandlineSettings commandLineSettings)
{
var configLocation = string.IsNullOrEmpty(commandLineSettings.ConfigLocation) ? "./changelog.json" : commandLineSettings.ConfigLocation;
if (commandLineSettings.MakeConfig)
{
ChangelogSettings newSettings = new ChangelogSettings();
var directory = Path.GetDirectoryName(configLocation);
if (string.IsNullOrEmpty(directory))
{
directory = Environment.CurrentDirectory;
}
if (!Directory.Exists(directory))
{
Console.Error.WriteLine($"Path {directory} does not exist");
return(1);
}
var content = JsonConvert.SerializeObject(newSettings, Formatting.Indented);
File.WriteAllText(configLocation, content);
return(0);
}
if (!File.Exists(configLocation))
{
Console.Error.WriteLine($"Config file {configLocation} does not exist");
Console.Error.WriteLine("Create a config file using -m or --make-config");
return(1);
}
ChangelogSettings settings = JsonConvert.DeserializeObject <ChangelogSettings>(File.ReadAllText(configLocation), new JsonSerializerSettings
{
ObjectCreationHandling = ObjectCreationHandling.Replace,
NullValueHandling = NullValueHandling.Ignore
});
if (commandLineSettings.DoTest)
{
settings.TestMode = true;
}
if (!string.IsNullOrEmpty(commandLineSettings.NextVersion))
{
settings.UnreleasedTitle = commandLineSettings.NextVersion;
}
if (!string.IsNullOrEmpty(commandLineSettings.RepoLocation))
{
settings.GitRepoLocation = commandLineSettings.RepoLocation;
}
return(GenerateChangelog(settings));
}
public static List <GitCommit> GetCommitBetweenTags(ChangelogSettings settings, string versionName, string from, string to)
{
using (var repo = new Repository(settings.GitRepoLocation))
{
object fromTag = null;
object toTag = null;
if (string.IsNullOrEmpty(from))
{
fromTag = repo.Branches[settings.LatestCodeBranch];
}
else
{
fromTag = repo.Tags[from];
}
if (string.IsNullOrEmpty(to))
{
toTag = repo.Branches[settings.LatestCodeBranch];
}
else
{
toTag = repo.Tags[to];
}
if (fromTag == null || toTag == null)
{
throw new Exception($"Failed to find tags - from: {fromTag} to: {toTag}");
}
CommitFilter filter = null;
if (string.IsNullOrEmpty(from))
{
filter = new CommitFilter
{
IncludeReachableFrom = toTag
};
}
else
{
filter = new CommitFilter
{
ExcludeReachableFrom = fromTag,
IncludeReachableFrom = toTag
};
}
var commits = repo.Commits.QueryBy(filter);
return(commits.Select(c => GitCommit.Create(versionName, c)).ToList());
}
}
public static string GetCategory(ChangelogSettings settings, GitChangelogItem message, GitCommitMessageLine line)
{
foreach (var token in line.Tokens)
{
var category = settings.Categories.FirstOrDefault(c => c.Filter.IsMatch(token));
if (category != null)
{
var cleanToken = category.Filter.CleanValue(token);
line.ReplaceMessagePart(token, cleanToken);
return(category.DisplayName);
}
}
return(null);
}
public string GetLink(ChangelogSettings settings)
{
var url = LinkSettings.UrlTemplate;
var message = settings.Templates.LinkTemplate;
url = url.Replace("{LinkKey}", Token);
message = message.Replace("{LinkKey}", Token);
url = url.Replace("{LinkCleanKey}", CleanToken);
message = message.Replace("{LinkCleanKey}", CleanToken);
message = message.Replace("{Url}", url);
return(message);
}
public static string GetMessage(ChangelogSettings settings, GitChangelogItem item, GitCommitMessageLine line)
{
var message = item.PartOfSummary ? settings.Templates.SummarySentenceTemplate : settings.Templates.IssueTemplate;
message = message.Replace("{Message}", line.CleanMessage);
message = message.Replace("{Links}", item.Links);
message = message.Replace("{Category}", item.Category);
message = item.Commit.Parse(message);
message = message.Trim();
return(message);
}
public static string GetLinkText(ChangelogSettings settings, GitChangelogItem message, GitCommitMessageLine line)
{
List <GitChangelogLink> links = new List <GitChangelogLink>();
foreach (var token in line.Tokens)
{
var link = settings.Links.FirstOrDefault(c => c.Filter.IsMatch(token));
if (link != null)
{
links.Add(new GitChangelogLink(token, link));
line.ReplaceMessagePart(token, "");
}
}
StringBuilder sb = new StringBuilder();
foreach (var link in links)
{
sb.Append(link.GetLink(settings)).Append(" ");
}
return(sb.ToString());
}
private static GitVersion CreateVersion(string name, string fromName, string toName, ChangelogSettings settings)
{
var versionName = string.IsNullOrEmpty(name) ? settings.UnreleasedTitle : name;
var commits = GetCommitBetweenTags(settings, versionName, fromName, toName);
var categories = GitChangelogCategoryParser.GetCategories(commits, settings);
return(new GitVersion(versionName, commits, categories));
}
public static GitChangelog Generate(ChangelogSettings settings)
{
var versions = Utility.GetVersions(settings);
return(new GitChangelog(versions, settings));
}
public static void GenerateChangelog(this ICakeContext context, ChangelogSettings settings)
{
ChangelogCore core = new ChangelogCore();
core.GenerateChangelog(settings);
}
public static List <GitChangelogCategory> GetCategories(List <GitCommit> commits, ChangelogSettings settings)
{
var categories = new List <GitChangelogCategory>();
List <GitChangelogItem> items = commits.SelectMany(c => ParseCommitMessages(c, settings)).ToList();
foreach (var categorySetting in settings.Categories)
{
var categoryItems = items.Where(i => i.Category == categorySetting.DisplayName).ToList();
GitChangelogCategory category = new GitChangelogCategory();
category.Name = categorySetting.DisplayName;
category.Items = categoryItems;
category.Summary = categorySetting.IsSummary;
if (settings.IncludeEmptyCategories || category.Items.Count > 0)
{
categories.Add(category);
}
}
return(categories);
}
public Program(ChangelogSettings settings)
{
_settings = settings;
}
public DayTemplate(ChangelogSettings settings, List <ChangelogCommit> templateContent, List <GitHubLabel> allGitHubLabels)
{
Settings = settings;
TemplateContent = templateContent;
AllGitHubLabels = allGitHubLabels;
}
public static async Task Test()
{
var repo = new GitHubRepository
{
Branch = EnvironmentHelper.GetEnvironmentVariable("BRANCH"),
Username = EnvironmentHelper.GetEnvironmentVariable("GITUSERNAME"),
Repository = EnvironmentHelper.GetEnvironmentVariable("GITREPOSITORY")
};
if (string.IsNullOrEmpty(repo.Branch) || string.IsNullOrEmpty(repo.Username) || string.IsNullOrEmpty(repo.Repository))
{
System.Console.WriteLine("Error: Please provide Branch, Username and Repository");
return;
}
var creds = new GitHubPATAuthentification
{
PersonalAccessToken = EnvironmentHelper.GetEnvironmentVariable("PAT")
};
if (string.IsNullOrEmpty(creds.PersonalAccessToken))
{
System.Console.WriteLine("Error: Please provide PAT (personal access token)");
return;
}
var settings = new ChangelogSettings
{
Caption = EnvironmentHelper.GetEnvironmentVariable("CHANGELOGNAME"),
ChangelogLabel = EnvironmentHelper.GetEnvironmentVariable("CHANGELOGLABEL").ToLower(),
ChangelogPublishLabels = EnvironmentHelper.GetEnvironmentVariable("CHANGELOGPUBLISHLABELS").ToLower().Split(',').ToList()
};
if (string.IsNullOrEmpty(settings.Caption) || string.IsNullOrEmpty(settings.ChangelogLabel) || settings.ChangelogPublishLabels.Count <= 0)
{
System.Console.WriteLine("Error: Please provice Changelogname, Changeloglabel and Changelogpublishlabels");
}
System.Console.WriteLine(@"
_____ _ _ _ _ _ _____ _ _
| __ (_) | | | | | | | / __ \ | | |
| | \/_| |_| |_| |_ _| |__ | / \/ |__ __ _ _ __ __ _ ___| | ___ __ _
| | __| | __| _ | | | | '_ \| | | '_ \ / _` | '_ \ / _` |/ _ \ |/ _ \ / _` |
| |_\ \ | |_| | | | |_| | |_) | \__/\ | | | (_| | | | | (_| | __/ | (_) | (_| |
\____/_|\__\_| |_/\__,_|_.__/ \____/_| |_|\__,_|_| |_|\__, |\___|_|\___/ \__, |
_____ _ __/ | __/ |
| __ \ | | |___/ |___/
| | \/ ___ _ __ ___ _ __ __ _| |_ ___ _ __
| | __ / _ \ '_ \ / _ \ '__/ _` | __/ _ \| '__|
| |_\ \ __/ | | | __/ | | (_| | || (_) | | Available on github.com:
\____/\___|_| |_|\___|_| \__,_|\__\___/|_| srcmkr/GitHubChangelogGenerator
Environment-Variables:
");
System.Console.WriteLine($"REPOSITORY:");
System.Console.WriteLine($" GITUSERNAME: {EnvironmentHelper.GetEnvironmentVariable("GITUSERNAME")}");
System.Console.WriteLine($" GITREPOSITORY: {EnvironmentHelper.GetEnvironmentVariable("GITREPOSITORY")}");
System.Console.WriteLine($" BRANCH: {EnvironmentHelper.GetEnvironmentVariable("BRANCH")}");
System.Console.WriteLine($"");
System.Console.WriteLine($"CHANGELOG:");
System.Console.WriteLine($" CHANGELOGNAME: {EnvironmentHelper.GetEnvironmentVariable("CHANGELOGNAME")}");
System.Console.WriteLine($" CHANGELOGLABEL: {EnvironmentHelper.GetEnvironmentVariable("CHANGELOGLABEL")}");
System.Console.WriteLine($" CHANGELOGPUBLISHLABELS: {EnvironmentHelper.GetEnvironmentVariable("CHANGELOGPUBLISHLABELS")}");
System.Console.WriteLine($" TEMPLATE: {EnvironmentHelper.GetEnvironmentVariable("TEMPLATE")}");
System.Console.WriteLine($"");
System.Console.WriteLine($"SECURITY:");
if (string.IsNullOrEmpty(EnvironmentHelper.GetEnvironmentVariable("PAT")))
{
System.Console.WriteLine($" PAT IS NOT SET");
}
else
{
System.Console.WriteLine($" PAT IS SET: {EnvironmentHelper.GetEnvironmentVariable("PAT").Substring(0,5)}*REDACTED*");
}
System.Console.WriteLine($"");
System.Console.WriteLine($"Generating changelog...");
var htmlFileContent = await new GitHubChangelogGenerator(settings, repo, creds).CreateHtmlTemplate(EnvironmentHelper.GetEnvironmentVariable("TEMPLATE").ToLower());
File.WriteAllText("data/output.html", htmlFileContent);
System.Console.WriteLine($"Changelog generated and saved to data/output.html");
}
public GitChangelog(List <GitVersion> versions, ChangelogSettings settings)
{
Versions = versions;
Settings = settings;
}
