Rejigs 1.0.6

Rejigs

🧩 A fluent, intuitive builder for regular expressions in C#

Rejigs makes creating complex regular expressions simple and readable by providing a fluent API that builds patterns step by step. No more cryptic regex syntax - write patterns that are easy to understand and maintain!

🚀 Getting Started

Installation

Install Rejigs via NuGet Package Manager:

dotnet add package Rejigs

Or via Package Manager Console:

Install-Package Rejigs

Basic Usage

using Rejigs;

// Simple text matching
var regex = Rejigs.Create()
                  .AtStart()
                  .Text("hello")
                  .AtEnd()
                  .Build();

Console.WriteLine(regex.IsMatch("hello")); // True
Console.WriteLine(regex.IsMatch("hello world")); // False

📖 Real-World Examples

Email Validation

var emailRegex = Rejigs.Create()
                        .AtStart()
                        .OneOrMore(r => r.AnyLetterOrDigit().Or().AnyOf(".-_"))  // Local part
                        .Text("@")
                        .OneOrMore(r => r.AnyLetterOrDigit().Or().AnyOf(".-"))   // Domain
                        .Text(".")
                        .Between(2, 6).AnyOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") // TLD
                        .AtEnd()
                        .Build();

Console.WriteLine(emailRegex.IsMatch("user@example.com")); // True
Console.WriteLine(emailRegex.IsMatch("invalid-email")); // False

Phone Number Formatting

var phoneRegex = Rejigs.Create()
                       .AtStart()
                       .Optional("(")
                       .Exactly(3).AnyDigit()  // Area code
                       .Optional(")")
                       .Optional(r => r.AnyOf(" -"))
                       .Exactly(3).AnyDigit()  // Exchange
                       .Optional(r => r.AnyOf(" -"))
                       .Exactly(4).AnyDigit()  // Number
                       .AtEnd()
                       .Build();

Console.WriteLine(phoneRegex.IsMatch("(555) 123-4567")); // True
Console.WriteLine(phoneRegex.IsMatch("555-123-4567")); // True
Console.WriteLine(phoneRegex.IsMatch("5551234567")); // True

URL Validation

var urlRegex = Rejigs.Create()
                     .AtStart()
                     .Either(
                         r => r.Text("http"),
                         r => r.Text("https")
                     )
                     .Text("://")
                     .OneOrMore(r => r.AnyLetterOrDigit().Or().AnyOf(".-"))  // Domain
                     .Optional(r => r.Text(":").OneOrMore(c => c.AnyDigit())) // Port
                     .ZeroOrMore(r => r.Text("/").ZeroOrMore(c => c.AnyExcept(" "))) // Path
                     .AtEnd()
                     .Build();

Console.WriteLine(urlRegex.IsMatch("https://example.com/path")); // True
Console.WriteLine(urlRegex.IsMatch("http://localhost:8080")); // True

Credit Card Number

var creditCardRegex = Rejigs.Create()
                            .AtStart()
                            .Exactly(4).AnyDigit()
                            .Optional(r => r.AnyOf(" -"))
                            .Exactly(4).AnyDigit()
                            .Optional(r => r.AnyOf(" -"))
                            .Exactly(4).AnyDigit()
                            .Optional(r => r.AnyOf(" -"))
                            .Exactly(4).AnyDigit()
                            .AtEnd()
                            .Build();

Console.WriteLine(creditCardRegex.IsMatch("1234 5678 9012 3456")); // True
Console.WriteLine(creditCardRegex.IsMatch("1234-5678-9012-3456")); // True

Password Validation (Complex)

// Password must be 8-20 characters, contain uppercase, lowercase, digit, and special char
var passwordRegex = Rejigs.Create()
                          .AtStart()
                          .Grouping(r => r.ZeroOrMore(c => c.AnyCharacter()).OneOrMore(d => d.AnyInRange('A', 'Z'))) // Has uppercase
                          .Grouping(r => r.ZeroOrMore(c => c.AnyCharacter()).OneOrMore(d => d.AnyInRange('a', 'z'))) // Has lowercase  
                          .Grouping(r => r.ZeroOrMore(c => c.AnyCharacter()).OneOrMore(d => d.AnyDigit())) // Has digit
                          .Grouping(r => r.ZeroOrMore(c => c.AnyCharacter()).OneOrMore(d => d.AnyOf("!@#$%^&*"))) // Has special
                          .Between(8, 20).AnyCharacter() // Length 8-20
                          .AtEnd()
                          .Build();

📚 Complete API Reference

Creating a Builder

Anchors

Character Classes

Text Matching

Quantifiers

Grouping and Alternation

Options

Building

🔧 Performance & Options

Case-Insensitive Matching

Use IgnoreCase() for case-insensitive matching:

var regex = Rejigs.Create()
                  .Text("hello")
                  .IgnoreCase()
                  .Build();

Console.WriteLine(regex.IsMatch("HELLO")); // True
Console.WriteLine(regex.IsMatch("Hello")); // True

Performance Optimization

Use Compiled() for better performance when the regex will be used many times:

var regex = Rejigs.Create()
                  .AtStart()
                  .OneOrMore(r => r.AnyDigit())
                  .Compiled()
                  .IgnoreCase()  // Can combine multiple options
                  .Build();

Recommended Usage Patterns

For simple, one-time use:

var regex = Rejigs.Create().Text("pattern").Build();

For case-insensitive matching:

var regex = Rejigs.Create().Text("pattern").IgnoreCase().Build();

For high-performance scenarios (repeated use):

var regex = Rejigs.Create().Pattern().Compiled().Build();

For maximum flexibility:

var regex = Rejigs.Create()
                  .Pattern()
                  .IgnoreCase()
                  .Compiled()
                  .Build();

🎯 Tips and Best Practices

1. Use descriptive variable names: var emailRegex = ... instead of var regex = ...
2. Break complex patterns into smaller parts: Use variables to store intermediate builders
3. Add comments: Explain what each part of your regex does
4. Test thoroughly: Use unit tests to verify your patterns work correctly
5. Use AtStart() and AtEnd(): For exact matches, always anchor your patterns

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.