Cucumber expressions support

TechTalk.SpecFlow.sln

@@ -18,6 +18,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		LICENSE.txt = LICENSE.txt
 		nuget.config = nuget.config
 		README.md = README.md
+		specflow-config.json = specflow-config.json
 		TechTalk.SpecFlow.sln.DotSettings = TechTalk.SpecFlow.sln.DotSettings
 		version.json = version.json
 	EndProjectSection

TechTalk.SpecFlow/BindingSkeletons/DefaultSkeletonTemplates.sftemplate

@@ -16,8 +16,8 @@ namespace {namespace}
 {bindings}
     }
 }
->>>CSharp/StepDefinitionRegex
-[{attribute}(@"{regex}")]
+>>>CSharp/StepDefinitionExpression
+[{attribute}({expression})]
 public void {methodName}({parameters})
 {
     _scenarioContext.Pending();
@@ -26,7 +26,7 @@ public void {methodName}({parameters})
 [{attribute}]
 public void {methodName}({parameters})
 {
-    _scenarioContext .Pending();
+    _scenarioContext.Pending();
 }
 >>>VB/StepDefinitionClass
 Imports System
@@ -42,8 +42,8 @@ Namespace {namespace}
     End Class
 
 End Namespace
->>>VB/StepDefinitionRegex
-<TechTalk.SpecFlow.{attribute}("{regex}")> _
+>>>VB/StepDefinitionExpression
+<TechTalk.SpecFlow.{attribute}({expression})> _
 Public Sub {methodName}({parameters})
     ScenarioContext.Current.Pending()
 End Sub
@@ -59,7 +59,7 @@ module {className}
 open TechTalk.SpecFlow
 
 {bindings}
->>>FSharp/StepDefinitionRegex
-let [<{attribute}(@"{regex}")>] {methodName}({parameters}) = ()
+>>>FSharp/StepDefinitionExpression
+let [<{attribute}({expression}>] {methodName}({parameters}) = ()
 >>>FSharp/StepDefinition
 let [<{attribute}>] {methodName}({parameters}) = ()

TechTalk.SpecFlow/BindingSkeletons/FileBasedSkeletonTemplateProvider.cs

@@ -45,9 +45,9 @@ protected internal virtual string GetTemplate(string key)
             return template;
         }
 
-        public string GetStepDefinitionTemplate(ProgrammingLanguage language, bool withRegex)
+        public string GetStepDefinitionTemplate(ProgrammingLanguage language, bool withExpression)
         {
-            string key = $"{language}/StepDefinition{(withRegex ? "Regex" : "")}";
+            string key = $"{language}/StepDefinition{(withExpression ? "Expression" : "")}";
             string template = GetTemplate(key);
             if (template == null)
                 return MissingTemplate(key);

TechTalk.SpecFlow/BindingSkeletons/ISkeletonTemplateProvider.cs

@@ -2,7 +2,7 @@ namespace TechTalk.SpecFlow.BindingSkeletons
 {
     public interface ISkeletonTemplateProvider
     {
-        string GetStepDefinitionTemplate(ProgrammingLanguage language, bool withRegex);
+        string GetStepDefinitionTemplate(ProgrammingLanguage language, bool withExpression);
         string GetStepDefinitionClassTemplate(ProgrammingLanguage language);
     }
 }

TechTalk.SpecFlow/BindingSkeletons/StepDefinitionSkeletonProvider.cs

@@ -46,19 +46,50 @@ private static IEnumerable<StepInstance> GetOrderedSteps(StepInstance[] stepInst
 
         public virtual string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
         {
-            var withRegex = style == StepDefinitionSkeletonStyle.RegexAttribute;
-            var template = templateProvider.GetStepDefinitionTemplate(language, withRegex);
+            var withExpression = style == StepDefinitionSkeletonStyle.RegexAttribute || style == StepDefinitionSkeletonStyle.CucumberExpressionAttribute;
+            var template = templateProvider.GetStepDefinitionTemplate(language, withExpression);
             var analyzedStepText = Analyze(stepInstance, bindingCulture);
             //{attribute}/{regex}/{methodName}/{parameters}
             return ApplyTemplate(template, new
                                                {
                                                    attribute = stepInstance.StepDefinitionType,
-                                                   regex = withRegex ? GetRegex(analyzedStepText) : "",
+                                                   expression = withExpression ? GetExpression(analyzedStepText, style, language) : "",
                                                    methodName = GetMethodName(stepInstance, analyzedStepText, style, language),
                                                    parameters = string.Join(", ", analyzedStepText.Parameters.Select(p => ToDeclaration(language, p)).ToArray())
                                                });
         }
 
+        private string GetExpression(AnalyzedStepText analyzedStepText, StepDefinitionSkeletonStyle style, ProgrammingLanguage programmingLanguage)
+        {
+            switch (style)
+            {
+                case StepDefinitionSkeletonStyle.RegexAttribute:
+                    var regex = GetRegex(analyzedStepText);
+                    var stringPrefix = programmingLanguage == ProgrammingLanguage.VB ? "" : "@";
+                    return $"{stringPrefix}\"{regex}\"";
+                case StepDefinitionSkeletonStyle.CucumberExpressionAttribute:
+                    var cucumberExpression = GetCucumberExpression(analyzedStepText);
+                    return $"\"{cucumberExpression}\"";
+                default: 
+                    return "";
+            }
+        }
+
+        private string GetCucumberExpression(AnalyzedStepText stepText)
+        {
+            StringBuilder result = new StringBuilder();
+
+            result.Append(EscapeRegex(stepText.TextParts[0]));
+            for (int i = 1; i < stepText.TextParts.Count; i++)
+            {
+                var parameter = stepText.Parameters[i - 1];
+                result.AppendFormat("{{{0}}}", parameter.CucumberExpressionTypeName ?? parameter.Type);
+                result.Append(EscapeRegex(stepText.TextParts[i]));
+            }
+
+            return result.ToString();
+        }
+
         private AnalyzedStepText Analyze(StepInstance stepInstance, CultureInfo bindingCulture)
         {
             var result = stepTextAnalyzer.Analyze(stepInstance.Text, bindingCulture);
@@ -81,6 +112,7 @@ private string GetMethodName(StepInstance stepInstance, AnalyzedStepText analyze
             switch (style)
             {
                 case StepDefinitionSkeletonStyle.RegexAttribute:
+                case StepDefinitionSkeletonStyle.CucumberExpressionAttribute:
                     return keyword.ToIdentifier() + string.Concat(analyzedStepText.TextParts.ToArray()).ToIdentifier();
                 case StepDefinitionSkeletonStyle.MethodNameUnderscores:
                     return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsUnderscored, "_{0}");
@@ -134,12 +166,15 @@ private string GetRegex(AnalyzedStepText stepText)
         {
             StringBuilder result = new StringBuilder();
 
+            result.Append("^");
             result.Append(EscapeRegex(stepText.TextParts[0]));
             for (int i = 1; i < stepText.TextParts.Count; i++)
             {
-                result.AppendFormat("({0})", stepText.Parameters[i-1].RegexPattern);
+                var parameter = stepText.Parameters[i - 1];
+                result.Append($"{parameter.WrapText}({parameter.RegexPattern}){parameter.WrapText}");
                 result.Append(EscapeRegex(stepText.TextParts[i]));
             }
+            result.Append("$");
 
             return result.ToString();
         }

TechTalk.SpecFlow/BindingSkeletons/StepDefinitionSkeletonStyle.cs

@@ -11,6 +11,8 @@ public enum StepDefinitionSkeletonStyle
         [Description("Method name - pascal case")]
         MethodNamePascalCase = 2,
         [Description("Method name as regulare expression (F#)")]
-        MethodNameRegex = 3
+        MethodNameRegex = 3,
+        [Description("Cucumber expressions in attributes")]
+        CucumberExpressionAttribute = 4,
     }
 }

TechTalk.SpecFlow/BindingSkeletons/StepTextAnalyzer.cs

@@ -17,12 +17,16 @@ public class AnalyzedStepParameter
         public readonly string Type;
         public readonly string Name;
         public readonly string RegexPattern;
+        public readonly string WrapText;
+        public readonly string CucumberExpressionTypeName;
 
-        public AnalyzedStepParameter(string type, string name, string regexPattern = null)
+        public AnalyzedStepParameter(string type, string name, string regexPattern = null, string cucumberExpressionTypeName = null, string wrapText = "")
         {
-            this.Type = type;
-            this.Name = name;
-            this.RegexPattern = regexPattern;
+            Type = type;
+            Name = name;
+            RegexPattern = regexPattern;
+            CucumberExpressionTypeName = cucumberExpressionTypeName;
+            WrapText = wrapText;
         }
     }
 
@@ -52,54 +56,55 @@ public AnalyzedStepText Analyze(string stepText, CultureInfo bindingCulture)
                 if (paramMatch.Capture.Index < textIndex)
                     continue;
 
-                const string singleQuoteRegexPattern = "[^']*";
-                const string doubleQuoteRegexPattern = "[^\"\"]*";
+                const string singleQuoteRegexPattern = ".*"; // earlier it was "[^']*"
+                const string doubleQuoteRegexPattern = ".*"; // earlier it was "[^\"\"]*"
                 const string defaultRegexPattern = ".*";
 
                 string regexPattern = defaultRegexPattern;
                 string value = paramMatch.Capture.Value;
                 int index = paramMatch.Capture.Index;
+                string wrapText = "";
 
                 switch (value.Substring(0, Math.Min(value.Length, 1)))
                 {
                     case "\"":
                         regexPattern = doubleQuoteRegexPattern;
                         value = value.Substring(1, value.Length - 2);
-                        index++;
+                        wrapText = "\"";
                         break;
                     case "'":
                         regexPattern = singleQuoteRegexPattern;
                         value = value.Substring(1, value.Length - 2);
-                        index++;
+                        wrapText = "'";
                         break;
                 }
 
                 result.TextParts.Add(stepText.Substring(textIndex, index - textIndex));
-                result.Parameters.Add(AnalyzeParameter(value, bindingCulture, result.Parameters.Count, regexPattern, paramMatch.ParameterType));
-                textIndex = index + value.Length;
+                result.Parameters.Add(AnalyzeParameter(value, bindingCulture, result.Parameters.Count, regexPattern, paramMatch.ParameterType, wrapText));
+                textIndex = index + paramMatch.Capture.Length;
             }
 
             result.TextParts.Add(stepText.Substring(textIndex));
             return result;
         }
 
