Merge pull request #119 from TestStack/nettostring

JakeGinnivan · JakeGinnivan · commit 9107453fafc7 · 2014-04-28T14:28:26.000+01:00
NetToString clean up and bug fixes
diff --git a/.gitignore b/.gitignore
@@ -3,7 +3,6 @@ bin/
 obj/
 *.user
 *.suo
-*.DotSettings
 *~
 *.swp
 *.orig
diff --git a/TestStack.BDDfy.Tests/NetToStringTests.cs b/TestStack.BDDfy.Tests/NetToStringTests.cs
@@ -5,13 +5,13 @@
 namespace TestStack.BDDfy.Tests
 {
     [TestFixture]
-    public class HumanizerTests
+    public class NetToStringTests
     {
         [Test]
         public void PascalCaseInputStringIsTurnedIntoSentence()
         {
             Assert.That(
-                Configurator.Scanners.Humanize("PascalCaseInputStringIsTurnedIntoSentence"), 
+                Configurator.Scanners.Humanize("PascalCaseInputStringIsTurnedIntoSentence"),
                 Is.EqualTo("Pascal case input string is turned into sentence"));
         }
 
@@ -37,32 +37,37 @@ public void WhenInputStringEndWithANumber_ThenNumberIsDealtWithLikeAWord()
         public void UnderscoredInputStringIsTurnedIntoSentence()
         {
             Assert.That(
-                Configurator.Scanners.Humanize("Underscored_input_string_is_turned_into_sentence"), 
+                Configurator.Scanners.Humanize("Underscored_input_string_is_turned_into_sentence"),
                 Is.EqualTo("Underscored input string is turned into sentence"));
         }
 
         [Test]
         public void UnderscoredInputStringPreservesCasing()
         {
             Assert.That(
-                Configurator.Scanners.Humanize("Underscored_input_String_is_turned_INTO_sentence"), 
+                Configurator.Scanners.Humanize("Underscored_input_String_is_turned_INTO_sentence"),
                 Is.EqualTo("Underscored input String is turned INTO sentence"));
         }
 
         [Test]
         public void OneLetterWordInTheBeginningOfStringIsTurnedIntoAWord()
         {
-            Assert.That(
-                Configurator.Scanners.Humanize("XIsFirstPlayer"),
-                Is.EqualTo("X is first player"));
+            Assert.That(Configurator.Scanners.Humanize("XIsFirstPlayer"), Is.EqualTo("X is first player"));
         }
 
-        [Test]
-        public void CanDealWithExampleStepNames()
+        [TestCase("GivenThereAre__start__Cucumbers", "Given there are <start> cucumbers")]
+        [TestCase("Given_there_are__start__cucumbers", "Given there are <start> cucumbers")]
+        [TestCase("GivenMethodTaking__ExampleInt__", "Given method taking <example int>")]
+        [TestCase("Given_method_taking__ExampleInt__", "Given method taking <ExampleInt>")]
+        [TestCase("__starting__with_example", "<starting> with example")]
+        [TestCase("__starting__WithExample", "<starting> with example")]
+        [TestCase("WhenMethod__takes____two__parameters", "When method <takes> <two> parameters")]
+        [TestCase("When_method__takes____two__parameters", "When method <takes> <two> parameters")]
+        [TestCase("When_method_takes__one__and__two__parameters", "When method takes <one> and <two> parameters")]
+        [TestCase("WhenMethodTakes__one__and__two__parameters", "When method takes <one> and <two> parameters")]
+        public void CanDealWithExampleStepNames(string stepName, string expectedStepTitle)
         {
-            NetToString.Convert("GivenThereAre__start__Cucumbers").ShouldBe("Given there are <start> cucumbers");
-            NetToString.Convert("Given_there_are__start__cucumbers").ShouldBe("Given there are <start> cucumbers");
-            NetToString.Convert("GivenMethodTaking__ExampleInt__").ShouldBe("Given method taking <example int>");
+            NetToString.Convert(stepName).ShouldBe(expectedStepTitle, Case.Sensitive);
         }
     }
 }
