=head1 VERSION
-Version 1.00
+Version 1.02
=cut
use vars qw/$VERSION/;
BEGIN {
- $VERSION = '1.00';
+ $VERSION = '1.02';
}
=head1 SYNOPSIS
$re = $rw->convert('a{b?,c}*'); # Do it Unix shell style.
$re = $rw->convert('a?,b*', 'win32'); # Do it Windows shell style.
$re = $rw->convert('*{x,y}?', 'jokers'); # Process the jokers and escape the rest.
- $re = $rw->convert('%a_c%', 'sql'); # Turn SQL wildcards into regexps.
+ $re = $rw->convert('%a_c%', 'sql'); # Turn SQL wildcards into regexps.
$rw = Regexp::Wildcards->new(
do => [ qw/jokers brackets/ ], # Do jokers and brackets.
In many situations, users may want to specify patterns to match but don't need the full power of regexps. Wildcards make one of those sets of simplified rules. This module converts wildcard expressions to Perl regular expressions, so that you can use them for matching.
-It handles the C<*> and C<?> jokers, as well as Unix bracketed alternatives C<{,}>, but also C<%> and C<_> SQL wildcards. It can also keep original C<(...)> groups. Backspace (C<\>) is used as an escape character.
+It handles the C<*> and C<?> jokers, as well as Unix bracketed alternatives C<{,}>, but also C<%> and C<_> SQL wildcards. If required, it can also keep original C<(...)> groups or C<^> and C<$> anchors. Backspace (C<\>) is used as an escape character.
Typesets that mimic the behaviour of Windows and Unix shells are also provided.
commas => ',',
brackets => '{},',
groups => '()',
+ anchors => '^$',
);
my %captures = (
=head2 C<< do [ $what E<verbar> set => $c1, add => $c2, rem => $c3 ] >>
-Specifies the list of metacharacters to convert.
-They are classified into five classes :
+Specifies the list of metacharacters to convert or to prevent for escaping.
+They fit into six classes :
=over 4
-=item C<'jokers'> converts C<?> to C<.> and C<*> to C<.*> ;
+=item *
+
+C<'jokers'> converts C<?> to C<.> and C<*> to C<.*> ;
'a**\\*b??\\?c' ==> 'a.*\\*b..\\?c'
-=item C<'sql'> converts C<_> to C<.> and C<%> to C<.*> ;
+=item *
+
+C<'sql'> converts C<_> to C<.> and C<%> to C<.*> ;
'a%%\\%b__\\_c' ==> 'a.*\\%b..\\_c'
-=item C<'commas'> converts all C<,> to C<|> and puts the complete resulting regular expression inside C<(?: ... )> ;
+=item *
+
+C<'commas'> converts all C<,> to C<|> and puts the complete resulting regular expression inside C<(?: ... )> ;
'a,b{c,d},e' ==> '(?:a|b\\{c|d\\}|e)'
-=item C<'brackets'> converts all matching C<{ ... , ... }> brackets to C<(?: ... | ... )> alternations. If some brackets are unbalanced, it tries to substitute as many of them as possible, and then escape the remaining unmatched C<{> and C<}>. Commas outside of any bracket-delimited block are also escaped ;
+=item *
+
+C<'brackets'> converts all matching C<{ ... , ... }> brackets to C<(?: ... | ... )> alternations. If some brackets are unbalanced, it tries to substitute as many of them as possible, and then escape the remaining unmatched C<{> and C<}>. Commas outside of any bracket-delimited block are also escaped ;
'a,b{c,d},e' ==> 'a\\,b(?:c|d)\\,e'
'{a\\{b,c}d,e}' ==> '(?:a\\{b|c)d\\,e\\}'
'{a{b,c\\}d,e}' ==> '\\{a\\{b\\,c\\}d\\,e\\}'
-=item C<'groups'> keeps the parenthesis C<( ... )> of the original string without escaping them. Currently, no check is done to ensure that the parenthesis are matching.
+=item *
+
+C<'groups'> keeps the parenthesis C<( ... )> of the original string without escaping them. Currently, no check is done to ensure that the parenthesis are matching.
'a(b(c))d\\(\\)' ==> (no change)
+=item *
+
+C<'anchors'> prevents the I<beginning-of-line> C<^> and I<end-of-line> C<$> anchors to be escaped. Since C<[...]> character class are currently escaped, a C<^> will always be interpreted as I<beginning-of-line>.
+
+ 'a^b$c' ==> (no change)
+
=back
Each C<$c> can be any of :
=over 4
-=item A hash reference, with wanted metacharacter group names (described above) as keys and booleans as values ;
+=item *
-=item An array reference containing the list of wanted metacharacter classes ;
+A hash reference, with wanted metacharacter group names (described above) as keys and booleans as values ;
-=item A plain scalar, when only one group is required.
+=item *
+
+An array reference containing the list of wanted metacharacter classes ;
+
+=item *
+
+A plain scalar, when only one group is required.
=back
=over 4
-=item C<'single'> will capture all unescaped I<"exactly one"> metacharacters, i.e. C<?> for wildcards or C<_> for SQL ;
+=item *
+
+C<'single'> will capture all unescaped I<"exactly one"> metacharacters, i.e. C<?> for wildcards or C<_> for SQL ;
'a???b\\??' ==> 'a(.)(.)(.)b\\?(.)'
'a___b\\__' ==> 'a(.)(.)(.)b\\_(.)'
-=item C<'any'> will capture all unescaped I<"any"> metacharacters, i.e. C<*> for wildcards or C<%> for SQL ;
+=item *
+
+C<'any'> will capture all unescaped I<"any"> metacharacters, i.e. C<*> for wildcards or C<%> for SQL ;
'a***b\\**' ==> 'a(.*)b\\*(.*)'
'a%%%b\\%%' ==> 'a(.*)b\\%(.*)'
-=item C<'greedy'>, when used in conjunction with C<'any'>, will make the C<'any'> captures greedy (by default they are not) ;
+=item *
+
+C<'greedy'>, when used in conjunction with C<'any'>, will make the C<'any'> captures greedy (by default they are not) ;
'a***b\\**' ==> 'a(.*?)b\\*(.*?)'
'a%%%b\\%%' ==> 'a(.*?)b\\%(.*?)'
-=item C<'brackets'> will capture matching C<{ ... , ... }> alternations.
+=item *
+
+C<'brackets'> will capture matching C<{ ... , ... }> alternations.
'a{b\\},\\{c}' ==> 'a(b\\}|\\{c)'
my $do = $config->{do};
my $e = $config->{escape};
$wc =~ s/(?<!\\)((?:\\\\)*[^\w\s\\$e])/\\$1/g;
- return $self->_sql($wc) if $do->{sql};
- $wc = $self->_jokers($wc) if $do->{jokers};
+ if ($do->{jokers}) {
+ $wc = $self->_jokers($wc);
+ } elsif ($do->{sql}) {
+ $wc = $self->_sql($wc);
+ }
if ($do->{brackets}) {
$wc = $self->_bracketed($wc);
} elsif ($do->{commas}) {
Vincent Pit, C<< <perl at profvince.com> >>, L<http://www.profvince.com>.
-You can contact me by mail or on #perl @ FreeNode (vincent or Prof_Vince).
+You can contact me by mail or on C<irc.perl.org> (vincent).
=head1 BUGS
projects / perl / modules / Regexp-Wildcards.git / blobdiff