Add support for Tag Expressions

CHANGELOG.md

@@ -1,10 +1,12 @@
 # [vNext]
 
 ## Improvements:
+* Tag Expressions: step definition scopes and hooks may now use tag expressions (such as `@db and not @slow`) (#911)
 
 ## Bug fixes:
 
 *Contributors of this release (in alphabetical order):* 
+@clrudolphi
 
 # v3.3.2 - 2026-01-14
 

Reqnroll/Bindings/BindingFactory.cs

@@ -10,9 +10,9 @@ public class BindingFactory(
     : IBindingFactory
 {
     public IHookBinding CreateHookBinding(IBindingMethod bindingMethod, HookType hookType, BindingScope bindingScope,
-        int hookOrder)
+        int hookOrder, string errorMessage = null)
     {
-        return new HookBinding(bindingMethod, hookType, bindingScope, hookOrder);
+        return new HookBinding(bindingMethod, hookType, bindingScope, hookOrder, errorMessage);
     }
 
     public IStepDefinitionBindingBuilder CreateStepDefinitionBindingBuilder(StepDefinitionType stepDefinitionType, IBindingMethod bindingMethod, BindingScope bindingScope,

Reqnroll/Bindings/BindingScope.cs

@@ -1,38 +1,30 @@
 using System;
 using System.Linq;
+using Cucumber.TagExpressions;
+using Reqnroll.Bindings.Discovery;
 
 namespace Reqnroll.Bindings
 {
-    public class BindingScope
+    public class BindingScope(ITagExpression tagExpression, string featureTitle, string scenarioTitle)
     {
-        public string Tag { get; private set; }
-        public string FeatureTitle { get; private set; }
-        public string ScenarioTitle { get; private set; }
+        public string Tag => tagExpression is ReqnrollTagExpression reqnrollTagExpression ? reqnrollTagExpression.TagExpressionText : tagExpression.ToString();
+        public ITagExpression TagExpression => tagExpression;
 
-        public BindingScope(string tag, string featureTitle, string scenarioTitle)
-        {
-            Tag = RemoveLeadingAt(tag);
-            FeatureTitle = featureTitle;
-            ScenarioTitle = scenarioTitle;
-        }
+        public string FeatureTitle { get; } = featureTitle;
 
-        private string RemoveLeadingAt(string tag)
-        {
-            if (tag == null || !tag.StartsWith("@"))
-                return tag;
-
-            return tag.Substring(1); // remove leading "@"
-        }
+        public string ScenarioTitle { get; } = scenarioTitle;
+        public bool IsValid => ErrorMessage == null;
+        public string ErrorMessage => tagExpression is InvalidTagExpression ? tagExpression.ToString() : null;
 
         public bool Match(StepContext stepContext, out int scopeMatches)
         {
             scopeMatches = 0;
 
-            var tags = stepContext.Tags;
-
-            if (Tag != null)
+            if (tagExpression is not NullExpression)
             {
-                if (!tags.Contains(Tag))
+                var tags = stepContext.Tags.Select(t => "@" + t).ToList();
+
+                if (!tagExpression.Evaluate(tags))    
                     return false;
 
                 scopeMatches++;
@@ -57,14 +49,14 @@ public bool Match(StepContext stepContext, out int scopeMatches)
 
         protected bool Equals(BindingScope other)
         {
-            return string.Equals(Tag, other.Tag) && string.Equals(FeatureTitle, other.FeatureTitle) && string.Equals(ScenarioTitle, other.ScenarioTitle);
+            return string.Equals(Tag, other.Tag) && string.Equals(FeatureTitle, other.FeatureTitle) && string.Equals(ScenarioTitle, other.ScenarioTitle) && string.Equals(ErrorMessage, other.ErrorMessage);
         }
 
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
             if (ReferenceEquals(this, obj)) return true;
-            if (obj.GetType() != this.GetType()) return false;
+            if (obj.GetType() != GetType()) return false;
             return Equals((BindingScope) obj);
         }
 
@@ -75,6 +67,7 @@ public override int GetHashCode()
                 var hashCode = (Tag != null ? Tag.GetHashCode() : 0);
                 hashCode = (hashCode*397) ^ (FeatureTitle != null ? FeatureTitle.GetHashCode() : 0);
                 hashCode = (hashCode*397) ^ (ScenarioTitle != null ? ScenarioTitle.GetHashCode() : 0);
+                hashCode = (hashCode*397) ^ (ErrorMessage != null ? ErrorMessage.GetHashCode() : 0);
                 return hashCode;
             }
         }

Reqnroll/Bindings/Discovery/BindingSourceProcessor.cs

@@ -3,20 +3,23 @@
 using System.Linq;
 using Reqnroll.Bindings.Reflection;
 using Reqnroll.PlatformCompatibility;
+using Cucumber.TagExpressions;
 
 namespace Reqnroll.Bindings.Discovery
 {
     public abstract class BindingSourceProcessor : IBindingSourceProcessor
     {
         private readonly IBindingFactory _bindingFactory;
+        private readonly IReqnrollTagExpressionParser _tagExpressionParser;
 
         private BindingSourceType _currentBindingSourceType = null;
         private BindingScope[] _typeScopes = null;
         private readonly List<IStepDefinitionBindingBuilder> _stepDefinitionBindingBuilders = new();
 
-        protected BindingSourceProcessor(IBindingFactory bindingFactory)
+        protected BindingSourceProcessor(IBindingFactory bindingFactory, IReqnrollTagExpressionParser tagExpressionParser)
         {
             _bindingFactory = bindingFactory;
+            _tagExpressionParser = tagExpressionParser;
         }
 
         public bool CanProcessTypeAttribute(string attributeTypeName)
@@ -75,7 +78,7 @@ public virtual void BuildingCompleted()
         private IEnumerable<BindingScope> GetScopes(IEnumerable<BindingSourceAttribute> attributes)
         {
             return attributes.Where(attr => attr.AttributeType.TypeEquals(typeof(ScopeAttribute)))
-                .Select(attr => new BindingScope(attr.TryGetAttributeValue<string>("Tag"), attr.TryGetAttributeValue<string>("Feature"), attr.TryGetAttributeValue<string>("Scenario")));
+                .Select(attr => new BindingScope(_tagExpressionParser.Parse(attr.TryGetAttributeValue<string>("Tag")), attr.TryGetAttributeValue<string>("Feature"), attr.TryGetAttributeValue<string>("Scenario")));
         }
 
         private bool IsBindingType(BindingSourceType bindingSourceType)
@@ -156,7 +159,7 @@ private void ProcessHookAttribute(BindingSourceMethod bindingSourceMethod, Bindi
 
             string[] tags = GetTagsDefinedOnBindingAttribute(hookAttribute);
             if (tags != null)
-                scopes = scopes.Concat(tags.Select(t => new BindingScope(t, null, null)));
+                scopes = scopes.Concat(tags.Select(t => new BindingScope(_tagExpressionParser.Parse(t), null, null)));
 
 
             ApplyForScope(scopes.ToArray(), scope => ProcessHookAttribute(bindingSourceMethod, hookAttribute, scope));
@@ -179,13 +182,15 @@ private void ProcessHookAttribute(BindingSourceMethod bindingSourceMethod, Bindi
             int order = GetHookOrder(hookAttribute);
 
             var validationResult = ValidateHook(bindingSourceMethod, hookAttribute, hookType);
+            var scopeValidationResult = ValidateBindingScope(scope);
+            validationResult += scopeValidationResult;
             if (!validationResult.IsValid)
             {
                 OnValidationError(validationResult, true);
-                return;
             }
 
-            var hookBinding = _bindingFactory.CreateHookBinding(bindingSourceMethod.BindingMethod, hookType, scope, order);
+            var hookBinding = _bindingFactory.CreateHookBinding(bindingSourceMethod.BindingMethod, hookType, scope, order, 
+                scopeValidationResult.IsValid ? null : scopeValidationResult.CombinedErrorMessages);
 
             ProcessHookBinding(hookBinding);
         }
@@ -250,6 +255,8 @@ private void ProcessStepDefinitionAttribute(BindingSourceMethod bindingSourceMet
             var expressionType = stepDefinitionAttribute.TryGetAttributeValue<ExpressionType>(nameof(StepDefinitionBaseAttribute.ExpressionType));
 
             var validationResult = ValidateStepDefinition(bindingSourceMethod, stepDefinitionAttribute);
+            validationResult += ValidateBindingScope(scope);
+
             if (!validationResult.IsValid)
             {
                 OnValidationError(validationResult, false);
@@ -352,6 +359,17 @@ protected virtual BindingValidationResult ValidateHook(BindingSourceMethod bindi
             return result;
         }
 
+        protected virtual BindingValidationResult ValidateBindingScope(BindingScope bindingScope) 
+        { 
+            var result = BindingValidationResult.Valid;
+
+            if (bindingScope is { TagExpression: InvalidTagExpression invalidTagExpression })
+            {
+                result += BindingValidationResult.Error($"Invalid scope: {invalidTagExpression}");
+            }
+            return result;
+        }
+
         protected bool IsScenarioSpecificHook(HookType hookType)
         {
             return

Reqnroll/Bindings/Discovery/IReqnrollTagExpressionParser.cs

@@ -0,0 +1,16 @@
+using Cucumber.TagExpressions;
+
+namespace Reqnroll.Bindings.Discovery;
+
+/// <summary>
+/// Defines a parser for tag expressions.
+/// </summary>
+public interface IReqnrollTagExpressionParser
+{
+    /// <summary>
+    /// Parses the specified text into an <see cref="ITagExpression"/>.
+    /// </summary>
+    /// <param name="text">The tag expression string to parse.</param>
+    /// <returns>An <see cref="ITagExpression"/> representing the parsed expression.</returns>
+    ITagExpression Parse(string text);
+}

Reqnroll/Bindings/Discovery/InvalidTagExpression.cs

@@ -0,0 +1,17 @@
+using Cucumber.TagExpressions;
+using System;
+
+namespace Reqnroll.Bindings.Discovery;
+public class InvalidTagExpression(ITagExpression expression, string originalTagExpression, string message) : ReqnrollTagExpression(expression, originalTagExpression)
+{
+    public string Message { get; } = message;
+
+    public override bool Evaluate(System.Collections.Generic.IEnumerable<string> tags)
+    {
+        throw new InvalidOperationException("Cannot evaluate an invalid tag expression: " + Message);
+    }
+    public override string ToString()
+    {
+        return "Invalid tag expression: " + Message;
+    }
+}

Reqnroll/Bindings/Discovery/ReqnrollTagExpression.cs

@@ -0,0 +1,19 @@
+using Cucumber.TagExpressions;
+using System.Collections.Generic;
+
+namespace Reqnroll.Bindings.Discovery;
+
+public class ReqnrollTagExpression(ITagExpression inner, string tagExpressionText) : ITagExpression
+{
+    public string TagExpressionText { get; } = tagExpressionText;
+
+    public override string ToString()
+    {
+        return inner.ToString();
+    }
+
+    public virtual bool Evaluate(IEnumerable<string> inputs)
+    {
+        return inner.Evaluate(inputs);
+    }
+}

Reqnroll/Bindings/Discovery/ReqnrollTagExpressionParser.cs

@@ -0,0 +1,65 @@
+using Cucumber.TagExpressions;
+using System;
+
+namespace Reqnroll.Bindings.Discovery;
+
+public class ReqnrollTagExpressionParser : IReqnrollTagExpressionParser
+{
+    public ITagExpression Parse(string tagExpression)
+    {
+        var tagExpressionParser = new TagExpressionParser();
+        try 
+        { 
+            var result = tagExpressionParser.Parse(tagExpression);
+            result = Rewrite(result);
+            return new ReqnrollTagExpression(result, tagExpression);
+        }
+        catch (TagExpressionException ex)
+        {
+            var msg = ex.Message;
+            if (ex.TagToken != null)
+            {
+                msg += $" (at offset {ex.TagToken.Position})";
+            }
+            return new InvalidTagExpression(null, tagExpression, msg);
+        }
+    }
+
+    // iff the expression is a literal node, prefix it with '@' if not already present
+    private ITagExpression Rewrite(ITagExpression expression)
+    {
+        if (expression is LiteralNode)
+        {
+            return PrefixLiteralNode(expression);
+        }
+        if (ConfirmExpressionHasAtPrefixes(expression))
+            return expression;
+        throw new TagExpressionException("In multi-term tag expressions, all tag names must start with '@'.");
+    }
+
+    private bool ConfirmExpressionHasAtPrefixes(ITagExpression expression)
+    {
+        switch (expression)
+        {
+            case NullExpression:
+                return true;
+            case BinaryOpNode binaryNode:
+                return ConfirmExpressionHasAtPrefixes(binaryNode.Left) && ConfirmExpressionHasAtPrefixes(binaryNode.Right);
+            case NotNode notNode:
+                return ConfirmExpressionHasAtPrefixes(notNode.Operand);
+            case LiteralNode literalNode:
+                return literalNode.Name.StartsWith("@");
+            default:
+                throw new InvalidOperationException($"Unknown tag expression node type: {expression.GetType().FullName}");
+        }
+    }
+
+    private ITagExpression PrefixLiteralNode(ITagExpression expression)
+    {
+        var literalNode = (LiteralNode)expression;
+        if (literalNode.Name.IsNullOrEmpty() || literalNode.Name.StartsWith("@"))
+            return literalNode;
+
+        return new LiteralNode("@" + literalNode.Name);
+    }
+}

Reqnroll/Bindings/Discovery/RuntimeBindingSourceProcessor.cs

@@ -1,4 +1,5 @@
 using Reqnroll.Tracing;
+using Cucumber.TagExpressions;
 
 namespace Reqnroll.Bindings.Discovery
 {
@@ -12,7 +13,7 @@ public class RuntimeBindingSourceProcessor : BindingSourceProcessor, IRuntimeBin
         private readonly IBindingRegistry _bindingRegistry;
         private readonly ITestTracer _testTracer;
 
-        public RuntimeBindingSourceProcessor(IBindingFactory bindingFactory, IBindingRegistry bindingRegistry, ITestTracer testTracer) : base(bindingFactory)
+        public RuntimeBindingSourceProcessor(IBindingFactory bindingFactory, IBindingRegistry bindingRegistry, ITestTracer testTracer, IReqnrollTagExpressionParser tagExpressionParser) : base(bindingFactory, tagExpressionParser)
         {
             _bindingRegistry = bindingRegistry;
             _testTracer = testTracer;

Reqnroll/Bindings/HookBinding.cs

@@ -9,16 +9,20 @@ public class HookBinding : MethodBinding, IHookBinding
         public BindingScope BindingScope { get; private set; }
         public bool IsScoped { get { return BindingScope != null; } }
 
-        public HookBinding(IBindingMethod bindingMethod, HookType hookType, BindingScope bindingScope, int hookOrder) : base(bindingMethod)
+        public bool IsValid => ErrorMessage == null;
+        public string ErrorMessage { get; }
+
+        public HookBinding(IBindingMethod bindingMethod, HookType hookType, BindingScope bindingScope, int hookOrder, string errorMessage = null) : base(bindingMethod)
         {
             HookOrder = hookOrder;
             HookType = hookType;
             BindingScope = bindingScope;
+            ErrorMessage = errorMessage;
         }
 
         protected bool Equals(HookBinding other)
         {
-            return HookType == other.HookType && HookOrder == other.HookOrder && Equals(BindingScope, other.BindingScope) && base.Equals(other);
+            return HookType == other.HookType && HookOrder == other.HookOrder && Equals(BindingScope, other.BindingScope) && string.Equals(ErrorMessage, other.ErrorMessage) && base.Equals(other);
         }
 
         public override bool Equals(object obj)
@@ -36,6 +40,7 @@ public override int GetHashCode()
                 var hashCode = (int) HookType;
                 hashCode = (hashCode*397) ^ HookOrder;
                 hashCode = (hashCode*397) ^ (BindingScope != null ? BindingScope.GetHashCode() : 0);
+                hashCode = (hashCode * 397) ^ (ErrorMessage != null ? ErrorMessage.GetHashCode() : 0);
                 return hashCode;
             }
         }

Reqnroll/Bindings/IBindingFactory.cs

@@ -5,7 +5,7 @@ namespace Reqnroll.Bindings
     public interface IBindingFactory
     {
         IHookBinding CreateHookBinding(IBindingMethod bindingMethod, HookType hookType, BindingScope bindingScope,
-            int hookOrder);
+            int hookOrder, string errorMessage = null);
 
         IStepDefinitionBindingBuilder CreateStepDefinitionBindingBuilder(StepDefinitionType stepDefinitionType, IBindingMethod bindingMethod, BindingScope bindingScope,
             string expressionString, ExpressionType expressionType);

Reqnroll/Bindings/IHookBinding.cs

@@ -4,5 +4,7 @@ public interface IHookBinding : IScopedBinding, IBinding
     {
         HookType HookType { get; }
         int HookOrder { get; }
+        bool IsValid { get; }
+        string ErrorMessage { get; }
     }
 }