#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   package Re;
    sub re { qr/perl/i }
}

say 'perl Perl PERL' =~ /${ \Re::re() }/g;
say 'perl Perl PERL' =~ /(??{ Re::re() })/g;
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

say 'perl Perl PERL' =~ /${ \Re::re() }/g;

Abusing the internal representation of regular expressions, this also seems to work:

say 'perl Perl PERL' =~ /${Re::re()}/g;
[download]

It exports the regexps in a tied hash, and uses some tricks to generate parametrized regexps on demand.

The interesting thing is that you can interpolate the hash slots directly as in $foo =~ /$RE{balanced}{-parens=>'()'}/

This is a great idea! I'll have a good look at Regexp::Common over the weekend. I did get a full implementation and all my tests are passing on both Unix and Windows, so I did get it to work correctly. I've moved on to updating berrybrew with some new enhancements/bug fixes before I can get back to that distribution, as it relies on some berrybrew changes anyway.

I'll create a new branch and test it out, but at this time, this is what I ended up with:

package Test::BrewBuild::Regex;
use strict;
use warnings;

use Carp qw(croak);
use Exporter qw(import);

our $VERSION = '2.20';

our @EXPORT = qw(
    re_brewbuild
    re_brewcommands
    re_dispatch
    re_git
);

my %brewbuild = (

    check_failed => qr{failed.*?See\s+(.*?)\s+for details},

    check_result => qr{
        [Pp]erl-\d\.\d+\.\d+(?:_\w+)?
        \s+===.*?
        (?=(?:[Pp]erl-\d\.\d+\.\d+(?:_\w+)?\s+===|$))
    }xs,

    extract_dzil_dist_name => qr{^name\s+=\s+(.*)$},

    extract_dzil_dist_version => qr{^version\s+=\s+(.*)$},

    extract_errors => qr{
        cpanm\s+\(App::cpanminus\)
        .*?
        (?=(?:cpanm\s+\(App::cpanminus\)|$))
    }xs,

    extract_error_perl_ver => qr{cpanm.*?perl\s(5\.\d+)\s},

    extract_result => qr{
        ([Pp]erl-\d\.\d+\.\d+(?:_\w+)?\s+=+?)
        (\s+.*?)
        (?=(?:[Pp]erl-\d\.\d+\.\d+(?:_\w+)?\s+===|$))
    }xs,

    extract_perl_version => qr{^([Pp]erl-\d\.\d+\.\d+(_\d{2})?)},
);

my %brewcommands = (

    available_berrybrew => qr{(\d\.\d+\.\d+_\d+)},

    available_perlbrew => qr{(?<!c)(perl-\d\.\d+\.\d+(?:-RC\d+)?)},

    installed_berrybrew => qr{(\d\.\d{2}\.\d(?:_\d{2}))(?!=_)\s+\[inst
+alled\]}i,

    installed_perlbrew => qr{i\s+(perl-\d\.\d+\.\d+)},

    using_berrybrew => qr{(\d\.\d{2}\.\d(?:_\d{2}))(?!=_)\s+\[installe
+d\]\s+\*}i,
);

my %dispatch = (

    extract_short_results => qr{(5\.\d{1,2}\.\d{1,2} :: \w{4})},
);

my %git = (

    extract_repo_name => qr{.*/(.*?)(?:\.git)*$},

    extract_commit_csum => qr{([A-F0-9]{40})\s+HEAD}i,
);

sub re_brewbuild {
    my $re = shift;
    _check(\%brewbuild, $re);
    return $brewbuild{$re};
}
sub re_brewcommands {
    my $re = shift;
    _check(\%brewcommands, $re);
    return $brewcommands{$re};
}
sub re_dispatch {
    my $re = shift;
    _check(\%dispatch, $re);
    return $dispatch{$re};
}
sub re_git {
    my $re = shift;
    _check(\%git, $re);
    return $git{$re};
}
sub _check {
    my ($module, $re) = @_;
    croak "regex '$re' doesn't exist for re_${module}()"
      if ! exists $module->{$re};
}

1;
[download]

(POD redacted).

Thanks for all of the tips and advice everyone!

That is exactly how I would do it and in fact have done it. Copy the text of one of those modules and adapt it to your project's namespace, then refill it with the regexes that you need. It isn't overkill at all.

my @results = $str =~ /@{[ Re::re() ]}/g;
[download]

Heh, that's quite slick, thanks! :)

Might I ask where you found that tidbit? I swear I read the docs, so I must have overlooked that somewhere. I'd like to get an understanding of how and why that works properly.

I don't think you'll find it as is in the doc. It's a side effect of the "@{ REF }" interpolation where REF can actually be an arbitrary expression, so it can be an anonymous array ref that only contains the one element you want. It's known as a secret operator.

How about just Re::re($str) instead? Or maybe $str =~ /$Re::h{re}/g

Without the /g you would have been able to use $str =~ Re::re(). But to have the global search I can only think of $str =~ /@{[ Re::re() ]}/g or /(??{ Re::re() })/g which aren't much of an improvement.

Can your subs have parameters? If there is one regex for each sub, where the name of the sub is also the key in the hash, you maybe be interested in AUTOLOAD.

Edit: choroba made me realize it's (??{ }) not (?{{ }}) (which should have been obvious, as the latter is actually a case of (?{ }))

The sub(s) will take parameters. One sub per module in the distribution. Here's the real code section of the new module. I've only added one module's sub so far:

package Test::BrewBuild::Regex;
use strict;
use warnings;

use Carp qw(croak);
use Exporter qw(import);

our $VERSION = '2.20';

our @EXPORT = qw(
    re_brewbuild
);

my %brewbuild = (

    check_failed => qr{
        failed.*?See\s+(.*?)\s+for details
    }x,

    check_result => qr{
        [Pp]erl-\d\.\d+\.\d+(?:_\w+)?
        \s+===.*?
        (?=(?:[Pp]erl-\d\.\d+\.\d+(?:_\w+)?\s+===|$))
    }xs,

    extract_dist_name => qr{
        ^name\s+=\s+(.*)$
    }x,

    extract_dist_version => qr{
        ^version\s+=\s+(.*)$
    }x,

    extract_errors => qr{
        cpanm\s+\(App::cpanminus\)
        .*?
        (?=(?:cpanm\s+\(App::cpanminus\)|$))
    }xs,

    extract_error_perl_ver => qr{
        cpanm.*?perl\s(5\.\d+)\s
    }x,

    extract_result => qr{
        ([Pp]erl-\d\.\d+\.\d+(?:_\w+)?\s+=+?)
        (\s+.*?)
        (?=(?:[Pp]erl-\d\.\d+\.\d+(?:_\w+)?\s+===|$))
    }xs,

    extract_perl_version => qr{
        ^([Pp]erl-\d\.\d+\.\d+(_\d{2})?)
    }x,
);

sub re_brewbuild {
    my $re = shift;
    _check(\%brewbuild, $re);
    return $brewbuild{$re};
}
sub _check {
    my ($module, $re) = @_;
    croak "regex '$re' doesn't exist for re_brewbuild()"
      if ! exists $module->{$re};
}

1;
[download]

You can probably use straight-up $str =~ re() syntax with global searches as well, just make sure the re() returns a :lvalue. Either that or return a ref: $str =~ ${re()}.

I don't see any connexion between :lvalue and /g. $str =~ ${re()} isn't a global search but the output of qr is already a reference so /${re()}/g works, as pointed out by salva.