(GH-48) Added ability to provide input file

- Rather than create release notes from an existing milestone, instead,
use an input file as the source of the description for the release on
GitHub

Author: gep13

Source/GitHubReleaseManager.Cli/GitHubReleaseManager.Cli.csproj

@@ -80,7 +80,6 @@
     <Compile Include="Options\BaseGitHubSubOptions.cs" />
     <Compile Include="Options\BaseSubOptions.cs" />
     <Compile Include="Options\CloseSubOptions.cs" />
-    <Compile Include="Options\CommonSubOptions.cs" />
     <Compile Include="Options\CreateSubOptions.cs" />
     <Compile Include="Options\ExportSubOptions.cs" />
     <Compile Include="Options\InitSubOptions.cs" />

Source/GitHubReleaseManager.Cli/Options/AddAssetSubOptions.cs

@@ -10,9 +10,12 @@ namespace GitHubReleaseManager.Cli.Options
 
     using CommandLine;
 
-    public class AddAssetSubOptions : CommonSubOptions
+    public class AddAssetSubOptions : BaseGitHubSubOptions
     {
         [OptionList('a', "assets", Separator = ',', HelpText = "Paths to the files to include in the release.", Required = true)]
         public IList<string> AssetPaths { get; set; }
+
+        [Option('t', "tagName", HelpText = "The name of the release (Typically this is the generated SemVer Version Number).", Required = true)]
+        public string TagName { get; set; }
     }
 }

Source/GitHubReleaseManager.Cli/Options/BaseSubOptions.cs

@@ -10,8 +10,8 @@ namespace GitHubReleaseManager.Cli.Options
 
     public abstract class BaseSubOptions
     {
-        [Option('t', "targetPath", HelpText = "The directory on which GitHubReleaseManager should be executed. Defaults to current directory.", Required = false)]
-        public string TargetPath { get; set; }
+        [Option('d', "targetDirectory", HelpText = "The directory on which GitHubReleaseManager should be executed. Defaults to current directory.", Required = false)]
+        public string TargetDirectory { get; set; }
 
         [Option('l', "logFilePath", HelpText = "Path to where log file should be created. Defaults to logging to console.", Required = false)]
         public string LogFilePath { get; set; }

Source/GitHubReleaseManager.Cli/Options/CloseSubOptions.cs

@@ -6,7 +6,11 @@
 
 namespace GitHubReleaseManager.Cli.Options
 {
-    public class CloseSubOptions : CommonSubOptions
+    using CommandLine;
+
+    public class CloseSubOptions : BaseGitHubSubOptions
     {
+        [Option('m', "milestone", HelpText = "The milestone to use.", Required = true)]
+        public string Milestone { get; set; }
     }
 }

Source/GitHubReleaseManager.Cli/Options/CommonSubOptions.cs

@@ -10,12 +10,21 @@ namespace GitHubReleaseManager.Cli.Options
 
     using CommandLine;
 
-    public class CreateSubOptions : CommonSubOptions
+    public class CreateSubOptions : BaseGitHubSubOptions
     {
         [OptionList('a', "assets", Separator = ',', HelpText = "Paths to the files to include in the release.", Required = false)]
         public IList<string> AssetPaths { get; set; }
 
         [Option('c', "targetcommitish", HelpText = "The commit to tag. Can be a branch or SHA. Defaults to repository's default branch.", Required = false)]
         public string TargetCommitish { get; set; }
+
+        [Option('m', "milestone", HelpText = "The milestone to use.", Required = false)]
+        public string Milestone { get; set; }
+
+        [Option('n', "name", HelpText = "The name of the release (Typically this is the generated SemVer Version Number.", Required = false)]
+        public string Name { get; set; }
+
+        [Option('i', "inputFilePath", HelpText = "The path to the file to be used as the content of the release notes.", Required = false)]
+        public string InputFilePath { get; set; }
     }
 }

