Feature/configurable humanizer (#290)

SonOfSardaar · Gurpreet Singh · web-flow · commit 49585ea3b0dd · 2025-10-25T23:44:09.000+01:00
* Allow setting up custom Humanizer

* Change DefaultHumanizer class to public

---------

Co-authored-by: Gurpreet Singh &lt;gps@coding.com&gt;
diff --git a/src/TestStack.BDDfy.Tests/DefaultHumanizerTests.cs b/src/TestStack.BDDfy.Tests/DefaultHumanizerTests.cs
@@ -5,51 +5,53 @@
 
 namespace TestStack.BDDfy.Tests
 {
-    public class NetToStringTests
+    public class DefaultHumanizerTests
     {
+        private static DefaultHumanizer Humanizer => new();
+
         [Fact]
         public void PascalCaseInputStringIsTurnedIntoSentence()
         {
-            Configurator.Scanners.Humanize("PascalCaseInputStringIsTurnedIntoSentence")
+            Humanizer.Humanize("PascalCaseInputStringIsTurnedIntoSentence")
                 .ShouldBe("Pascal case input string is turned into sentence");
         }
 
         [Fact]
         public void WhenInputStringContainsConsequtiveCaptialLetters_ThenTheyAreTurnedIntoOneLetterWords()
         {
-            Configurator.Scanners.Humanize("WhenIUseAnInputAHere").ShouldBe("When I use an input a here");
+            Humanizer.Humanize("WhenIUseAnInputAHere").ShouldBe("When I use an input a here");
         }
 
         [Fact]
         public void WhenInputStringStartsWithANumber_ThenNumberIsDealtWithLikeAWord()
         {
-            Configurator.Scanners.Humanize("10NumberIsInTheBegining").ShouldBe("10 number is in the begining");
+            Humanizer.Humanize("10NumberIsInTheBegining").ShouldBe("10 number is in the begining");
         }
 
         [Fact]
         public void WhenInputStringEndWithANumber_ThenNumberIsDealtWithLikeAWord()
         {
-            Configurator.Scanners.Humanize("NumberIsAtTheEnd100").ShouldBe("Number is at the end 100");
+            Humanizer.Humanize("NumberIsAtTheEnd100").ShouldBe("Number is at the end 100");
         }
 
         [Fact]
         public void UnderscoredInputStringIsTurnedIntoSentence()
         {
-            Configurator.Scanners.Humanize("Underscored_input_string_is_turned_into_sentence")
+            Humanizer.Humanize("Underscored_input_string_is_turned_into_sentence")
                 .ShouldBe("Underscored input string is turned into sentence");
         }
 
         [Fact]
         public void UnderscoredInputStringPreservesCasing()
         {
-            Configurator.Scanners.Humanize("Underscored_input_String_is_turned_INTO_sentence")
+            Humanizer.Humanize("Underscored_input_String_is_turned_INTO_sentence")
                 .ShouldBe("Underscored input String is turned INTO sentence");
         }
 
         [Fact]
         public void OneLetterWordInTheBeginningOfStringIsTurnedIntoAWord()
         {
-            Configurator.Scanners.Humanize("XIsFirstPlayer").ShouldBe("X is first player");
+            Humanizer.Humanize("XIsFirstPlayer").ShouldBe("X is first player");
         }
 
         [Theory]
@@ -67,14 +69,14 @@ public void OneLetterWordInTheBeginningOfStringIsTurnedIntoAWord()
         [InlineData("WhenMethodTakes__one__and__two__parameters", "When method takes <one> and <two> parameters")]
         public void CanDealWithExampleStepNames(string stepName, string expectedStepTitle)
         {
-            NetToString.Convert(stepName).ShouldBe(expectedStepTitle);
+            Humanizer.Humanize(stepName).ShouldBe(expectedStepTitle);
         }
 
         [Theory]
         [InlineData("GivenThereAre__tv�__Cucumbers", "Given there are <tv�> cucumbers")]
         public void ReportsIllegalExampleStepNames(string stepName, string expectedStepTitle) {
             var exception = Record.Exception(() => {
-                NetToString.Convert(stepName).ShouldBe(expectedStepTitle);
+                Humanizer.Humanize(stepName).ShouldBe(expectedStepTitle);
             });
 
             exception.ShouldNotBeNull();
diff --git a/src/TestStack.BDDfy.Tests/Scanner/FluentScanner/BDDfyUsingFluentApi.cs b/src/TestStack.BDDfy.Tests/Scanner/FluentScanner/BDDfyUsingFluentApi.cs
@@ -279,7 +279,7 @@ public void WhenTitleIsNotProvidedItIsFetchedFromMethodName()
                     .BDDfy();
 
             var scenario = story.Scenarios.First();
-            scenario.Title.ShouldBe(Configurator.Scanners.Humanize(nameof(WhenTitleIsNotProvidedItIsFetchedFromMethodName)));
+            scenario.Title.ShouldBe(Configurator.Humanizer.Humanize(nameof(WhenTitleIsNotProvidedItIsFetchedFromMethodName)));
         }
 
         [Fact]
diff --git a/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenCombinationOfExecutableAttributeAndMethodNamingConventionIsUsed.cs b/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenCombinationOfExecutableAttributeAndMethodNamingConventionIsUsed.cs
@@ -125,15 +125,15 @@ public void LegacyConsecutiveAssertionStepIsScanned()
 
         void VerifyStepAndItsProperties(Expression<Action> stepMethodAction, ExecutionOrder expectedOrder, int expectedCount = 1)
         {
-            var matchingSteps = _scenario.Steps.Where(s => s.Title.Trim() == Configurator.Scanners.Humanize(Helpers.GetMethodInfo(stepMethodAction).Name));
+            var matchingSteps = _scenario.Steps.Where(s => s.Title.Trim() == Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(stepMethodAction).Name));
             matchingSteps.Count().ShouldBe(expectedCount);
             matchingSteps.All(s => s.ExecutionOrder == expectedOrder).ShouldBe(true);
         }
 
         [Fact]
         public void IgnoredMethodShouldNotBeAddedToSteps()
         {
-            var matchingSteps = _scenario.Steps.Where(s => s.Title == Configurator.Scanners.Humanize(Helpers.GetMethodInfo(() => _sut.ThenIAmNotAStep()).Name));
+            var matchingSteps = _scenario.Steps.Where(s => s.Title == Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(() => _sut.ThenIAmNotAStep()).Name));
             matchingSteps.ShouldBeEmpty();
         }
     }