diff --git a/TestStack.BDDfy.Tests/TestStack.BDDfy.Tests.csproj b/TestStack.BDDfy.Tests/TestStack.BDDfy.Tests.csproj
@@ -104,7 +104,7 @@
     <Compile Include="Scanner\FluentScanner\WhenStepsAreScannedUsingFluentScanner.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="HumanizerTests.cs" />
+    <Compile Include="NetToStringTests.cs" />
     <Compile Include="Reporters\Diagnostics\DiagnosticsReportBuilderTests.cs" />
     <Compile Include="Reporters\Diagnostics\WhenBuildingReportDiagnostics.cs" />
     <Compile Include="Reporters\Diagnostics\DiagnosticsReporterTests.cs" />
diff --git a/TestStack.BDDfy/NetToString.cs b/TestStack.BDDfy/NetToString.cs
@@ -14,52 +14,59 @@ static string FromPascalCase(string name)
                 new List<char>(), 
                 (list, currentChar) =>
                     {
-                        if (currentChar == ' ')
-                        {
-                            list.Add(currentChar);
-                            return list;
-                        }
-
-                        if(list.Count == 0)
-                        {
+                        if (currentChar == ' ' || list.Count == 0)
                             list.Add(currentChar);
-                            return list;
-                        }
-
-                        var lastCharacterInTheList = list[list.Count - 1];
-                        if (lastCharacterInTheList != ' ')
+                        else
                         {
-                            if(char.IsDigit(lastCharacterInTheList))
-                            {
-                                if (char.IsLetter(currentChar))
-                                    list.Add(' ');
-                            }
-                            else if (!char.IsLower(currentChar))
+                            if(ShouldAddSpace(list[list.Count - 1], currentChar))
                                 list.Add(' ');
+                            list.Add(char.ToLower(currentChar));
                         }
 
-                        list.Add(char.ToLower(currentChar));
-
                         return list;
                     });
 
             var result = new string(chars.ToArray());
             return result.Replace(" i ", " I "); // I is an exception
         }
 
-        public static readonly Func<string, string> Convert = name =>
+        private static bool ShouldAddSpace(char lastChar, char currentChar)
         {
-            if (name.Contains("__"))
+            if (lastChar == ' ') 
+                return false;
+
+            if (char.IsDigit(lastChar))
             {
-                // hacking the crap out of it for now
-                name = Regex.Replace(name, "__(\\w+)__", " <$1> ");
-                return FromPascalCase(name).Replace("_", "").Replace(" >", ">").Replace("< ", "<").TrimEnd();
+                if (char.IsLetter(currentChar))
+                    return true;
+
+                return false;
             }
 
+            if (!char.IsLower(currentChar) && currentChar != '>' && lastChar != '<')
+                return true;
+
+            return false;
+        }
+
+        public static readonly Func<string, string> Convert = name =>
+        {
+            if (name.Contains("__"))
+                return ExampleTitle(name);
+
             if (name.Contains("_"))
                 return FromUnderscoreSeparatedWords(name);
 
             return FromPascalCase(name);
         };
+
+        private static string ExampleTitle(string name)
+        {
+            name = Regex.Replace(name, "__([a-zA-Z]+)__", " <$1> ");
+
+            // for when there are two consequetive example placeholders in the word; e.g. Given__one____two__parameters
+            name = name.Replace("  ", " ");
+            return Convert(name).Trim();
+        }
     }
 }
diff --git a/TestStack.BDDfy/Scanners/ScenarioScanners/FluentScenarioScanner.cs b/TestStack.BDDfy/Scanners/ScenarioScanners/FluentScenarioScanner.cs
@@ -45,7 +45,7 @@ private static string GetTitleFromMethodNameInStackTrace(object testObject)
             if (initiatingFrame == null)
                 return null;
 
-            return NetToString.Convert(initiatingFrame.GetMethod().Name);
+            return Configurator.Scanners.Humanize(initiatingFrame.GetMethod().Name);
         }
     }
 }