-        private AnalyzedStepParameter AnalyzeParameter(string value, CultureInfo bindingCulture, int paramIndex, string regexPattern, ParameterType parameterType)
+        private AnalyzedStepParameter AnalyzeParameter(string value, CultureInfo bindingCulture, int paramIndex, string regexPattern, ParameterType parameterType, string wrapText)
         {
             string paramName = StepParameterNameGenerator.GenerateParameterName(value, paramIndex, usedParameterNames);
 
             if (parameterType == ParameterType.Int && int.TryParse(value, NumberStyles.Integer, bindingCulture, out _))
-                return new AnalyzedStepParameter("Int32", paramName, regexPattern);
+                return new AnalyzedStepParameter("Int32", paramName, regexPattern, "int", wrapText);
 
             if (parameterType == ParameterType.Decimal && decimal.TryParse(value, NumberStyles.Number, bindingCulture, out _))
-                return new AnalyzedStepParameter("Decimal", paramName, regexPattern);
+                return new AnalyzedStepParameter("Decimal", paramName, regexPattern, "float", wrapText);
 
             if (parameterType == ParameterType.Date && DateTime.TryParse(value, bindingCulture, DateTimeStyles.AllowWhiteSpaces, out _))
-                return new AnalyzedStepParameter("DateTime", paramName, regexPattern);
+                return new AnalyzedStepParameter("DateTime", paramName, regexPattern, "DateTime", wrapText);
 
-            return new AnalyzedStepParameter("String", paramName, regexPattern);
+            return new AnalyzedStepParameter("String", paramName, regexPattern, "string", wrapText);
         }
 