diff --git a/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenMethodNamesFollowNamingConventionsOtherThanGivenWhenThen.cs b/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenMethodNamesFollowNamingConventionsOtherThanGivenWhenThen.cs
@@ -89,7 +89,7 @@ public void IncorrectSpecificationStepIsNotAdded()
 
         void AssertSpecificationStepIsScannedProperly(Expression<Action> getSpecMethod)
         {
-            var specMethods = _steps.Where(s => s.Title.Trim() == Configurator.Scanners.Humanize(Helpers.GetMethodInfo(getSpecMethod).Name));
+            var specMethods = _steps.Where(s => s.Title.Trim() == Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(getSpecMethod).Name));
             specMethods.Count().ShouldBe(1);
             var specStep = specMethods.First();
             specStep.Asserts.ShouldBe(false);
diff --git a/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenStepsAreDefinedInABaseClass.cs b/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenStepsAreDefinedInABaseClass.cs
@@ -41,15 +41,15 @@ Scenario Scenario
         [RunStepWithArgs("ThenInTheBaseClass")]
         void ThenTheFollowingStepFromBaseClassIsScanned(string stepName)
         {
-            Scenario.Steps.Count(s => s.Title == Configurator.Scanners.Humanize(stepName)).ShouldBe(1);
+            Scenario.Steps.Count(s => s.Title == Configurator.Humanizer.Humanize(stepName)).ShouldBe(1);
         }
 
         [RunStepWithArgs("GivenInTheSubClass")]
         [RunStepWithArgs("WhenInTheSubClass")]
         [RunStepWithArgs("ThenInTheSubClass")]
         void ThenTheFollowingStepFromSubClassScanned(string stepName)
         {
-            Scenario.Steps.Count(s => s.Title == Configurator.Scanners.Humanize(stepName)).ShouldBe(1);
+            Scenario.Steps.Count(s => s.Title == Configurator.Humanizer.Humanize(stepName)).ShouldBe(1);
         }
 
         [Fact]