Source/GitHubReleaseManager.Cli/Options/CreateSubOptions.cs

@@ -6,7 +6,11 @@
 
 namespace GitHubReleaseManager.Cli.Options
 {
-    public class PublishSubOptions : CommonSubOptions
+    using CommandLine;
+
+    public class PublishSubOptions : BaseGitHubSubOptions
     {
+        [Option('t', "tagName", HelpText = "The name of the release (Typically this is the generated SemVer Version Number).", Required = true)]
+        public string TagName { get; set; }
     }
 }

Source/GitHubReleaseManager.Cli/Options/PublishSubOptions.cs

@@ -35,87 +35,87 @@ private static int Main(string[] args)
                 args,
                 options,
                 (verb, subOptions) =>
-                    {
-                        result = 1;
+                {
+                    result = 1;
 
-                        var baseSubOptions = subOptions as BaseSubOptions;
-                        if (baseSubOptions != null)
+                    var baseSubOptions = subOptions as BaseSubOptions;
+                    if (baseSubOptions != null)
+                    {
+                        if (string.IsNullOrEmpty(baseSubOptions.TargetDirectory))
                         {
-                            if (string.IsNullOrEmpty(baseSubOptions.TargetPath))
-                            {
-                                baseSubOptions.TargetPath = Environment.CurrentDirectory;
-                            }
-
-                            ConfigureLogging(baseSubOptions.LogFilePath);
+                            baseSubOptions.TargetDirectory = Environment.CurrentDirectory;
                         }
 
-                        var fileSystem = new FileSystem();
+                        ConfigureLogging(baseSubOptions.LogFilePath);
+                    }
+
+                    var fileSystem = new FileSystem();
 
-                        if (verb == "create")
+                    if (verb == "create")
+                    {
+                        var createSubOptions = baseSubOptions as CreateSubOptions;
+                        if (createSubOptions != null)
                         {
-                            var createSubOptions = baseSubOptions as CreateSubOptions;
-                            if (createSubOptions != null)
-                            {
-                                result = CreateReleaseAsync(createSubOptions, fileSystem).Result;
-                            }
+                            result = CreateReleaseAsync(createSubOptions, fileSystem).Result;
                         }
+                    }
 
-                        if (verb == "addasset")
+                    if (verb == "addasset")
+                    {
+                        var addAssetSubOptions = baseSubOptions as AddAssetSubOptions;
+                        if (addAssetSubOptions != null)
                         {
-                            var addAssetSubOptions = baseSubOptions as AddAssetSubOptions;
-                            if (addAssetSubOptions != null)
-                            {
-                                result = AddAssetsAsync(addAssetSubOptions).Result;
-                            }
+                            result = AddAssetsAsync(addAssetSubOptions).Result;
                         }
+                    }
 
-                        if (verb == "close")
+                    if (verb == "close")
+                    {
+                        var closeSubOptions = baseSubOptions as CloseSubOptions;
+                        if (closeSubOptions != null)
                         {
-                            var closeSubOptions = baseSubOptions as CloseSubOptions;
-                            if (closeSubOptions != null)
-                            {
-                                result = CloseMilestoneAsync(closeSubOptions).Result;
-                            }
+                            result = CloseMilestoneAsync(closeSubOptions).Result;
                         }
+                    }
 
-                        if (verb == "publish")
+                    if (verb == "publish")
+                    {
+                        var publishSubOptions = baseSubOptions as PublishSubOptions;
+                        if (publishSubOptions != null)
                         {
-                            var publishSubOptions = baseSubOptions as PublishSubOptions;
-                            if (publishSubOptions != null)
-                            {
-                                result = CloseAndPublishReleaseAsync(publishSubOptions).Result;
-                            }
+                            result = PublishReleaseAsync(publishSubOptions).Result;
                         }
+                    }
 
-                        if (verb == "export")
+                    if (verb == "export")
+                    {
+                        var exportSubOptions = baseSubOptions as ExportSubOptions;
+                        if (exportSubOptions != null)
                         {
-                            var exportSubOptions = baseSubOptions as ExportSubOptions;
-                            if (exportSubOptions != null)
-                            {
-                                result = ExportReleasesAsync(exportSubOptions, fileSystem).Result;
-                            }
+                            result = ExportReleasesAsync(exportSubOptions, fileSystem).Result;
                         }
+                    }
 
-                        if (verb == "init")
+                    if (verb == "init")
+                    {
+                        var initSubOptions = baseSubOptions as InitSubOptions;
+                        if (initSubOptions != null)
                         {
-                            var initSubOptions = baseSubOptions as InitSubOptions;
-                            if (initSubOptions != null)
-                            {
-                                ConfigurationProvider.WriteSample(initSubOptions.TargetPath, fileSystem);
-                                result = 0;
-                            }
+                            ConfigurationProvider.WriteSample(initSubOptions.TargetDirectory, fileSystem);
+                            result = 0;
                         }
+                    }
 
-                        if (verb == "showconfig")
+                    if (verb == "showconfig")
+                    {
+                        var showConfigSubOptions = baseSubOptions as ShowConfigSubOptions;
+                        if (showConfigSubOptions != null)
                         {
-                            var showConfigSubOptions = baseSubOptions as ShowConfigSubOptions;
-                            if (showConfigSubOptions != null)
-                            {
-                                Console.WriteLine(ConfigurationProvider.GetEffectiveConfigAsString(showConfigSubOptions.TargetPath, fileSystem));
-                                result = 0;
-                            }
+                            Console.WriteLine(ConfigurationProvider.GetEffectiveConfigAsString(showConfigSubOptions.TargetDirectory, fileSystem));
+                            result = 0;
                         }
-                    }))
+                    }
+                }))
             {
                 return 1;
             }
