public override int Run(string[] remainingArguments)
{
if (!string.IsNullOrEmpty(_outDiff))
{
Console.WriteLine();
if (!_overwrite && File.Exists(_outDiff))
{
var question = string.Format("{0} already exists - do you want to replace it", _outDiff);
if (!ConsoleQuestion.AskYN(question))
{
return(1);
}
}
}
var compareCommand = new CompareCommand {
Source = _source,
Target = _target,
Verbose = _verbose,
OutDiff = _outDiff
};
try {
return(compareCommand.Execute() ? 1 : 0);
} catch (Exception ex) {
throw new ConsoleHelpAsException(ex.Message);
}
}
static int Main(string[] args)
{
var logger = LogManager.GetCurrentClassLogger();
var rootCommand = new RootCommand();
rootCommand.Description = "SimplCommerce Language Tool is a language comparison tool for SimplCommerce.";
try
{
var parser = new CommandLineBuilder(rootCommand)
.AddCommand(CompareCommand.Create())
.AddCommand(CompleteCommand.Create())
.UseVersionOption()
.UseDefaults()
.UseHelp()
.Build();
return(parser.Invoke(args));
}
catch (Exception ex)
{
logger.Error(ex, "Error!");
throw;
}
finally
{
LogManager.Shutdown();
}
}
public void GetResultsForComparison(CompareEvent @event)
{
View.Region = @event.Region;
ComparisonRequest request = @event.ToRequest();
var compareCommand = new CompareCommand(request);
compareCommand.Execute(RestClient, c => Dispatcher.BeginInvoke(() => GetResultsForComparisonCallBack(c)));
}
public void ApplyOverrides(CompareCommand command)
{
ResetOptions();
Settings.AdditionalRulesPath = command.AdditionalRulesPath ?? Settings.AdditionalRulesPath;
Settings.IncludeHeader = command.IncludeHeader ?? Settings.IncludeHeader;
Settings.OmitDisclaimer = command.OmitDisclaimer ?? Settings.OmitDisclaimer;
Settings.AssumeChanges = command.AssumeChanges ?? Settings.AssumeChanges;
}
public async Task CompareSameAssembly()
{
var command = new CompareCommand {
Assembly = "Local.dll",
PackageName = "Local"
};
var report = await Runner.Compare(command);
PAssert.IsTrue(() => report == null);
}
public async Task IncludeHeaderFalse()
{
var command = new CompareCommand {
Assembly = "Local.dll",
PackageName = "Major"
};
_integrationFixture.ApplyOverrides(command);
var report = await Runner.Compare(command);
PAssert.IsTrue(() => !report.Contains("# Local ( Major )"));
}
public async Task OmitDisclaimerFalse()
{
var command = new CompareCommand {
Assembly = "Local.dll",
PackageName = "Major"
};
_integrationFixture.ApplyOverrides(command);
var report = await Runner.Compare(command);
PAssert.IsTrue(() => report.Contains("*This is a sanity check"));
}
public async Task DotNet5IsNotFound()
{
var command = new CompareCommand {
Assembly = "Local.dll",
PackageName = "Major",
Framework = "net5.0"
};
_integrationFixture.ApplyOverrides(command);
var report = await Runner.Compare(command);
PAssert.IsTrue(() => !report.Contains("you will find nothing for .net 5"));
}
private static int Main(string[] args)
{
return(Parser.Default.ParseArguments <
CleanOptions,
CompareOptions,
TestOptions,
TrainOptions
>(args)
.MapResult(
(CleanOptions options) => Run(new CleanCommand(options)),
(CompareOptions options) => CompareCommand.Run(options),
(TestOptions options) => Run(new TestCommand(options)),
(TrainOptions options) => Run(new TrainCommand(options)),
errors => 1));
}
private static void CompareExecute(CompareOptions options)
{
if (options.Folders.Count() != 1)
{
throw new ArgumentOutOfRangeException("--folder must provide single folder/path");
}
Console.WriteLine("Started to Compare, please wait...");
var command = new CompareCommand(options);
command.Execute();
Console.WriteLine("Summary");
Console.WriteLine($" Same name files existed and compared were {command.Stats.TotalFiles}.");
Console.WriteLine($" Number of instances of files found at both sides were {command.Stats.TotalInstances}.");
Console.WriteLine($" Number of files found that were different {command.Stats.FoundFiles}.");
}
private static int Main(string[] args)
{
var asyncCommand = Parser.Default.ParseArguments <
CleanOptions,
CompareOptions,
TestOptions,
TrainOptions
>(args)
.MapResult(
(CleanOptions options) => RunAsync(new CleanCommand(options)),
(CompareOptions options) => Task.FromResult(CompareCommand.Run(options)),
(TestOptions options) => RunAsync(new TestCommand(options)),
(TrainOptions options) => RunAsync(new TrainCommand(options)),
errors => IsVersionError(errors) ? Task.FromResult(0) : Task.FromResult(1));
return(asyncCommand.GetAwaiter().GetResult());
}
public async Task CompareMajorChange()
{
var command = new CompareCommand
{
Assembly = "Local.dll",
PackageName = "Minor"
};
var report = await _runner.Compare(command);
_testOutputHelper.WriteLine(report);
using (var poly = PAssert.Poly())
{
poly.IsTrue(() => report != null);
poly.IsTrue(() => report.Contains("always bump major"));
}
}
public async Task ComparePatchChange()
{
var command = new CompareCommand {
Assembly = "Local.dll",
PackageName = "Patch"
};
var report = await Runner.Compare(command);
_testOutputHelper.WriteLine(report);
using (var poly = PAssert.Poly()) {
poly.IsTrue(() => report != null);
foreach (var change in _patchChanges)
{
poly.IsTrue(() => report.Contains(change));
}
}
}
public async Task OverrideRemoveTypeToIgnore()
{
var command = new CompareCommand
{
Assembly = "Local.dll",
PackageName = "Major"
};
_fixture.Settings.RuleOverrides["TypeRemovedRule"] = RuleOverrideType.Ignore;
var report = await _runner.Compare(command);
_testOutputHelper.WriteLine(report);
using (var poly = PAssert.Poly())
{
poly.IsTrue(() => report != null);
poly.IsTrue(() => !report.Contains("`ClassToRemove` is no longer present or accessible."));
}
}
public void TestMethod1()
{
var sut = new CompareCommand();
//sut.GetItems(new List<FileMetadata> { _item1 }, new List<FileMetadata> { _item2 });
}