diff --git a/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenTestClassUsesExecutableAttributes.cs b/src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenTestClassUsesExecutableAttributes.cs
@@ -68,7 +68,7 @@ public WhenTestClassUsesExecutableAttributes()
 
         private static string GetStepTextFromMethodName(Expression<Action> methodInfoAction)
         {
-            return Configurator.Scanners.Humanize(Helpers.GetMethodInfo(methodInfoAction).Name);
+            return Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(methodInfoAction).Name);
         }
 
         [Fact]
diff --git a/src/TestStack.BDDfy/BDDfyExtensions.cs b/src/TestStack.BDDfy/BDDfyExtensions.cs
@@ -52,12 +52,12 @@ public static Engine LazyBDDfy<TStory>(this object testObject, string scenarioTi
         /// <returns></returns>
         public static Story BDDfy(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)
         {
-            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller)).Run();
+            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller)).Run();
         }
 
         public static Engine LazyBDDfy(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)
         {
-            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller));
+            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller));
         }
 
         /// <summary>
@@ -71,13 +71,13 @@ public static Engine LazyBDDfy(this object testObject, string scenarioTitle = nu
         public static Story BDDfy<TStory>(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)
             where TStory : class
         {
-            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller), typeof(TStory)).Run();
+            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller), typeof(TStory)).Run();
         }
 
         public static Engine LazyBDDfy<TStory>(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)
             where TStory : class
         {
-            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller), typeof(TStory));
+            return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller), typeof(TStory));
         }
 #endif
 
diff --git a/src/TestStack.BDDfy/Configuration/Configurator.cs b/src/TestStack.BDDfy/Configuration/Configurator.cs
@@ -2,45 +2,18 @@ namespace TestStack.BDDfy.Configuration
 {
     public static class Configurator
     {
-        static Configurator()
-        {
-            AsyncVoidSupportEnabled = true;
-        }
+        public static bool AsyncVoidSupportEnabled { get; set; } = true;
 
-        public static bool AsyncVoidSupportEnabled { get; set; }
+        public static Processors Processors { get; } = new();
 
-        private static readonly Processors ProcessorsFactory = new();
-        public static Processors Processors
-        {
-            get { return ProcessorsFactory; }
-        }
+        public static BatchProcessors BatchProcessors { get; } = new();
 
-        private static readonly BatchProcessors BatchProcessorFactory = new();
-        public static BatchProcessors BatchProcessors
-        {
-            get { return BatchProcessorFactory; }
-        }
+        public static Scanners Scanners { get; } = new();
 
-        private static readonly Scanners ScannersFactory = new();
-        public static Scanners Scanners
-        {
-            get { return ScannersFactory; }
-        }
+        public static IKeyGenerator IdGenerator { get; set; } = new SequentialKeyGenerator();
 
-        private static IKeyGenerator _idGenerator = new SequentialKeyGenerator();
-        public static IKeyGenerator IdGenerator
-        {
-            get { return _idGenerator; }
-            set { _idGenerator = value; }
-        }
-
-
-        private static IStepExecutor _stepExecutor = new StepExecutor();
-        public static IStepExecutor  StepExecutor
-        {
-            get { return _stepExecutor; }
-            set { _stepExecutor = value; }
-        }
+        public static IStepExecutor StepExecutor { get; set; } = new StepExecutor();
 
+        public static IHumanizer Humanizer { get; set; } = new DefaultHumanizer();
     }
 }
