Using

Regex::replace('/[^a-zA-Z0-9_]+/', '_', $value)->result();

fails with this error message:

_() expects parameter 1 to be string, object given

It seems like the _ string is detected as a callable as it may refer to gettext's _() function

Travis reports these failures for PHP 7.3. This should be fixed.

1. Spatie\Regex\Test\MatchAllTest::it_throws_an_exception_if_a_match_throws_a_preg_error array_flip(): Can only flip STRING and INTEGER values! /home/travis/build/spatie/regex/src/RegexResult.php:9 /home/travis/build/spatie/regex/src/MatchAllResult.php:49 /home/travis/build/spatie/regex/src/Regex.php:26 /home/travis/build/spatie/regex/tests/MatchAllTest.php:54
2. Spatie\Regex\Test\MatchTest::it_throws_an_exception_if_a_match_throws_a_preg_error array_flip(): Can only flip STRING and INTEGER values!

Hey there, I have a sittuation where a regex group might not exist and where I would like to return a default value instead. With the current implementation I would need to do a check first and handle that accordingly. What if we could specify a default value as a parameter? I was about to submit a PR but I would like some feedback first, let me know if you think this would be useful:

How I do it now:

$pattern = '/some-pattern/(.+?)/with-groups';

if(Regex::match($pattern, $url)->hasMatch()){
    $value = Regex::match($pattern, $url)->group(1);
}) else {
    $value = 'something else';   
};

// or
$regex = Regex::match($pattern, $url);
$value = $regex->hasMatch() ? $regex->group(1) : 'something else';

Proposed way:

// this approach would add a default parameter to keep backwards compatibility
$value = Regex::match('/some-pattern/(.+?)/with-groups', $url)->group(1, 'something else');

// or a new method
$value = Regex::match('/some-pattern/(.+?)/with-groups', $url)->groupOr(1, 'something else');

// or maybe simply return null or false?
$value = Regex::match('/some-pattern/(.+?)/with-groups', $url)->group(1) ?? 'something else';

Anyway, it might not even be worth it...

Does it make sense to integrate https://github.com/TYVRNET/SRL in this package to have one simple Regex API? Regardless if one want to use raw regex or SRL.

This PR adds a new major version, v2.0.0.

Specifically, it:

• Removes support for all PHP 7.x versions.
• Requires PHP 8.0+.
• All syntax converted to PHP 8 where possible.
• Removes unnecessary PHP docblocks per Spatie's guidelines.
• Moves exception classes to an "Exceptions" directory to match the structure of other packages.
• Adds config & github workflow for php-cs-fixer.
• Updates the location of CONTRIBUTING.md.
• Updates the readme with minor adjustments from spatie/package-skeleton-php.
• Updates the changelog - release date needs to be updated, currently is "unreleased".

Just looking at the documentation:

// Using `match`
Regex::match('/a/', 'abc'); // `MatchResult` object
Regex::match('/a/', 'abc')->hasMatch(); // true
Regex::match('/a/', 'abc')->result(); // 'a'

I realize this is an example, but it's not uncommon for regex to be expensive to process, and this static approach would reevaluate the regex for each statement.

An object-oriented approach would be better, or perhaps some caching of results to prevent needlessly processing the same patterns and string combinations more than once.

Alternatively, remove hasMatch() and suggest checking the result() and results() to determine if there are matches.

First of all, I ❤️ this library as well as all of your projects! 🤓

I think it would be really convenient to be able to access the private MatchResult::$matches property to be able to access the results as an array.

Example

$result = Regex::match($pattern, $subject);

// Either as a property...
$result->matches;

// or as an accessor method...
$result->groups()

// Use
$results = $result->groups();
echo($results[3]); // Printing group #3.

Could also probably apply to MatchAllResult::class as well.

Thank you for all of your work!

I added support for named capturing groups in class MatchAllResult. The old behavior has been done with array_map() but it's not compatible with string keys inside arrays, so they can't be unpacked. I therefore reworked it and now named capturing groups in regular expressions can be used on Regex::matchAll() also.

As an additional change I reworked MatchResult::group() and MatchResult::namedGroup(). I don't see why I need to distinguish between indexed and named capturing groups, because probably if using named capturing groups they can be the same. I think there's no need to differentiate between both.

Additionally I type hinted MatchAllResult::results() to get a useful code completion.

I also annotated necessary @throws tags where an exception could be thrown.

This PR contains a RegexBuilder and an ExpressionBuilder that makes it easy to generate regular expressions programmatically. It makes it easy to understand previously written regexes, to use advanced expressions and to tell what the regex is doing to beginning regex programmers.

Example:

$builder = RegexBuilder::create();
$expr = ExpressionBuilder::create();
$regex = $builder
    ->setDelimiter('/')
    ->isCaseInsensitive()
    ->isFreeSpacing()
    ->addExpression($expr->extendedComment('This one matches zero or more numeric characters.'))
    ->addExpression(
        $exp->concat(
            $exp->characterClass(
                $exp->concat(
                    $exp->range('0', '9'),
                    $exp->range('a', 'z')
                )
            ),
            $exp->zeroOrMoreTimes()
        )
    )
    ->getRegex("\n");

Result

/
# This one matches zero or more numeric characters.
[0-9a-z]*
/ix

(Off course the example above is simple and can be written directly as the result, but some advanced expressions are also available with the builder.)

It's based on this presentation: http://slides.seld.be/?file=2016-01-30+How+I+learned+to+stop+worrying+and+love+Regular+Expressions.html#1

If this is something you want inside this package, I can add some additional documentation on how to use it.

(Side-Note: I thing the current Regex class should really be a Regex instance instead of a list with static functions. It makes more sense to me)

Its not a feature request but more like a philosophical talk.

Did you consider a non-static approach, something like Js Regexp.

Then you could do for example:

$re = new RegExp(...);

Str::endsWith('abcde', $re);

//--

class Str
{
    public static function endsWith(string $haystack, $needle): bool
    {
        $length = strlen($needle);
        if ($length == 0) {
            return true;
        }
        
        if ($needle instanceof RegExp) {
            return $needle->match($haystack)->hasMatch();
        } else {
            return substr($haystack, -$length) === $needle;
        }
    }
}

Otherwise very nice library.

Regex::replace can be used with both strings and arrays for $subject (like the original preg_replace method), and it therefore can return a string or an array, which leads to static analyzers (like PHPStan) not being able to tell what the return type ends up being - making the use of static analyzers very painful or simply impossible, as it will be necessary to type cast or somehow tell the static analyzers the exact type each time.

I suggest adding methods for both cases, one where $subject specifically is a string, and one where $subject is an array, so the return type can be specified. These functions could simply be named replaceString and replaceArray - that way it could be added without any backwards compatibility problems.

I can prepare a PR if this is something that you are open to.