Download the PHP package aegisora/regex-rule without Composer

Aegisora Regex Rule

Regex Rule provides a simple, rule-based regular expression validation implementation for the Aegisora ecosystem.

It is built on top of aegisora/rule-contract and follows its strict validation architecture, ensuring consistent and predictable behavior across applications.

This rule is useful for validating user input, form fields, usernames, slugs, email addresses, phone numbers, API request parameters, and any other string that must match a specific pattern.

📑 Table of Contents

• Features
• Installation
• Core Concept
• Basic Usage
• Valid vs Invalid
• Validation Result
• Guardian Usage
• Real-World Examples
• Factory Methods
• Architecture
• License
• Contributing
• Support

✨ Features

• 🔹 Lightweight and dependency-free except aegisora/rule-contract
• 🔹 Validates a string against any PCRE regular expression
• 🔹 Supports the full pattern syntax and flags (i, u, m, s, ...)
• 🔹 Rejects non-string input as an invalid context
• 🔹 Surfaces broken patterns and runtime PCRE failures as execution errors instead of a silent false
• 🔹 Fully compatible with Aegisora validation pipeline
• 🔹 Strict Context → Result validation flow
• 🔹 No raw booleans — only structured results
• 🔹 Safe execution via base Rule abstraction
• 🔹 Expressive factory API
• 🔹 Ready to use out of the box

📦 Installation

🚀 Core Concept

This package implements a single validation rule:

• accepts a string value via Context
• checks whether the string matches the configured regular expression
• returns a standardized Result

Under the hood it wraps the common boilerplate:

into a reusable rule that reports its outcome through a Result object instead of a raw boolean, and turns PCRE failures into explicit exceptions.

🏗️ Basic Usage

The rule can also be instantiated directly:

✅ Valid vs Invalid

The rule passes when the string matches the configured pattern and fails otherwise.

Anchored patterns

Unanchored patterns

Flags

🧪 Validation Result

If the string matches the pattern, the rule returns a valid result.

$result->isValid(); // true

If the string does not match the pattern, the rule returns an invalid result.

If the context value is not a string, the rule throws:

Aegisora\RuleContract\Exceptions\InvalidRuleContextException

If the pattern is invalid, or the match fails at runtime (e.g. the backtrack limit is exceeded or the subject is not valid UTF-8 under the u flag), the rule throws:

Aegisora\RuleContract\Exceptions\RuleExecutionException

🔗 Guardian Usage

This rule can be used together with aegisora/guardian to build fluent validation pipelines.

If the value does not match the pattern, Guardian throws the provided domain exception.

🧭 Real-World Examples

Regex Rule is useful for enforcing format constraints before values are persisted or processed.

Examples

🧩 Factory Methods

RegexRule::create($pattern);

• creates a rule that passes when the value matches the PCRE $pattern (delimiters and flags included)

new RegexRule($pattern);

• equivalent to RegexRule::create($pattern)

RegexRule::create($pattern)->validate($context);

• $context — Context wrapping the string value to validate

🏛️ Architecture

This package relies on aegisora/rule-contract.

Flow:

1. validate() is called
2. Context is passed in
3. The configured pattern is checked; a broken pattern raises RuleExecutionException
4. The string value is extracted from context (non-strings raise InvalidRuleContextException)
5. The value is matched against the pattern with preg_match(); a PCRE runtime failure raises RuleExecutionException
6. Result is returned — valid on match, invalid with the regex_rule code on no match

All logic is safely handled by Rule contract.

⚖️ License

This package is open-source and licensed under the MIT License. See the LICENSE for details.

🌱 Contributing

Contributions are welcome and greatly appreciated! See the CONTRIBUTING for details.

🌟 Support

If you find this project useful, please consider giving it a star on GitHub!

It helps the project grow and motivates further development.