diff --git a/src/TestStack.BDDfy/Configuration/IHumanizer.cs b/src/TestStack.BDDfy/Configuration/IHumanizer.cs
@@ -0,0 +1,7 @@
+namespace TestStack.BDDfy.Configuration
+{
+    public interface IHumanizer
+    {
+        string Humanize(string input);
+    }
+}
diff --git a/src/TestStack.BDDfy/Configuration/Scanners.cs b/src/TestStack.BDDfy/Configuration/Scanners.cs
@@ -35,7 +35,5 @@ public IEnumerable<IStepScanner> GetStepScanners(object objectUnderTest)
         }
 
         public Func<IStoryMetadataScanner> StoryMetadataScanner = () => new StoryAttributeMetadataScanner();
-
-        public Func<string, string> Humanize = NetToString.Convert;
     }
 }
diff --git a/src/TestStack.BDDfy/DefaultHumanizer.cs b/src/TestStack.BDDfy/DefaultHumanizer.cs
@@ -2,10 +2,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using TestStack.BDDfy.Configuration;
 
 namespace TestStack.BDDfy
 {
-    public class NetToString
+    public partial class DefaultHumanizer: IHumanizer
     {
         static readonly Func<string, string> FromUnderscoreSeparatedWords = methodName => string.Join(" ", methodName.Split(new[] { '_' }));
         static string FromPascalCase(string name)
@@ -49,29 +51,31 @@ private static bool ShouldAddSpace(char lastChar, char currentChar)
             return false;
         }
 
-        public static readonly Func<string, string> Convert = name => {
-            return name.Contains("__") ? ExampleTitle(name) : ConvertNonExample(name);
-        };
-
         private static readonly Func<string, string> ConvertNonExample = name => {
-            if (name.Contains("_"))
+            if (name.Contains('_'))
                 return FromUnderscoreSeparatedWords(name);
 
             return FromPascalCase(name);
         };
 
-        private static string ExampleTitle(string name)
+        private string ExampleTitle(string name)
         {
             // Compare contains("__") with a regex match
-            string newName = Regex.Replace(name, "__([a-zA-Z][a-zA-Z0-9]*)__", " <$1> ");
+            string newName = TitleCleanerRegex().Replace(name, " <$1> ");
 
             if (newName == name) {
                 throw new ArgumentException("Illegal example title in name '" + name + "'!");
             }
 
             // for when there are two consequetive example placeholders in the word; e.g. Given__one____two__parameters
             newName = newName.Replace("  ", " ");
-            return Convert(newName).Trim();
+            return Humanize(newName).Trim();
         }
+
+        public string Humanize(string input) 
+            => input.Contains("__") ? ExampleTitle(input) : ConvertNonExample(input);
+
+        [GeneratedRegex("__([a-zA-Z][a-zA-Z0-9]*)__")]
+        private static partial Regex TitleCleanerRegex();
     }
-}
+}
diff --git a/src/TestStack.BDDfy/Reporters/TextReporter.cs b/src/TestStack.BDDfy/Reporters/TextReporter.cs
@@ -170,7 +170,7 @@ void ReportOnStep(Scenario scenario, Tuple<Step, string[]> stepAndLines, bool in
             }
 
             var step = stepAndLines.Item1;
-            var humanizedResult = Configurator.Scanners.Humanize(step.Result.ToString());
+            var humanizedResult = Configurator.Humanizer.Humanize(step.Result.ToString());
 
             string message;
             if (scenario.Result == Result.Passed)
diff --git a/src/TestStack.BDDfy/Scanners/ScenarioScanners/FluentScenarioScanner.cs b/src/TestStack.BDDfy/Scanners/ScenarioScanners/FluentScenarioScanner.cs
@@ -38,7 +38,7 @@ private static string GetTitleFromMethodNameInStackTrace(object testObject)
             if (initiatingFrame == null)
                 return null;
 
