Skip to content

Commit 6b1dbec

Browse files
axunonbaxunonb
committed
Refactor internal ParserSettings to use static or const members
Refactored internal `ParserSettings` to convert instance-level properties and methods to static or const members.
1 parent a43748e commit 6b1dbec

7 files changed

Lines changed: 68 additions & 75 deletions

File tree

‎src/SmartFormat.Tests/Core/SettingsTests.cs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,8 @@ public class SettingsTests
1111
public void TryingToAddDisallowedSelectorCharacters_Should_Throw()
1212
{
1313
var settings = new SmartSettings();
14-
Assert.That(() => settings.Parser.AddCustomSelectorChars([settings.Parser.PlaceholderBeginChar]),
15-
Throws.ArgumentException.And.Message.Contains($"{settings.Parser.PlaceholderBeginChar}"));
14+
Assert.That(() => settings.Parser.AddCustomSelectorChars([ParserSettings.PlaceholderBeginChar]),
15+
Throws.ArgumentException.And.Message.Contains($"{ParserSettings.PlaceholderBeginChar}"));
1616
}
1717

1818
[Test]
@@ -22,22 +22,22 @@ public void ExistingSelectorCharacter_Should_Not_Be_Added()
2222
settings.Parser.AddCustomSelectorChars(['A', ' ']);
2323
Assert.Multiple(() =>
2424
{
25-
Assert.That(settings.Parser.CustomSelectorChars().Count(c => c == 'A'), Is.EqualTo(0));
26-
Assert.That(settings.Parser.CustomSelectorChars().Count(c => c == ' '), Is.EqualTo(0));
25+
Assert.That(settings.Parser.CustomSelectorChars.Count(c => c == 'A'), Is.EqualTo(0));
26+
Assert.That(settings.Parser.CustomSelectorChars.Count(c => c == ' '), Is.EqualTo(0));
2727
});
2828
}
2929