@@ -128,9 +128,16 @@ private static async Task<int> CreateReleaseAsync(CreateSubOptions subOptions, I
             try
             {
                 var github = subOptions.CreateGitHubClient();
-                var configuration = ConfigurationProvider.Provide(subOptions.TargetPath, fileSystem);
+                var configuration = ConfigurationProvider.Provide(subOptions.TargetDirectory, fileSystem);
 
-                await CreateRelease(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.Milestone, subOptions.TargetCommitish, subOptions.AssetPaths, configuration);
+                if (string.IsNullOrEmpty(subOptions.Milestone))
+                {
+                    await CreateReleaseFromMilestone(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.Milestone, subOptions.TargetCommitish, subOptions.AssetPaths, configuration);
+                }
+                else
+                {
+                    await CreateReleaseFromInputFile(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.Name, subOptions.InputFilePath, subOptions.TargetCommitish, subOptions.AssetPaths, configuration);
+                }
 
                 return 0;
             }
@@ -148,7 +155,7 @@ private static async Task<int> AddAssetsAsync(AddAssetSubOptions subOptions)
             {
                 var github = subOptions.CreateGitHubClient();
 
-                await AddAssets(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.Milestone, subOptions.AssetPaths);
+                await AddAssets(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.TagName, subOptions.AssetPaths);
 
                 return 0;
             }
@@ -178,15 +185,13 @@ private static async Task<int> CloseMilestoneAsync(CloseSubOptions subOptions)
             }
         }
 
