public void FormatReturnsValueWithPadding(int scopeLevel)
{
var config = new LoggingConfig();
var padding = new string(' ', config.ScopePaddingSpaces *scopeLevel);
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var message = Guid.NewGuid().ToString();
var exception = new ArgumentNullException(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, exception);
_output.WriteLine(actual);
if (scopeLevel > 0)
{
actual.Should().StartWith(padding);
}
else
{
actual.Should().NotStartWith(" ");
}
}
static ContextObject()
{
DefaultFormatter = MorestachioFormatterService.Default;
DefaultFormatter.AddFromType(typeof(ObjectFormatter));
DefaultFormatter.AddFromType(typeof(Number));
DefaultFormatter.AddFromType(typeof(BooleanFormatter));
DefaultFormatter.AddFromType(typeof(DateFormatter));
DefaultFormatter.AddFromType(typeof(EqualityFormatter));
DefaultFormatter.AddFromType(typeof(LinqFormatter));
DefaultFormatter.AddFromType(typeof(ListExtensions));
DefaultFormatter.AddFromType(typeof(RegexFormatter));
DefaultFormatter.AddFromType(typeof(TimeSpanFormatter));
DefaultFormatter.AddFromType(typeof(StringFormatter));
DefaultFormatter.AddFromType(typeof(RandomFormatter));
DefaultFormatter.AddFromType(typeof(Worktime));
DefaultFormatter.AddFromType(typeof(Money));
DefaultFormatter.AddFromType(typeof(HtmlFormatter));
DefaultFormatter.AddFromType(typeof(LoggingFormatter));
DefaultDefinitionOfFalse = value => value != null &&
value as bool? != false &&
// ReSharper disable once CompareOfFloatsByEqualityOperator
value as double? != 0 &&
value as int? != 0 &&
value as string != string.Empty &&
// We've gotten this far, if it is an object that does NOT cast as enumberable, it exists
// OR if it IS an enumerable and .Any() returns true, then it exists as well
(!(value is IEnumerable) || ((IEnumerable)value).Cast <object>().Any()
);
DefinitionOfFalse = DefaultDefinitionOfFalse;
}
/// <summary>
/// Parses the current object by using the given argument
/// </summary>
public async Task <object> Format(string name, KeyValuePair <string, object>[] argument)
{
await EnsureValue();
var retval = Value;
if (Value == null)
{
return(retval);
}
if (string.IsNullOrWhiteSpace(name))
{
name = null;
}
//call formatters that are given by the Options for this run
retval = await Options.Formatters.CallMostMatchingFormatter(Value.GetType(), argument, Value, name);
if (!Equals(retval, MorestachioFormatterService.FormatterFlow.Skip))
{
//one formatter has returned a valid value so use this one.
return(retval);
}
//all formatters in the options object have rejected the value so try use the global ones
retval = await DefaultFormatter.CallMostMatchingFormatter(Value.GetType(), argument, Value, name);
if (!Equals(retval, MorestachioFormatterService.FormatterFlow.Skip))
{
return(retval);
}
return(Value);
}
public void FormatHidesSensitiveDataInException(string?sensitiveValue, string message, string expected)
{
var config = new LoggingConfig();
var scopeLevel = 1;
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var logMessage = Guid.NewGuid().ToString();
var exception = new InvalidOperationException(message);
if (sensitiveValue != null)
{
config.SensitiveValues.Add(sensitiveValue);
}
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, logMessage, exception);
actual.Should().Contain(expected);
if (sensitiveValue != null)
{
actual.Should().NotContain(sensitiveValue);
}
}
/// <summary>
/// Parses the current object by using the given argument
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
public async Task <object> Format(KeyValuePair <string, object>[] argument)
{
await EnsureValue();
var retval = Value;
if (Value == null)
{
return(retval);
}
//call formatters that are given by the Options for this run
retval = await Options.Formatters.CallMostMatchingFormatter(Value.GetType(), argument, Value);
if ((retval as FormatterMatcher.FormatterFlow) != FormatterMatcher.FormatterFlow.Skip)
{
//one formatter has returned a valid value so use this one.
return(retval);
}
//all formatters in the options object have rejected the value so try use the global ones
retval = await DefaultFormatter.CallMostMatchingFormatter(Value.GetType(), argument, Value);
if ((retval as FormatterMatcher.FormatterFlow) != FormatterMatcher.FormatterFlow.Skip)
{
return(retval);
}
return(Value);
}
public void OnTearDown()
{
_formatter = null;
_fakeLogger = null;
_testObject = null;
Log.CompoundLogger.ClearLoggers();
}
private static CommandLineApplication ConfigureApplication()
{
var app = new CommandLineApplication();
app.Name = "grep.core";
app.Description = "Intelligent grep in .NET Core";
app.HelpOption();
app.ThrowOnUnexpectedArgument = false;
app.MakeSuggestionsInErrorMessage = true;
app.VersionOptionFromAssemblyAttributes(Assembly.GetExecutingAssembly());
var regexp = app.Option("-e|--regexp", "Pattern to search for", CommandOptionType.SingleValue).IsRequired();
var isSimplePattern = app.Option("-F|--fixed-strings", "Interpret pattern as a fixed string not a regular expression", CommandOptionType.NoValue);
var recurse = app.Option("-r|--recursive", "Read all files under each directory, recursively", CommandOptionType.NoValue);
var ignoreCase = app.Option("-i|--ignore-case", "Ignore case distinctions in both the pattern and the input files", CommandOptionType.NoValue);
var listFileMatches = app.Option("-l|--files-with-matches", $"Suppress normal output; instead print the name of each input file{Environment.NewLine}from which output would normally have been printed", CommandOptionType.NoValue);
var ignoreBinary = app.Option("-I", "Process a binary file as if it did not contain matching data", CommandOptionType.NoValue);
var excludeDir = app.Option("--exclude-dir", "Exclude directories matching the pattern from recursive searches", CommandOptionType.SingleValue);
var file = app.Argument("FILE", "Input files to search", multipleValues: true).IsRequired();
app.OnExecuteAsync(async cancellationToken =>
{
var sw = Stopwatch.StartNew();
var fileProviders = file.Values.Select(x => (IFileProvider) new DefaultFileProvider(x, recurse.HasValue(), excludeDir.Value())).ToList();
var matcher = isSimplePattern.HasValue() ? (ITextMatcher) new SimpleMatcher(regexp.Value(), ignoreCase.HasValue()) : (ITextMatcher) new RegexMatcher(regexp.Value(), ignoreCase.HasValue());
var formatter = new DefaultFormatter();
var results = new ResultInfo();
var printTask = PrintResults(results, formatter, listFileMatches.HasValue(), cancellationToken);
var processTask = ProcessFiles(fileProviders, matcher, results, ignoreBinary.HasValue(), cancellationToken);
await Task.WhenAll(printTask, processTask).ContinueWith(
t =>
{
sw.Stop();
Write($"{results.MatchedFiles} file(s)", ConsoleColor.Yellow);
Write(" with ", ConsoleColor.DarkGray);
Write($"{results.TotalMatches} match(es)", ConsoleColor.Blue);
WriteLine($" in {results.TotalFiles} file(s) in {sw.Elapsed:g}", ConsoleColor.DarkGray);
if (Debugger.IsAttached)
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey(true);
}
},
cancellationToken);
});
return(app);
}
public void OnSetup()
{
_formatter = new DefaultFormatter();
_fakeLogger = new FakeLogger();
_testObject = new object();
Log.CompoundLogger.ClearLoggers();
Log.CompoundLogger.SetLoggers(_fakeLogger);
}
private InfluxdbFormatter GetDefaultFormatter()
{
var formatter = new DefaultFormatter(false, null);
formatter.ContextNameFormatter = null;
formatter.MetricNameFormatter = null;
formatter.TagKeyFormatter = null;
formatter.FieldKeyFormatter = null;
return(formatter);
}
public void FormatTotal_ReturnsOriginalString()
{
var formatter = new DefaultFormatter();
var testSb = new StringBuilder("test");
formatter.FormatTotal(testSb);
var result = testSb.ToString();
Assert.AreEqual(result, "test");
}
public void FormatTax_ReturnsWithNewLine()
{
var formatter = new DefaultFormatter();
var testSb = new StringBuilder("test");
formatter.FormatTax(testSb);
var result = testSb.ToString();
Assert.AreEqual(result, $"test{Environment.NewLine}");
}
/// <summary>
/// Pick the best available formatter to format the given piece of code.
/// </summary>
/// <param name="code">The code to be formatted. This parameter cannot be null.</param>
/// <param name="language">
/// The language into which code has been written. Ex: "C#", "Java".
/// If no such formatter is available, a default formatting is applied.
/// This parameter cannot be null.
/// </param>
/// <returns>
/// The formatting for this piece of code.
/// </returns>
public FormattedCode Format(string code, string language)
{
UiExceptionHelper.CheckNotNull(code, "code");
UiExceptionHelper.CheckNotNull(language, "language");
if (_formatters.HasLanguage(language))
{
return(_formatters[language].Format(code));
}
return(DefaultFormatter.Format(code));
}
/// <summary>
/// A convenient method to make the formatting of a piece of code when
/// only the file extension is known.
/// </summary>
/// <param name="code">The piece of code to be formatted. This parameter
/// cannot be null.</param>
/// <param name="extension">The file extension associated to this piece of code.
/// Ex: "cs", "cpp". This is used to pick the formatter assigned to. If no such
/// formatter exists, the default one is picked up.</param>
/// <returns>The FormattedCode for this piece of code.</returns>
public FormattedCode FormatFromExtension(string code, string extension)
{
UiExceptionHelper.CheckNotNull(code, "code");
UiExceptionHelper.CheckNotNull(extension, "extension");
if (_formatters.HasExtension(extension))
{
return(_formatters.GetFromExtension(extension).Format(code));
}
return(DefaultFormatter.Format(code));
}
public int Execute()
{
DefaultFormatter formatter = new DefaultFormatter("fr");
Console.WriteLine(formatter.DateHumanize_Now());
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()
.Where(a => a.GetName().Name.StartsWith("Humanizer")))
{
Console.WriteLine($"{assembly.FullName} from {assembly.Location}");
}
return(0);
}
public void FormatReturnsEmptyWhenMessageIsNullEmptyOrWhiteSpace(string message)
{
var config = new LoggingConfig().Set(x => x.ScopePaddingSpaces = 2);
var scopeLevel = 1;
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, null);
actual.Should().BeEmpty();
}
public void FormatMethodEntry_HideTimeStampInMethodIsSet_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().WithTimeStampInMethodHidden().Build();
var formatter = new DefaultFormatter();
var entry = new MethodEntry(1, "Yalf.TestMethod", new[] { "param1", "param2" }, DateTime.Parse("2022-10-22 22:22:31.678"));
var expectedText = "[Enter] Yalf.TestMethod(param1, param2)";
// Act
var outputText = formatter.FormatMethodEntry(22, 1, 33, entry, filters, true);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
public void FormatMethodExit_ReturnRecordedIsFalse_ExpectedTextIsReturned()
{
// Arrange
var filters = this.GetDefaultFilters();
var formatter = new DefaultFormatter();
var entry = new MethodExit(1, "Yalf.TestMethod", 345, false, "returnVal");
var expectedText = "[Exit] Yalf.TestMethod() duration 345ms";
// Act
var outputText = formatter.FormatMethodExit(22, 1, 33, entry, filters, true);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
public void FormatMethodExit_HideMethodReturnValueIsSet_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().WithMethodReturnValueHidden().Build();
var formatter = new DefaultFormatter();
var entry = new MethodExit(1, "Yalf.TestMethod", 345, true, "returnVal");
var expectedText = "[Exit] Yalf.TestMethod() duration 345ms";
// Act
var outputText = formatter.FormatMethodExit(22, 1, 33, entry, filters, true);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
public void FormatLogEvent_ValidLog_ExpectedTextIsReturned()
{
// Arrange
var filters = this.GetDefaultFilters();
var formatter = new DefaultFormatter();
var entry = new LogEvent(LogLevel.Info, DateTime.Parse("2022-10-22 22:22:31.678"), "This is a log entry");
var expectedText = "[Log] [Info] This is a log entry";
// Act
var outputText = formatter.FormatLogEvent(22, 1, 33, entry, filters, true);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
public void FormatReturnsValueWithLogLevel(LogLevel logLevel)
{
var config = new LoggingConfig();
var scopeLevel = 1;
var eventId = Model.Create <EventId>();
var message = Guid.NewGuid().ToString();
var categoryName = Guid.NewGuid().ToString();
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, null);
_output.WriteLine(actual);
actual.Should().Contain(logLevel.ToString());
}
public void FormatReturnsValueWithoutException()
{
var config = new LoggingConfig();
var scopeLevel = 1;
var name = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var message = Guid.NewGuid().ToString();
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, name, logLevel, eventId, message, null);
_output.WriteLine(actual);
actual.Should().NotContain("Exception");
}
protected virtual string Format(object value, string format, string language)
{
if (_formatters != null)
{
for (var i = 0; i < _formatters.Count; i++)
{
var formatter = _formatters[i];
if (formatter.CanFormat(value, format, language))
{
return(formatter.Format(value, format, language));
}
}
}
return(DefaultFormatter.Format(value, format, language));
}
public void FormatException_ValidLog_ExpectedTextIsReturned()
{
// Arrange
var filters = this.GetDefaultFilters();
var formatter = new DefaultFormatter();
var ex = this.GenerateExceptionWithStackTrace();
var entry = new ExceptionTrace(ex, DateTime.Parse("2022-10-22 22:22:31.678"));
var expectedText = "[Exception] 22:22:31.678 Attempted to divide by zero.";
// Act
var outputText = formatter.FormatException(22, 1, 33, entry, filters);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
public void FormatReturnsValueWithoutName()
{
var config = new LoggingConfig();
var scopeLevel = 1;
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var message = Guid.NewGuid().ToString();
var exception = new ArgumentNullException(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, exception);
_output.WriteLine(actual);
actual.Should().NotContain(categoryName);
}
public void FormatThread_ValidLogWithBlankThreadName_ExpectedTextIsReturned()
{
// Arrange
var filters = this.GetDefaultFilters();
var formatter = new DefaultFormatter();
var entry1 = new MethodEntry(1, "Yalf.TestMethod", new[] { "param1", "param2" }, DateTime.Parse("2022-10-22 22:22:31.678"));
var entry2 = new MethodExit(1, "Yalf.TestMethod", 345, true, "returnVal");
var entry = new ThreadData(22, String.Empty, new BaseEntry[] { entry1, entry2 });
var expectedText = "[Thread 22]";
// Act
var outputText = formatter.FormatThread(entry, filters);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
static async Task MainAsync(string[] args)
{
var searchTerm = new SearchTerm(args);
var searchers = GetSearchers();
ICalculator calculator = new DefaultCalculator();
var searcher = new SearchService(searchTerm, searchers, calculator);
await searcher.Search();
IFormatter formatter = new DefaultFormatter();
var sb = new StringBuilder();
sb.Append(formatter.FormatResultsPerTerm(searcher.ResultsPerTerm));
sb.Append(formatter.FormatWinnersPerEngine(searcher.WinnersPerEngine));
sb.Append(formatter.FormatTotalWinner(searcher.TotalWinner));
Console.WriteLine(sb);
Console.ReadLine();
}
public void FormatHidesSensitiveDataInMessage(string?sensitiveValue, string message, string expected)
{
var config = new LoggingConfig();
var scopeLevel = 1;
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
if (sensitiveValue != null)
{
config.SensitiveValues.Add(sensitiveValue);
}
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, null);
actual.Should().Be($" Information [{eventId.Id}]: {expected}");
}
public async Task <object> Format(KeyValuePair <string, object>[] argument)
{
await EnsureValue();
var retval = Value;
if (Value == null)
{
return(retval);
}
var name = argument.FirstOrDefault().Value?.ToString();
var argumentWithoutName = argument.Skip(1).ToArray();
//call formatters that are given by the Options for this run
retval = await Options.Formatters.CallMostMatchingFormatter(Value.GetType(), argumentWithoutName, Value, name);
if (!Equals(retval, MorestachioFormatterService.FormatterFlow.Skip))
{
//one formatter has returned a valid value so use this one.
return(retval);
}
//call formatters that are given by the Options for this run
retval = await Options.Formatters.CallMostMatchingFormatter(Value.GetType(), argument, Value, null);
if (!Equals(retval, MorestachioFormatterService.FormatterFlow.Skip))
{
//one formatter has returned a valid value so use this one.
return(retval);
}
//all formatters in the options object have rejected the value so try use the global ones
retval = await DefaultFormatter.CallMostMatchingFormatter(Value.GetType(), argument, Value, null);
if (!Equals(retval, MorestachioFormatterService.FormatterFlow.Skip))
{
return(retval);
}
return(Value);
}
public void FormatIncludesNewLineBetweenMessageAndException(string message, bool exceptionExists)
{
var config = new LoggingConfig();
var scopeLevel = 1;
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
Exception?exception = exceptionExists
? new ArgumentNullException(Guid.NewGuid().ToString(), Guid.NewGuid().ToString())
: null;
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, exception);
actual.Should().NotStartWith(Environment.NewLine);
actual.Should().NotEndWith(Environment.NewLine);
if (string.IsNullOrWhiteSpace(message))
{
if (exception != null)
{
actual.Should().Be($" Information [{eventId.Id}]: {exception}");
}
else
{
actual.Should().BeEmpty();
}
}
else if (exception != null)
{
actual.Should()
.Be(
$" Information [{eventId.Id}]: stuff{Environment.NewLine} Information [{eventId.Id}]: {exception}");
}
else
{
actual.Should().Be($" Information [{eventId.Id}]: stuff");
}
}
/// <summary>
/// Gets an FormatterCache from ether the custom formatter or the global one
/// </summary>
public virtual FormatterCache PrepareFormatterCall(Type type,
string name,
FormatterArgumentType[] arguments,
ScopeData scopeData)
{
if (string.IsNullOrWhiteSpace(name))
{
name = null;
}
//call formatters that are given by the Options for this run
var cache = scopeData.ParserOptions.Formatters.PrepareCallMostMatchingFormatter(type, arguments, name, scopeData.ParserOptions, scopeData);
if (cache != null)
{
//one formatter has returned a valid value so use this one.
return(cache);
}
//all formatters in the options object have rejected the value so try use the global ones
return(DefaultFormatter.PrepareCallMostMatchingFormatter(type, arguments, name, scopeData.ParserOptions, scopeData));
}