3030
[Test]
3131
public void ControlCharacters_Should_Be_Added_As_SelectorChars()
3232
{
3333
var settings = new SmartSettings();
34-
var controlChars = settings.Parser.ControlChars().ToList();
34+
var controlChars = ParserSettings.ControlChars().ToList();
3535
settings.Parser.AddCustomSelectorChars(controlChars);
3636

3737
Assert.Multiple(() =>
3838
{
39-
Assert.That(settings.Parser.CustomSelectorChars().Count, Is.EqualTo(controlChars.Count));
40-
foreach (var c in settings.Parser.CustomSelectorChars())
39+
Assert.That(settings.Parser.CustomSelectorChars, Has.Count.EqualTo(controlChars.Count));
40+
foreach (var c in settings.Parser.CustomSelectorChars)
4141
{
4242
Assert.That(settings.Parser.DisallowedSelectorChars(), Does.Not.Contain(c),
4343
$"Control char U+{(int)c:X4} should be allowed as selector char.");
@@ -49,21 +49,21 @@ public void ControlCharacters_Should_Be_Added_As_SelectorChars()
4949
public void TryingToAddDisallowedOperatorCharacters_Should_Throw()
5050
{
5151
var settings = new SmartSettings();
52-
Assert.That(() => settings.Parser.AddCustomOperatorChars([settings.Parser.PlaceholderBeginChar]),
53-
Throws.ArgumentException.And.Message.Contains($"{settings.Parser.PlaceholderBeginChar}"));
52+
Assert.That(() => settings.Parser.AddCustomOperatorChars([ParserSettings.PlaceholderBeginChar]),
53+
Throws.ArgumentException.And.Message.Contains($"{ParserSettings.PlaceholderBeginChar}"));
5454
}
5555

5656
[Test]
5757
public void ExistingOperatorCharacter_Should_Not_Be_Added()
5858
{
5959
var settings = new SmartSettings();
60-
settings.Parser.AddCustomOperatorChars([settings.Parser.OperatorChars()[0], '°']);
60+
settings.Parser.AddCustomOperatorChars([ParserSettings.OperatorChars[0], '°']);
6161
settings.Parser.AddCustomOperatorChars(['°']);
6262

6363
Assert.Multiple(() =>
6464
{
65-
Assert.That(settings.Parser.CustomOperatorChars().Count(c => c == settings.Parser.OperatorChars()[0]), Is.EqualTo(0));
66-
Assert.That(settings.Parser.CustomOperatorChars().Count(c => c == '°'), Is.EqualTo(1));
65+
Assert.That(settings.Parser.CustomOperatorChars.Count(c => c == ParserSettings.OperatorChars[0]), Is.EqualTo(0));
66+
Assert.That(settings.Parser.CustomOperatorChars.Count(c => c == '°'), Is.EqualTo(1));
6767
});
6868
}
6969

‎src/SmartFormat/Core/Extensions/Source.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ private bool HasNullableOperator(ISelectorInfo selectorInfo)
4949
#pragma warning disable S3267 // Don't use LINQ in favor of less GC
5050
foreach (var s in selectorInfo.Placeholder.Selectors)
5151
{
52-
if (s.OperatorLength > 1 && s.BaseString[s.OperatorStartIndex] == _smartSettings.Parser.NullableOperator)
52+
if (s.OperatorLength > 1 && s.BaseString[s.OperatorStartIndex] == ParserSettings.NullableOperator)
5353
return true;
5454
}
5555
#pragma warning restore S3267 // Restore: Loops should be simplified with "LINQ" expressions

‎src/SmartFormat/Core/Parsing/Parser.cs‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -63,9 +63,9 @@ public Parser(SmartSettings? smartSettings = null)
6363
{
6464
Settings = smartSettings ?? new SmartSettings();
6565
_parserSettings = Settings.Parser;
66-
_operatorChars = _parserSettings.OperatorChars();
67-
_customOperatorChars = _parserSettings.CustomOperatorChars();
68-
_formatOptionsTerminatorChars = _parserSettings.FormatOptionsTerminatorChars();
66+
_operatorChars = ParserSettings.OperatorChars;
67+
_customOperatorChars = _parserSettings.CustomOperatorChars;
68+
_formatOptionsTerminatorChars = ParserSettings.FormatOptionsTerminatorChars;
6969

7070
_disallowedSelectorChars = _parserSettings.DisallowedSelectorChars();
7171
}
@@ -239,19 +239,19 @@ private void ProcessLiteralText(char inputChar, ParserState state, ParsingErrors
239239
return;
240240
}
241241

242-
if (inputChar == _parserSettings.PlaceholderBeginChar)
242+
if (inputChar == ParserSettings.PlaceholderBeginChar)
243243
{
244244
AddLiteralCharsParsedBefore(state);
245-
if (EscapeLikeStringFormat(_parserSettings.PlaceholderBeginChar, state)) return;
245+
if (EscapeLikeStringFormat(ParserSettings.PlaceholderBeginChar, state)) return;
246246

247247
// Context transition
248248
CreateNewPlaceholder(ref nestedDepth, state, out currentPlaceholder);
249249
currentContext = ParseContext.SelectorHeader;
250250
}
251-
else if (inputChar == _parserSettings.PlaceholderEndChar)
251+
else if (inputChar == ParserSettings.PlaceholderEndChar)
252252
{
253253
AddLiteralCharsParsedBefore(state);
254-
if (EscapeLikeStringFormat(_parserSettings.PlaceholderEndChar, state)) return;
254+
if (EscapeLikeStringFormat(ParserSettings.PlaceholderEndChar, state)) return;
255255
if (HasProcessedTooManyClosingBraces(parsingErrors, state)) return;
256256

257257
// End of a nested placeholder's Format.
@@ -292,7 +292,7 @@ private void ProcessSelector(char inputChar, ParserState state, ParsingErrors pa
292292
}
293293
state.Index.LastEnd = state.Index.SafeAdd(state.Index.Current, 1);
294294
}
295-
else if (inputChar == _parserSettings.FormatterNameSeparator)
295+
else if (inputChar == ParserSettings.FormatterNameSeparator)
296296
{
297297
AddLastSelector(ref currentPlaceholder, state, parsingErrors);
298298

@@ -308,7 +308,7 @@ private void ProcessSelector(char inputChar, ParserState state, ParsingErrors pa
308308
// We are now parsing the literal text *inside* the placeholder's format.
309309
currentContext = ParseContext.LiteralText;
310310
}
311-
else if (inputChar == _parserSettings.PlaceholderEndChar)
311+
else if (inputChar == ParserSettings.PlaceholderEndChar)
312312
{
313313
AddLastSelector(ref currentPlaceholder, state, parsingErrors);
314314

@@ -465,8 +465,8 @@ private void ParseAlternativeEscaping(ParserState state)
465465
throw new ArgumentException($"Unrecognized escape sequence at the end of the literal");
466466

467467
// **** Alternative brace escaping with { or } following the escape character ****
468-
if (state.InputFormat[indexNextChar] == _parserSettings.PlaceholderBeginChar ||
469-
state.InputFormat[indexNextChar] == _parserSettings.PlaceholderEndChar)
468+
if (state.InputFormat[indexNextChar] == ParserSettings.PlaceholderBeginChar ||
469+
state.InputFormat[indexNextChar] == ParserSettings.PlaceholderEndChar)
470470
{
471471
// Finish the last text item:
472472
if (state.Index.Current != state.Index.LastEnd)
@@ -509,7 +509,7 @@ private void ParseAlternativeEscaping(ParserState state)
509509
private bool ParseNamedFormatter(ParserState state)
510510
{
511511
var inputChar = state.InputFormat[state.Index.Current];
512-
if (inputChar == _parserSettings.FormatterOptionsBeginChar)
512+
if (inputChar == ParserSettings.FormatterOptionsBeginChar)
513513
{
514514
var emptyName = state.Index.NamedFormatterStart == state.Index.Current;
515515
if (emptyName)
@@ -521,16 +521,16 @@ private bool ParseNamedFormatter(ParserState state)
521521
// Note: This short-circuits the Parser.ParseFormat main loop
522522
ParseFormatOptions(state);
523523
}
524-
else if (inputChar == _parserSettings.FormatterOptionsEndChar || inputChar == _parserSettings.FormatterNameSeparator)
524+
else if (inputChar == ParserSettings.FormatterOptionsEndChar || inputChar == ParserSettings.FormatterNameSeparator)
525525
{
526-
if (inputChar == _parserSettings.FormatterOptionsEndChar)
526+
if (inputChar == ParserSettings.FormatterOptionsEndChar)
527527
{
528528
var hasOpeningParenthesis = state.Index.NamedFormatterOptionsStart != PositionUndefined;
529529

530530
// ensure no trailing chars past ')'
531531
var nextCharIndex = state.Index.SafeAdd(state.Index.Current, 1);
532532
var nextCharIsValid = nextCharIndex < state.InputFormat.Length &&
533-
(state.InputFormat[nextCharIndex] == _parserSettings.FormatterNameSeparator || state.InputFormat[nextCharIndex] == _parserSettings.PlaceholderEndChar);
533+
(state.InputFormat[nextCharIndex] == ParserSettings.FormatterNameSeparator || state.InputFormat[nextCharIndex] == ParserSettings.PlaceholderEndChar);
534534

535535
if (!hasOpeningParenthesis || !nextCharIsValid)
536536
{
@@ -540,7 +540,7 @@ private bool ParseNamedFormatter(ParserState state)
540540

541541
state.Index.NamedFormatterOptionsEnd = state.Index.Current;
542542

543-
if (state.InputFormat[nextCharIndex] == _parserSettings.FormatterNameSeparator) state.Index.Current++;
543+
if (state.InputFormat[nextCharIndex] == ParserSettings.FormatterNameSeparator) state.Index.Current++;
544544
}
545545

546546
var nameIsEmpty = state.Index.NamedFormatterStart == state.Index.Current;
@@ -601,8 +601,8 @@ private void AddLastSelector(ref Placeholder currentPlaceholder, ParserState sta
601601
if (state.Index.Current != state.Index.LastEnd ||
602602
currentPlaceholder.Selectors.Count > 0 && currentPlaceholder.Selectors[currentPlaceholder.Selectors.Count - 1].Length > 0 &&
603603
state.Index.Current - state.Index.Operator == 1 &&
604-
(state.InputFormat[state.Index.Operator] == _parserSettings.ListIndexEndChar ||
605-
state.InputFormat[state.Index.Operator] == _parserSettings.NullableOperator))
604+
(state.InputFormat[state.Index.Operator] == ParserSettings.ListIndexEndChar ||
605+
state.InputFormat[state.Index.Operator] == ParserSettings.NullableOperator))
606606
currentPlaceholder.AddSelector(SelectorPool.Instance.Get().Initialize(Settings, currentPlaceholder, state.InputFormat, state.Index.LastEnd, state.Index.Current, state.Index.Operator, state.Index.Selector));
607607
else if (state.Index.Operator != state.Index.Current)
608608
parsingErrors.AddIssue(state.ResultFormat,

‎src/SmartFormat/Core/Parsing/Placeholder.cs‎

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
using System;
66
using System.Buffers;
77
using System.Collections.Generic;
8+
using SmartFormat.Core.Settings;
89
using SmartFormat.Pooling.ObjectPools;
910
using SmartFormat.Pooling.SmartPools;
1011
using SmartFormat.ZString;
@@ -138,7 +139,7 @@ internal void AddSelector(Selector selector)
138139
// 1. The operator character must have a value, usually ','
139140
// 2. The alignment is an integer value
140141
if (selector.OperatorLength > 0
141-
&& selector.Operator[0] == SmartSettings.Parser.AlignmentOperator
142+
&& selector.Operator[0] == ParserSettings.AlignmentOperator
142143
&& int.TryParse(selector.RawText, out var alignment))
143144
{
144145
Alignment = alignment;
@@ -231,41 +232,41 @@ public override string ToString()
231232

232233
using var buffer = new ZCharArray(Length + 2); // +2 for the braces
233234

234-
buffer.Write(SmartSettings.Parser.PlaceholderBeginChar);
235+
buffer.Write(ParserSettings.PlaceholderBeginChar);
235236
foreach (var s in Selectors)
236237
{
237238
// alignment operators will be appended later
238-
if (s.Operator.Length > 0 && s.Operator[0] == SmartSettings.Parser.AlignmentOperator) continue;
239+
if (s.Operator.Length > 0 && s.Operator[0] == ParserSettings.AlignmentOperator) continue;
239240

240241
var selectorSpan = s.BaseString.AsSpan(s.OperatorStartIndex, s.EndIndex - s.OperatorStartIndex);
241242
buffer.Write(selectorSpan);
242243
}
243244
if (Alignment != 0)
244245
{
245-
buffer.Write(SmartSettings.Parser.AlignmentOperator);
246+
buffer.Write(ParserSettings.AlignmentOperator);
246247
buffer.Write(Alignment.ToString());
247248
}
248249

249250
if (FormatterName != string.Empty)
250251
{
251-
buffer.Write(SmartSettings.Parser.FormatterNameSeparator);
252+
buffer.Write(ParserSettings.FormatterNameSeparator);
252253
buffer.Write(FormatterName);
253254

254255
if (FormatterOptions != string.Empty)
255256
{
256-
buffer.Write(SmartSettings.Parser.FormatterOptionsBeginChar);
257+
buffer.Write(ParserSettings.FormatterOptionsBeginChar);
257258
buffer.Write(FormatterOptions);
258-
buffer.Write(SmartSettings.Parser.FormatterOptionsEndChar);
259+
buffer.Write(ParserSettings.FormatterOptionsEndChar);
259260
}
260261
}
261262

262263
if (Format != null)
263264
{
264-
buffer.Write(SmartSettings.Parser.FormatterNameSeparator);
265+
buffer.Write(ParserSettings.FormatterNameSeparator);
265266
buffer.Write(Format.AsSpan());
266267
}
267268

268-
buffer.Write(SmartSettings.Parser.PlaceholderEndChar);
269+
buffer.Write(ParserSettings.PlaceholderEndChar);
269270

270271
#if NETSTANDARD2_1 || NET6_0_OR_GREATER
271272
_toStringCache = new string(buffer.GetSpan());

0 commit comments

Comments
 (0)