-        private static async Task<int> CloseAndPublishReleaseAsync(PublishSubOptions subOptions)
+        private static async Task<int> PublishReleaseAsync(PublishSubOptions subOptions)
         {
             try
             {
                 var github = subOptions.CreateGitHubClient();
 
-                await CloseMilestone(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.Milestone);
-
-                await PublishRelease(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.Milestone);
+                await PublishRelease(github, subOptions.RepositoryOwner, subOptions.RepositoryName, subOptions.TagName);
 
                 return 0;
             }
@@ -203,7 +208,7 @@ private static async Task<int> ExportReleasesAsync(ExportSubOptions subOptions,
             try
             {
                 var github = subOptions.CreateGitHubClient();
-                var configuration = ConfigurationProvider.Provide(subOptions.TargetPath, fileSystem);
+                var configuration = ConfigurationProvider.Provide(subOptions.TargetDirectory, fileSystem);
 
                 var releasesMarkdown = await ExportReleases(github, subOptions.RepositoryOwner, subOptions.RepositoryName, configuration);
 
@@ -222,7 +227,7 @@ private static async Task<int> ExportReleasesAsync(ExportSubOptions subOptions,
             }
         }
 
-        private static async Task CreateRelease(GitHubClient github, string owner, string repository, string milestone, string targetCommitish, IList<string> assets, Config configuration)
+        private static async Task CreateReleaseFromMilestone(GitHubClient github, string owner, string repository, string milestone, string targetCommitish, IList<string> assets, Config configuration)
         {
             var releaseNotesBuilder = new ReleaseNotesBuilder(new DefaultGitHubClient(github, owner, repository), owner, repository, milestone, configuration);
 
@@ -260,15 +265,56 @@ private static async Task CreateRelease(GitHubClient github, string owner, strin
             }
         }
 
-        private static async Task AddAssets(GitHubClient github, string owner, string repository, string milestone, IList<string> assetPaths)
+        private static async Task CreateReleaseFromInputFile(GitHubClient github, string owner, string repository, string name, string inputFilePath, string targetCommitish, IList<string> assets, Config configuration)
+        {
+            if (!File.Exists(inputFilePath))
+            {
+                throw new ArgumentException("Unable to locate input file.");
+            }
+
+            var inputFileContents = File.ReadAllText(inputFilePath);
+
+            var releaseUpdate = new ReleaseUpdate(name)
+            {
+                Draft = true,
+                Body = inputFileContents,
+                Name = name
+            };
+
+            if (!string.IsNullOrEmpty(targetCommitish))
+            {
+                releaseUpdate.TargetCommitish = targetCommitish;
+            }
+
+            var release = await github.Release.Create(owner, repository, releaseUpdate);
+
+            foreach (var asset in assets)
+            {
+                if (!File.Exists(asset))
+                {
+                    continue;
+                }
+
+                var upload = new ReleaseAssetUpload
+                {
+                    FileName = Path.GetFileName(asset),
+                    ContentType = "application/octet-stream",
+                    RawData = File.Open(asset, FileMode.Open)
+                };
+
+                await github.Release.UploadAsset(release, upload);
+            }
+        }
+
+        private static async Task AddAssets(GitHubClient github, string owner, string repository, string tagName, IList<string> assetPaths)
         {
             var releases = await github.Release.GetAll(owner, repository);
 
-            var release = releases.FirstOrDefault(r => r.TagName == milestone);
+            var release = releases.FirstOrDefault(r => r.TagName == tagName);
 
             if (release == null)
             {
-                Logger.WriteError("Unable to find Release with specified milestone");
+                Logger.WriteError("Unable to find Release with specified tagName");
                 return;
             }
 
@@ -312,17 +358,17 @@ private static async Task CloseMilestone(GitHubClient github, string owner, stri
             await milestoneClient.Update(owner, repository, milestone.Number, new MilestoneUpdate { State = ItemState.Closed });
         }
 
-        private static async Task PublishRelease(GitHubClient github, string owner, string repository, string milestone)
+        private static async Task PublishRelease(GitHubClient github, string owner, string repository, string tagName)
         {
             var releases = await github.Release.GetAll(owner, repository);
-            var release = releases.FirstOrDefault(r => r.Name == milestone);
+            var release = releases.FirstOrDefault(r => r.TagName == tagName);
 
             if (release == null)
             {
                 return;
             }
 
-            var releaseUpdate = new ReleaseUpdate(milestone)
+            var releaseUpdate = new ReleaseUpdate(tagName)
             {
                 Draft = false
             };