diff --git a/TestStack.BDDfy/Scanners/ScenarioScanners/ReflectiveScenarioScanner.cs b/TestStack.BDDfy/Scanners/ScenarioScanners/ReflectiveScenarioScanner.cs
@@ -51,7 +51,7 @@ public virtual IEnumerable<Scenario> Scan(ITestContext testContext)
 
         static string GetScenarioText(Type scenarioType)
         {
-            return NetToString.Convert(scenarioType.Name);
+            return Configurator.Scanners.Humanize(scenarioType.Name);
         }
 
         protected virtual IEnumerable<Step> ScanScenarioForSteps(ITestContext testContext)
diff --git a/TestStack.BDDfy/Scanners/StepScanners/ExecutableAttribute/ExecutableAttributeStepScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/ExecutableAttribute/ExecutableAttributeStepScanner.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;
+using TestStack.BDDfy.Configuration;
 
 namespace TestStack.BDDfy
 {
@@ -33,7 +34,7 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo candidateMeth
 
             var stepTitle = new StepTitle(executableAttribute.StepTitle);
             if(string.IsNullOrEmpty(stepTitle))
-                stepTitle = new StepTitle(NetToString.Convert(candidateMethod.Name));
+                stepTitle = new StepTitle(Configurator.Scanners.Humanize(candidateMethod.Name));
 
             var stepAsserts = IsAssertingByAttribute(candidateMethod);
 
@@ -76,7 +77,7 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo method, Examp
 
             string stepTitle = executableAttribute.StepTitle;
             if (string.IsNullOrEmpty(stepTitle))
-                stepTitle = NetToString.Convert(method.Name);
+                stepTitle = Configurator.Scanners.Humanize(method.Name);
 
             var stepAsserts = IsAssertingByAttribute(method);
             var methodParameters = method.GetParameters();
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs
@@ -4,6 +4,7 @@
 using System.Reflection;
 using System.Linq;
 using System.Threading.Tasks;
+using TestStack.BDDfy.Configuration;
 
 namespace TestStack.BDDfy
 {
@@ -136,7 +137,7 @@ private StepTitle CreateTitle(string stepTextTemplate, bool includeInputsInStepT
                 {
 
                     var flatInputArray = inputArguments.FlattenArrays();
-                    var stepTitle = NetToString.Convert(methodInfo.Name);
+                    var stepTitle = Configurator.Scanners.Humanize(methodInfo.Name);
 
                     if (!string.IsNullOrEmpty(stepTextTemplate)) stepTitle = string.Format(stepTextTemplate, flatInputArray);
                     else if (includeInputsInStepTitle)
diff --git a/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Reflection;
 using System.Linq;
+using TestStack.BDDfy.Configuration;
 
 namespace TestStack.BDDfy
 {
@@ -122,7 +123,7 @@ private string GetStepTitle(MethodInfo method, object testObject, RunStepWithArg
 
         private string GetStepTitleFromMethodName(MethodInfo method, RunStepWithArgsAttribute argAttribute)
         {
-            var methodName = _stepTextTransformer(NetToString.Convert(method.Name));
+            var methodName = _stepTextTransformer(Configurator.Scanners.Humanize(method.Name));
             object[] inputs = null;
 
             if (argAttribute != null && argAttribute.InputArguments != null)
diff --git a/TestStack.BDDfy/Scanners/StoryMetadata.cs b/TestStack.BDDfy/Scanners/StoryMetadata.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using TestStack.BDDfy.Configuration;
 
 namespace TestStack.BDDfy
 {
@@ -11,7 +12,7 @@ public StoryMetadata(Type storyType, StoryNarrativeAttribute narrative)
 
         public StoryMetadata(Type storyType, string narrative1, string narrative2, string narrative3, string title = null, string titlePrefix = null)
         {
-            Title = title ?? NetToString.Convert(storyType.Name);
+            Title = title ?? Configurator.Scanners.Humanize(storyType.Name);
             TitlePrefix = titlePrefix ?? "Story: ";
             Type = storyType;
 
diff --git a/TestStack.BDDfy/TestStack.BDDfy.csproj.DotSettings b/TestStack.BDDfy/TestStack.BDDfy.csproj.DotSettings
@@ -0,0 +1,9 @@
+﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CScenarioScanners/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CStepScanners/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CStepScanners_005CExamples/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CStepScanners_005CExecutableAttribute/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CStepScanners_005CExecutableAttribute_005CGwtAttributes/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CStepScanners_005CFluent/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Scanners_005CStepScanners_005CMethodName/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

-Original file line number
+Diff line change
 obj/
 *.user
 *.suo
 -*.DotSettings
 *~
 *.swp
 *.orig
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`	`namespace TestStack.BDDfy.Tests`
`6`	`6`	`{`
`7`	`7`	`[TestFixture]`
`8`		`- public class HumanizerTests`
	`8`	`+ public class NetToStringTests`
`9`	`9`	`{`
`10`	`10`	`[Test]`
`11`	`11`	`public void PascalCaseInputStringIsTurnedIntoSentence()`
`12`	`12`	`{`
`13`	`13`	`Assert.That(`
`14`		`- Configurator.Scanners.Humanize("PascalCaseInputStringIsTurnedIntoSentence"),`
	`14`	`+ Configurator.Scanners.Humanize("PascalCaseInputStringIsTurnedIntoSentence"),`
`15`	`15`	`Is.EqualTo("Pascal case input string is turned into sentence"));`
`16`	`16`	`}`
`17`	`17`
`@@ -37,32 +37,37 @@ public void WhenInputStringEndWithANumber_ThenNumberIsDealtWithLikeAWord()`
`37`	`37`	`public void UnderscoredInputStringIsTurnedIntoSentence()`
`38`	`38`	`{`
`39`	`39`	`Assert.That(`
`40`		`- Configurator.Scanners.Humanize("Underscored_input_string_is_turned_into_sentence"),`
	`40`	`+ Configurator.Scanners.Humanize("Underscored_input_string_is_turned_into_sentence"),`
`41`	`41`	`Is.EqualTo("Underscored input string is turned into sentence"));`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`[Test]`
`45`	`45`	`public void UnderscoredInputStringPreservesCasing()`
`46`	`46`	`{`
`47`	`47`	`Assert.That(`
`48`		`- Configurator.Scanners.Humanize("Underscored_input_String_is_turned_INTO_sentence"),`
	`48`	`+ Configurator.Scanners.Humanize("Underscored_input_String_is_turned_INTO_sentence"),`
`49`	`49`	`Is.EqualTo("Underscored input String is turned INTO sentence"));`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`[Test]`
`53`	`53`	`public void OneLetterWordInTheBeginningOfStringIsTurnedIntoAWord()`
`54`	`54`	`{`
`55`		`- Assert.That(`
`56`		`- Configurator.Scanners.Humanize("XIsFirstPlayer"),`
`57`		`- Is.EqualTo("X is first player"));`
	`55`	`+ Assert.That(Configurator.Scanners.Humanize("XIsFirstPlayer"), Is.EqualTo("X is first player"));`
`58`	`56`	`}`
`59`	`57`
`60`		`- [Test]`
`61`		`- public void CanDealWithExampleStepNames()`
	`58`	`+ [TestCase("GivenThereAre__start__Cucumbers", "Given there are <start> cucumbers")]`
	`59`	`+ [TestCase("Given_there_are__start__cucumbers", "Given there are <start> cucumbers")]`
	`60`	`+ [TestCase("GivenMethodTaking__ExampleInt__", "Given method taking <example int>")]`
	`61`	`+ [TestCase("Given_method_taking__ExampleInt__", "Given method taking <ExampleInt>")]`
	`62`	`+ [TestCase("__starting__with_example", "<starting> with example")]`
	`63`	`+ [TestCase("__starting__WithExample", "<starting> with example")]`
	`64`	`+ [TestCase("WhenMethod__takes____two__parameters", "When method <takes> <two> parameters")]`
	`65`	`+ [TestCase("When_method__takes____two__parameters", "When method <takes> <two> parameters")]`
	`66`	`+ [TestCase("When_method_takes__one__and__two__parameters", "When method takes <one> and <two> parameters")]`
	`67`	`+ [TestCase("WhenMethodTakes__one__and__two__parameters", "When method takes <one> and <two> parameters")]`
	`68`	`+ public void CanDealWithExampleStepNames(string stepName, string expectedStepTitle)`
`62`	`69`	`{`
`63`		`- NetToString.Convert("GivenThereAre__start__Cucumbers").ShouldBe("Given there are <start> cucumbers");`
`64`		`- NetToString.Convert("Given_there_are__start__cucumbers").ShouldBe("Given there are <start> cucumbers");`
`65`		`- NetToString.Convert("GivenMethodTaking__ExampleInt__").ShouldBe("Given method taking <example int>");`
	`70`	`+ NetToString.Convert(stepName).ShouldBe(expectedStepTitle, Case.Sensitive);`
`66`	`71`	`}`
`67`	`72`	`}`
`68`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ private static string GetTitleFromMethodNameInStackTrace(object testObject)`
`45`	`45`	`if (initiatingFrame == null)`
`46`	`46`	`return null;`
`47`	`47`
`48`		`- return NetToString.Convert(initiatingFrame.GetMethod().Name);`
	`48`	`+ return Configurator.Scanners.Humanize(initiatingFrame.GetMethod().Name);`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public virtual IEnumerable<Scenario> Scan(ITestContext testContext)`
`51`	`51`
`52`	`52`	`static string GetScenarioText(Type scenarioType)`
`53`	`53`	`{`
`54`		`- return NetToString.Convert(scenarioType.Name);`
	`54`	`+ return Configurator.Scanners.Humanize(scenarioType.Name);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`protected virtual IEnumerable<Step> ScanScenarioForSteps(ITestContext testContext)`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using System.Linq;`
`6`	`6`	`using System.Threading.Tasks;`
	`7`	`+using TestStack.BDDfy.Configuration;`
`7`	`8`
`8`	`9`	`namespace TestStack.BDDfy`
`9`	`10`	`{`
`@@ -136,7 +137,7 @@ private StepTitle CreateTitle(string stepTextTemplate, bool includeInputsInStepT`
`136`	`137`	`{`
`137`	`138`
`138`	`139`	`var flatInputArray = inputArguments.FlattenArrays();`
`139`		`- var stepTitle = NetToString.Convert(methodInfo.Name);`
	`140`	`+ var stepTitle = Configurator.Scanners.Humanize(methodInfo.Name);`
`140`	`141`
`141`	`142`	`if (!string.IsNullOrEmpty(stepTextTemplate)) stepTitle = string.Format(stepTextTemplate, flatInputArray);`
`142`	`143`	`else if (includeInputsInStepTitle)`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Reflection;`
`4`	`4`	`using System.Linq;`
	`5`	`+using TestStack.BDDfy.Configuration;`
`5`	`6`
`6`	`7`	`namespace TestStack.BDDfy`
`7`	`8`	`{`
`@@ -122,7 +123,7 @@ private string GetStepTitle(MethodInfo method, object testObject, RunStepWithArg`
`122`	`123`
`123`	`124`	`private string GetStepTitleFromMethodName(MethodInfo method, RunStepWithArgsAttribute argAttribute)`
`124`	`125`	`{`
`125`		`- var methodName = _stepTextTransformer(NetToString.Convert(method.Name));`
	`126`	`+ var methodName = _stepTextTransformer(Configurator.Scanners.Humanize(method.Name));`
`126`	`127`	`object[] inputs = null;`
`127`	`128`
`128`	`129`	`if (argAttribute != null && argAttribute.InputArguments != null)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using TestStack.BDDfy.Configuration;`
`2`	`3`
`3`	`4`	`namespace TestStack.BDDfy`
`4`	`5`	`{`
`@@ -11,7 +12,7 @@ public StoryMetadata(Type storyType, StoryNarrativeAttribute narrative)`
`11`	`12`
`12`	`13`	`public StoryMetadata(Type storyType, string narrative1, string narrative2, string narrative3, string title = null, string titlePrefix = null)`
`13`	`14`	`{`
`14`		`- Title = title ?? NetToString.Convert(storyType.Name);`
	`15`	`+ Title = title ?? Configurator.Scanners.Humanize(storyType.Name);`
`15`	`16`	`TitlePrefix = titlePrefix ?? "Story: ";`
`16`	`17`	`Type = storyType;`
`17`	`18`