Wildcards.pm

   1 package Regexp::Wildcards;
   2
   3 use strict;
   4 use warnings;
   5
   6 use Text::Balanced qw/extract_bracketed/;
   7
   8 =head1 NAME
   9
  10 Regexp::Wildcards - Converts wildcards expressions to Perl regular expressions.
  11
  12 =head1 VERSION
  13
  14 Version 0.02
  15
  16 =cut
  17
  18 our $VERSION = '0.02';
  19
  20 =head1 SYNOPSIS
  21
  22     use Regexp::Wildcards qw/wc2re/;
  23
  24     my $re;
  25     $re = wc2re 'a{b.,c}*' => 'unix';   # Do it Unix style.
  26     $re = wc2re 'a.,b*'    => 'win32';  # Do it Windows style.
  27     $re = wc2re '*{x,y}.'  => 'jokers'; # Process the jokers & escape the rest.
  28
  29 =head1 DESCRIPTION
  30
  31 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 wildcards 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<{,}>, and uses the backspace (C<\>) as an escape character. Wrappers are provided to mimic the behaviour of Windows and Unix shells.
  32
  33 =head1 EXPORT
  34
  35 Four functions are exported only on request : C<wc2re>, C<wc2re_unix>, C<wc2re_win32> and C<wc2re_jokers>.
  36
  37 =cut
  38
  39 use base qw/Exporter/;
  40
  41 my %types = (
  42  'jokers' => \&wc2re_jokers,
  43  'unix'   => \&wc2re_unix,
  44  'win32'  => \&wc2re_win32
  45 );
  46
  47 our @EXPORT      = ();
  48 our @EXPORT_OK   = ('wc2re', map { 'wc2re_' . $_ } keys %types);
  49 our @EXPORT_FAIL = qw/extract do_jokers do_commas do_brackets do_bracketed/;
  50 our %EXPORT_TAGS = ( all => [ @EXPORT_OK ] );
  51
  52 =head1 FUNCTIONS
  53
  54 =head2 C<wc2re_unix>
  55
  56 This function takes as its only argument the wildcard string to process, and returns the corresponding regular expression according to standard Unix wildcard rules. It successively escapes all unprotected regexp special characters that doesn't hold any meaning for wildcards, turns jokers into their regexp equivalents, and changes bracketed blocks into C<(?:|)> alternations. If brackets are unbalanced, it will try to substitute as many of them as possible, and then escape the remaining C<{> and C<}>. Commas outside of any bracket-delimited block will also be escaped.
  57
  58     # This is a valid brackets expression which is correctly handled.
  59     print 'ok' if wc2re_unix('{a{b,c}d,e}') eq '(?:a(?:b|c)d|e)';
  60
  61 Unbalanced bracket expressions can always be rescued, but it may change completely its meaning. For example :
  62
  63     # The first comma is replaced, and the remaining brackets and comma are
  64     # escaped.
  65     print 'ok' if wc2re_unix('{a\\{b,c}d,e}') eq '(?:a\\{b|c)d\\,e\\}';
  66
  67     # All the brackets and commas are escaped.
  68     print 'ok' if wc2re_unix('{a{b,c\\}d,e}') eq '\\{a\\{b\\,c\\}d\\,e\\}';
  69
  70 =cut
  71
  72 sub wc2re_unix {
  73  my ($re) = @_;
  74  return unless defined $re;
  75  $re =~ s/(?<!\\)((?:\\\\)*[^\w\s?*\\\{\},])/\\$1/g;
  76  return do_bracketed(do_jokers($re));
  77 }
  78
  79 =head2 C<wc2re_win32>
  80
  81 Similar to the precedent, but for Windows wildcards. Bracketed blocks are no longer handled (which means that brackets will be escaped), but you can provide a comma-separated list of items.
  82
  83     # All the brackets are escaped, and commas are seen as list delimiters.
  84     print 'ok' if wc2re_win32('{a{b,c}d,e}') eq '(?:\\{a\\{b|c\\}d|e\\})';
  85
  86 =cut
  87
  88 sub wc2re_win32 {
  89  my ($wc) = @_;
  90  return unless defined $wc;
  91  $wc =~ s/(?<!\\)((?:\\\\)*[^\w\s?*\\,])/\\$1/g;
  92  my $re = do_jokers($wc);
  93  if ($re =~ /(?<!\\)(?:\\\\)*,/) { # win32 allows comma-separated lists
  94   $re = '(?:' . do_commas($re) . ')';
  95  }
  96  return $re;
  97 }
  98
  99 =head2 C<wc2re_jokers>
 100
 101 This one only handles the C<?> and C<*> jokers. All other unquoted regexp metacharacters will be escaped.
 102
 103     # Everything is escaped.
 104     print 'ok' if wc2re_jokers('{a{b,c}d,e}') eq '\\{a\\{b\\,c\\}d\\,e\\}';
 105
 106 =cut
 107
 108 sub wc2re_jokers {
 109  my ($wc) = @_;
 110  $wc =~ s/(?<!\\)((?:\\\\)*[^\w\s?*\\])/\\$1/g;
 111  return do_jokers($wc);
 112 }
 113
 114 =head2 C<wc2re>
 115
 116 A generic function that wraps around all the different rules. The first argument is the wildcard expression, and the second one is the type of rules to apply, currently either C<unix>, C<win32> or C<jokers>. If the type is undefined, it defaults to C<unix>.
 117
 118 =cut
 119
 120 sub wc2re {
 121  my ($wc, $type) = @_;
 122  return unless defined $wc;
 123  $type ||= 'unix';
 124  return $types{lc $type}($wc);
 125 }
 126
 127 =head1 DEPENDENCIES
 128
 129 L<Text::Balanced>, which is bundled with perl since version 5.7.3
 130
 131 =head1 SEE ALSO
 132
 133 Some modules provide incomplete alternatives as helper functions :
 134
 135 L<Net::FTPServer> has a method for that. Only jokers are translated, and escaping won't preserve them.
 136
 137 L<File::Find::Match::Util> has a C<wildcar> function that compiles a matcher. Only handles C<*>.
 138
 139 L<Text::Buffer> has the C<convertWildcardToRegex> class method that handles jokers.
 140
 141 =head1 AUTHOR
 142
 143 Vincent Pit, C<< <perl at profvince.com> >>
 144
 145 =head1 BUGS
 146
 147 Please report any bugs or feature requests to
 148 C<bug-regexp-wildcards at rt.cpan.org>, or through the web interface at
 149 L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Regexp-Wildcards>.
 150 I will be notified, and then you'll automatically be notified of progress on
 151 your bug as I make changes.
 152
 153 =head1 SUPPORT
 154
 155 You can find documentation for this module with the perldoc command.
 156
 157     perldoc Regexp::Wildcards
 158
 159 =head1 COPYRIGHT & LICENSE
 160
 161 Copyright 2007 Vincent Pit, all rights reserved.
 162
 163 This program is free software; you can redistribute it and/or modify it
 164 under the same terms as Perl itself.
 165
 166 =cut
 167
 168 sub extract { extract_bracketed shift, '{',  qr/.*?(?:(?<!\\)(?:\\\\)*)(?={)/; }
 169
 170 sub do_jokers {
 171  local $_ = shift;
 172  # escape an odd number of \ that doesn't protect a regexp/wildcard special char
 173  s/(?<!\\)((?:\\\\)*\\(?:[\w\s]|$))/\\$1/g;
 174  # substitute ? preceded by an even number of \
 175  s/(?<!\\)((?:\\\\)*)\?/$1./g;
 176  # substitute * preceded by an even number of \
 177  s/(?<!\\)((?:\\\\)*)\*+/$1.*/g;
 178  return $_;
 179 }
 180
 181 sub do_commas {
 182  local $_ = shift;
 183  # substitute , preceded by an even number of \
 184  s/(?<!\\)((?:\\\\)*),/$1|/g;
 185  return $_;
 186 }
 187
 188 sub do_brackets {
 189  my $rest = shift;
 190  substr $rest, 0, 1, '';
 191  chop $rest;
 192  my ($re, $bracket, $prefix) = ('');
 193  while (($bracket, $rest, $prefix) = extract $rest and $bracket) {
 194   $re .= do_commas($prefix) . do_brackets($bracket);
 195  }
 196  $re .= do_commas($rest);
 197  return '(?:' . $re . ')';
 198 }
 199
 200 sub do_bracketed {
 201  my $rest = shift;
 202  my ($re, $bracket, $prefix) = ('');
 203  while (($bracket, $rest, $prefix) = extract $rest and $bracket) {
 204   $re .= $prefix . do_brackets($bracket);
 205  }
 206  $re .= $rest;
 207  $re =~ s/(?<!\\)((?:\\\\)*[\{\},])/\\$1/g;
 208  return $re;
 209 }
 210
 211 1; # End of Regexp::Wildcards