-            return Configurator.Scanners.Humanize(initiatingFrame.GetMethod().Name);
+            return Configurator.Humanizer.Humanize(initiatingFrame.GetMethod().Name);
 #else
             return null;
 #endif
diff --git a/src/TestStack.BDDfy/Scanners/ScenarioScanners/ReflectiveScenarioScanner.cs b/src/TestStack.BDDfy/Scanners/ScenarioScanners/ReflectiveScenarioScanner.cs
@@ -47,7 +47,7 @@ public virtual IEnumerable<Scenario> Scan(ITestContext testContext)
 
         static string GetScenarioText(Type scenarioType)
         {
-            return Configurator.Scanners.Humanize(scenarioType.Name);
+            return Configurator.Humanizer.Humanize(scenarioType.Name);
         }
 
         protected virtual IEnumerable<Step> ScanScenarioForSteps(ITestContext testContext)
diff --git a/src/TestStack.BDDfy/Scanners/StepScanners/ExecutableAttribute/ExecutableAttributeStepScanner.cs b/src/TestStack.BDDfy/Scanners/StepScanners/ExecutableAttribute/ExecutableAttributeStepScanner.cs
@@ -34,7 +34,7 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo candidateMeth
 
             var stepTitle = new StepTitle(executableAttribute.StepTitle);
             if(string.IsNullOrEmpty(stepTitle))
-                stepTitle = new StepTitle(Configurator.Scanners.Humanize(candidateMethod.Name));
+                stepTitle = new StepTitle(Configurator.Humanizer.Humanize(candidateMethod.Name));
 
             var stepAsserts = IsAssertingByAttribute(candidateMethod);
             var shouldReport = executableAttribute.ShouldReport;
@@ -78,7 +78,7 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo method, Examp
 
             string stepTitle = executableAttribute.StepTitle;
             if (string.IsNullOrEmpty(stepTitle))
-                stepTitle = Configurator.Scanners.Humanize(method.Name);
+                stepTitle = Configurator.Humanizer.Humanize(method.Name);
 
             var stepAsserts = IsAssertingByAttribute(method);
             var shouldReport = executableAttribute.ShouldReport;
diff --git a/src/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs b/src/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs
@@ -190,7 +190,7 @@ private StepTitle CreateTitle(string stepTextTemplate, bool includeInputsInStepT
                             includeInputsInStepTitle = titleAttribute.IncludeInputsInStepTitle.Value;
                     }
 
-                    var stepTitle = AppendPrefix(Configurator.Scanners.Humanize(name), stepPrefix);
+                    var stepTitle = AppendPrefix(Configurator.Humanizer.Humanize(name), stepPrefix);
 
                     if (!string.IsNullOrEmpty(stepTextTemplate)) stepTitle = string.Format(stepTextTemplate, flatInputArray);
                     else if (includeInputsInStepTitle)