-        private static readonly Regex quotesRe = new Regex(@"""+(?<param>.*?)""+|'+(?<param>.*?)'+|(?<param>\<.*?\>)");
+        private static readonly Regex quotesRe = new Regex(@"(?<param>"".*?"")|(?<param>'.*?')|(?<param>\<.*?\>)");
         private IEnumerable<CaptureWithContext> RecognizeQuotedTexts(string stepText)
         {
             return quotesRe.Matches(stepText)

TechTalk.SpecFlow/Bindings/BindingFactory.cs

@@ -0,0 +1,37 @@
+using TechTalk.SpecFlow.Bindings.CucumberExpressions;
+using TechTalk.SpecFlow.Bindings.Reflection;
+
+namespace TechTalk.SpecFlow.Bindings;
+
+public class BindingFactory : IBindingFactory
+{
+    private readonly IStepDefinitionRegexCalculator stepDefinitionRegexCalculator;
+    private readonly ICucumberExpressionStepDefinitionBindingBuilderFactory _cucumberExpressionStepDefinitionBindingBuilderFactory;
+
+    public BindingFactory(IStepDefinitionRegexCalculator stepDefinitionRegexCalculator, ICucumberExpressionStepDefinitionBindingBuilderFactory cucumberExpressionStepDefinitionBindingBuilderFactory)
+    {
+        this.stepDefinitionRegexCalculator = stepDefinitionRegexCalculator;
+        _cucumberExpressionStepDefinitionBindingBuilderFactory = cucumberExpressionStepDefinitionBindingBuilderFactory;
+    }
+
+    public IHookBinding CreateHookBinding(IBindingMethod bindingMethod, HookType hookType, BindingScope bindingScope,
+        int hookOrder)
+    {
+        return new HookBinding(bindingMethod, hookType, bindingScope, hookOrder);
+    }
+
+    public IStepDefinitionBindingBuilder CreateStepDefinitionBindingBuilder(StepDefinitionType stepDefinitionType, IBindingMethod bindingMethod, BindingScope bindingScope, string expressionString)
+    {
+        return expressionString == null
+            ? new MethodNameStepDefinitionBindingBuilder(stepDefinitionRegexCalculator, stepDefinitionType, bindingMethod, bindingScope)
+            : CucumberExpressionStepDefinitionBindingBuilder.IsCucumberExpression(expressionString)
+                ? _cucumberExpressionStepDefinitionBindingBuilderFactory.Create(stepDefinitionType, bindingMethod, bindingScope, expressionString)
+                : new RegexStepDefinitionBindingBuilder(stepDefinitionType, bindingMethod, bindingScope, expressionString);
+    }
+
+    public IStepArgumentTransformationBinding CreateStepArgumentTransformation(string regexString,
+        IBindingMethod bindingMethod, string parameterTypeName = null)
+    {
+        return new StepArgumentTransformationBinding(regexString, bindingMethod, parameterTypeName);
+    }
+}

TechTalk.SpecFlow/Bindings/CucumberExpressions/BuiltInCucumberExpressionParameterTypeTransformation.cs

@@ -0,0 +1,21 @@
+using TechTalk.SpecFlow.Bindings.Reflection;
+
+namespace TechTalk.SpecFlow.Bindings.CucumberExpressions;
+
+public class BuiltInCucumberExpressionParameterTypeTransformation : ICucumberExpressionParameterTypeTransformation
+{
+    public string Name { get; }
+    public string Regex { get; }
+    public IBindingType TargetType { get; }
+    public bool UseForSnippets { get; }
+    public int Weight { get; }
+
+    public BuiltInCucumberExpressionParameterTypeTransformation(string regex, IBindingType targetType, string name = null, bool useForSnippets = true, int weight = 0)
+    {
+        Regex = regex;
+        TargetType = targetType;
+        Name = name;
+        UseForSnippets = useForSnippets;
+        Weight = weight;
+    }
+}

TechTalk.SpecFlow/Bindings/CucumberExpressions/CucumberExpressionParameterType.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TechTalk.SpecFlow.Bindings.Reflection;
+
+namespace TechTalk.SpecFlow.Bindings.CucumberExpressions;
+
+public class CucumberExpressionParameterType : ISpecFlowCucumberExpressionParameterType
+{
+    internal const string MatchAllRegex = @".*";
+
+    public string Name { get; }
+    public IBindingType TargetType { get; }
+    public ICucumberExpressionParameterTypeTransformation[] Transformations { get; }
+    public string[] RegexStrings { get; }
+
+    public bool UseForSnippets { get; }
+    public int Weight { get; }
+
+    public Type ParameterType => ((RuntimeBindingType)TargetType).Type;
+
+    public CucumberExpressionParameterType(string name, IBindingType targetType, IEnumerable<ICucumberExpressionParameterTypeTransformation> transformations)
+    {
+        Name = name;
+        TargetType = targetType;
+        Transformations = transformations.ToArray();
+        UseForSnippets = Transformations.Any(t => t.UseForSnippets);
+        Weight = Transformations.Max(t => t.Weight);
+
+        var regexStrings = Transformations.Select(tr => tr.Regex).Distinct().ToArray();
+        if (regexStrings.Length > 1 && regexStrings.Contains(MatchAllRegex))
+            regexStrings = new[] {MatchAllRegex};
+        RegexStrings = regexStrings;
+    }
+}