diff --git a/src/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs b/src/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs
@@ -135,7 +135,7 @@ private string GetStepTitle(MethodInfo method, object testObject, RunStepWithArg
 
         private string GetStepTitleFromMethodName(MethodInfo method, RunStepWithArgsAttribute argAttribute)
         {
-            var methodName = _stepTextTransformer(Configurator.Scanners.Humanize(method.Name));
+            var methodName = _stepTextTransformer(Configurator.Humanizer.Humanize(method.Name));
             object[] inputs = null;
 
             if (argAttribute != null && argAttribute.InputArguments != null)
diff --git a/src/TestStack.BDDfy/Scanners/StoryMetadata.cs b/src/TestStack.BDDfy/Scanners/StoryMetadata.cs
@@ -11,7 +11,7 @@ public StoryMetadata(Type storyType, StoryNarrativeAttribute narrative)
         }
 
         public Type Type { get; private set; } = storyType;
-        public string Title { get; private set; } = title ?? Configurator.Scanners.Humanize(storyType.Name);
+        public string Title { get; private set; } = title ?? Configurator.Humanizer.Humanize(storyType.Name);
         public string TitlePrefix { get; private set; } = titlePrefix ?? "Story: ";
         public string Narrative1 { get; private set; } = narrative1;
         public string Narrative2 { get; private set; } = narrative2;

Original file line number	Diff line number	Diff line change
`@@ -5,51 +5,53 @@`
`5`	`5`
`6`	`6`	`namespace TestStack.BDDfy.Tests`
`7`	`7`	`{`
`8`		`- public class NetToStringTests`
	`8`	`+ public class DefaultHumanizerTests`
`9`	`9`	`{`
	`10`	`+ private static DefaultHumanizer Humanizer => new();`
	`11`	`+`
`10`	`12`	`[Fact]`
`11`	`13`	`public void PascalCaseInputStringIsTurnedIntoSentence()`
`12`	`14`	`{`
`13`		`- Configurator.Scanners.Humanize("PascalCaseInputStringIsTurnedIntoSentence")`
	`15`	`+ Humanizer.Humanize("PascalCaseInputStringIsTurnedIntoSentence")`
`14`	`16`	`.ShouldBe("Pascal case input string is turned into sentence");`
`15`	`17`	`}`
`16`	`18`
`17`	`19`	`[Fact]`
`18`	`20`	`public void WhenInputStringContainsConsequtiveCaptialLetters_ThenTheyAreTurnedIntoOneLetterWords()`
`19`	`21`	`{`
`20`		`- Configurator.Scanners.Humanize("WhenIUseAnInputAHere").ShouldBe("When I use an input a here");`
	`22`	`+ Humanizer.Humanize("WhenIUseAnInputAHere").ShouldBe("When I use an input a here");`
`21`	`23`	`}`
`22`	`24`
`23`	`25`	`[Fact]`
`24`	`26`	`public void WhenInputStringStartsWithANumber_ThenNumberIsDealtWithLikeAWord()`
`25`	`27`	`{`
`26`		`- Configurator.Scanners.Humanize("10NumberIsInTheBegining").ShouldBe("10 number is in the begining");`
	`28`	`+ Humanizer.Humanize("10NumberIsInTheBegining").ShouldBe("10 number is in the begining");`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`[Fact]`
`30`	`32`	`public void WhenInputStringEndWithANumber_ThenNumberIsDealtWithLikeAWord()`
`31`	`33`	`{`
`32`		`- Configurator.Scanners.Humanize("NumberIsAtTheEnd100").ShouldBe("Number is at the end 100");`
	`34`	`+ Humanizer.Humanize("NumberIsAtTheEnd100").ShouldBe("Number is at the end 100");`
`33`	`35`	`}`
`34`	`36`
`35`	`37`	`[Fact]`
`36`	`38`	`public void UnderscoredInputStringIsTurnedIntoSentence()`
`37`	`39`	`{`
`38`		`- Configurator.Scanners.Humanize("Underscored_input_string_is_turned_into_sentence")`
	`40`	`+ Humanizer.Humanize("Underscored_input_string_is_turned_into_sentence")`
`39`	`41`	`.ShouldBe("Underscored input string is turned into sentence");`
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`[Fact]`
`43`	`45`	`public void UnderscoredInputStringPreservesCasing()`
`44`	`46`	`{`
`45`		`- Configurator.Scanners.Humanize("Underscored_input_String_is_turned_INTO_sentence")`
	`47`	`+ Humanizer.Humanize("Underscored_input_String_is_turned_INTO_sentence")`
`46`	`48`	`.ShouldBe("Underscored input String is turned INTO sentence");`
`47`	`49`	`}`
`48`	`50`
`49`	`51`	`[Fact]`
`50`	`52`	`public void OneLetterWordInTheBeginningOfStringIsTurnedIntoAWord()`
`51`	`53`	`{`
`52`		`- Configurator.Scanners.Humanize("XIsFirstPlayer").ShouldBe("X is first player");`
	`54`	`+ Humanizer.Humanize("XIsFirstPlayer").ShouldBe("X is first player");`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`[Theory]`
`@@ -67,14 +69,14 @@ public void OneLetterWordInTheBeginningOfStringIsTurnedIntoAWord()`
`67`	`69`	`[InlineData("WhenMethodTakes__one__and__two__parameters", "When method takes <one> and <two> parameters")]`
`68`	`70`	`public void CanDealWithExampleStepNames(string stepName, string expectedStepTitle)`
`69`	`71`	`{`
`70`		`- NetToString.Convert(stepName).ShouldBe(expectedStepTitle);`
	`72`	`+ Humanizer.Humanize(stepName).ShouldBe(expectedStepTitle);`
`71`	`73`	`}`
`72`	`74`
`73`	`75`	`[Theory]`
`74`	`76`	`[InlineData("GivenThereAre__två__Cucumbers", "Given there are <två> cucumbers")]`
`75`	`77`	`public void ReportsIllegalExampleStepNames(string stepName, string expectedStepTitle) {`
`76`	`78`	`var exception = Record.Exception(() => {`
`77`		`- NetToString.Convert(stepName).ShouldBe(expectedStepTitle);`
	`79`	`+ Humanizer.Humanize(stepName).ShouldBe(expectedStepTitle);`
`78`	`80`	`});`
`79`	`81`
`80`	`82`	`exception.ShouldNotBeNull();`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ public void WhenTitleIsNotProvidedItIsFetchedFromMethodName()`
`279`	`279`	`.BDDfy();`
`280`	`280`
`281`	`281`	`var scenario = story.Scenarios.First();`
`282`		`- scenario.Title.ShouldBe(Configurator.Scanners.Humanize(nameof(WhenTitleIsNotProvidedItIsFetchedFromMethodName)));`
	`282`	`+ scenario.Title.ShouldBe(Configurator.Humanizer.Humanize(nameof(WhenTitleIsNotProvidedItIsFetchedFromMethodName)));`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -125,15 +125,15 @@ public void LegacyConsecutiveAssertionStepIsScanned()`
`125`	`125`
`126`	`126`	`void VerifyStepAndItsProperties(Expression<Action> stepMethodAction, ExecutionOrder expectedOrder, int expectedCount = 1)`
`127`	`127`	`{`
`128`		`- var matchingSteps = _scenario.Steps.Where(s => s.Title.Trim() == Configurator.Scanners.Humanize(Helpers.GetMethodInfo(stepMethodAction).Name));`
	`128`	`+ var matchingSteps = _scenario.Steps.Where(s => s.Title.Trim() == Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(stepMethodAction).Name));`
`129`	`129`	`matchingSteps.Count().ShouldBe(expectedCount);`
`130`	`130`	`matchingSteps.All(s => s.ExecutionOrder == expectedOrder).ShouldBe(true);`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`[Fact]`
`134`	`134`	`public void IgnoredMethodShouldNotBeAddedToSteps()`
`135`	`135`	`{`
`136`		`- var matchingSteps = _scenario.Steps.Where(s => s.Title == Configurator.Scanners.Humanize(Helpers.GetMethodInfo(() => _sut.ThenIAmNotAStep()).Name));`
	`136`	`+ var matchingSteps = _scenario.Steps.Where(s => s.Title == Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(() => _sut.ThenIAmNotAStep()).Name));`
`137`	`137`	`matchingSteps.ShouldBeEmpty();`
`138`	`138`	`}`
`139`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public void IncorrectSpecificationStepIsNotAdded()`
`89`	`89`
`90`	`90`	`void AssertSpecificationStepIsScannedProperly(Expression<Action> getSpecMethod)`
`91`	`91`	`{`
`92`		`- var specMethods = _steps.Where(s => s.Title.Trim() == Configurator.Scanners.Humanize(Helpers.GetMethodInfo(getSpecMethod).Name));`
	`92`	`+ var specMethods = _steps.Where(s => s.Title.Trim() == Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(getSpecMethod).Name));`
`93`	`93`	`specMethods.Count().ShouldBe(1);`
`94`	`94`	`var specStep = specMethods.First();`
`95`	`95`	`specStep.Asserts.ShouldBe(false);`
Original file line number	Diff line number	Diff line change
`@@ -41,15 +41,15 @@ Scenario Scenario`
`41`	`41`	`[RunStepWithArgs("ThenInTheBaseClass")]`
`42`	`42`	`void ThenTheFollowingStepFromBaseClassIsScanned(string stepName)`
`43`	`43`	`{`
`44`		`- Scenario.Steps.Count(s => s.Title == Configurator.Scanners.Humanize(stepName)).ShouldBe(1);`
	`44`	`+ Scenario.Steps.Count(s => s.Title == Configurator.Humanizer.Humanize(stepName)).ShouldBe(1);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`[RunStepWithArgs("GivenInTheSubClass")]`
`48`	`48`	`[RunStepWithArgs("WhenInTheSubClass")]`
`49`	`49`	`[RunStepWithArgs("ThenInTheSubClass")]`
`50`	`50`	`void ThenTheFollowingStepFromSubClassScanned(string stepName)`
`51`	`51`	`{`
`52`		`- Scenario.Steps.Count(s => s.Title == Configurator.Scanners.Humanize(stepName)).ShouldBe(1);`
	`52`	`+ Scenario.Steps.Count(s => s.Title == Configurator.Humanizer.Humanize(stepName)).ShouldBe(1);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public WhenTestClassUsesExecutableAttributes()`
`68`	`68`
`69`	`69`	`private static string GetStepTextFromMethodName(Expression<Action> methodInfoAction)`
`70`	`70`	`{`
`71`		`- return Configurator.Scanners.Humanize(Helpers.GetMethodInfo(methodInfoAction).Name);`
	`71`	`+ return Configurator.Humanizer.Humanize(Helpers.GetMethodInfo(methodInfoAction).Name);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,12 @@ public static Engine LazyBDDfy<TStory>(this object testObject, string scenarioTi`
`52`	`52`	`/// <returns></returns>`
`53`	`53`	`public static Story BDDfy(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)`
`54`	`54`	`{`
`55`		`- return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller)).Run();`
	`55`	`+ return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller)).Run();`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`public static Engine LazyBDDfy(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)`
`59`	`59`	`{`
`60`		`- return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller));`
	`60`	`+ return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller));`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`/// <summary>`
`@@ -71,13 +71,13 @@ public static Engine LazyBDDfy(this object testObject, string scenarioTitle = nu`
`71`	`71`	`public static Story BDDfy<TStory>(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)`
`72`	`72`	`where TStory : class`
`73`	`73`	`{`
`74`		`- return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller), typeof(TStory)).Run();`
	`74`	`+ return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller), typeof(TStory)).Run();`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`public static Engine LazyBDDfy<TStory>(this object testObject, string scenarioTitle = null, [System.Runtime.CompilerServices.CallerMemberName] string caller = null)`
`78`	`78`	`where TStory : class`
`79`	`79`	`{`
`80`		`- return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Scanners.Humanize(caller), typeof(TStory));`
	`80`	`+ return InternalLazyBDDfy(testObject, scenarioTitle ?? Configurator.Humanizer.Humanize(caller), typeof(TStory));`
`81`	`81`	`}`
`82`	`82`	`#endif`
`83`	`83`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,5 @@ public IEnumerable<IStepScanner> GetStepScanners(object objectUnderTest)`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public Func<IStoryMetadataScanner> StoryMetadataScanner = () => new StoryAttributeMetadataScanner();`
`38`		`-`
`39`		`- public Func<string, string> Humanize = NetToString.Convert;`
`40`	`38`	`}`
`41`	`39`	`}`