lib/Regexp/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.01
  15
  16 =cut
  17
  18 our $VERSION = '0.01';
  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 (or C<undef> if the source is invalid) 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<}>.
  57
  58 Unbalanced bracket expressions can always be rescued, but it may change completely its meaning. As a side effect, commas that first appear to be between brackets can be taken at the uppermost level, which invalidates the pattern. For example :
  59
  60     # The last orphaned } gets escaped, and the first comma is replaced.
  61     # We also need to escape the comma because unix doesn't allow them out
  62     # of brackets.
  63     print 'ok' if wc2re_unix('{a\\{b,c}d\\,e}') eq '(?:a\\{b|c)d\\,e\\}';
  64
  65     # All of the unprotected brackets are escaped, which means that we must
  66     # escape all the commas.
  67     print 'ok' if wc2re_unix('{a{b\\,c\\}d\\,e}') eq '\\{a\\{b\\,c\\}d\\,e\\}';
  68
  69 =cut
  70
  71 sub wc2re_unix {
  72  my ($re) = @_;
  73  return unless defined $re;
  74  $re =~ s/(?<!\\)((?:\\\\)*[^\w\s?*\\\{\},])/\\$1/g;
  75  return do_bracketed(do_jokers($re));
  76 }
  77
  78 =head2 C<wc2re_win32>
  79
  80 Similar to the precedent, but for Windows wildcards. Bracketed blocks are no longer handled (which means that brackets will be escaped), but you can still provide a comma-separated list of items.
  81
  82 =cut
  83
  84 sub wc2re_win32 {
  85  my ($wc) = @_;
  86  return unless defined $wc;
  87  $wc =~ s/(?<!\\)((?:\\\\)*[^\w\s?*\\,])/\\$1/g;
  88  my $re = do_jokers($wc);
  89  if ($re =~ /(?<!\\)(?:\\\\)*,/) { # win32 allows comma-separated lists
  90   $re = '(?:' . do_commas($re) . ')';
  91  }
  92  return $re;
  93 }
  94
  95 =head2 C<wc2re_jokers>
  96
  97 This one only handles the C<?> and C<*> jokers. All other unquoted regexp metacharacters will be quoted.
  98
  99 =cut
 100
 101 sub wc2re_jokers {
 102  my ($wc) = @_;
 103  $wc =~ s/(?<!\\)((?:\\\\)*[^\w\s?*\\])/\\$1/g;
 104  return do_jokers($wc);
 105 }
 106
 107 =head2 C<wc2re>
 108
 109 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>.
 110
 111 =cut
 112
 113 sub wc2re {
 114  my ($wc, $type) = @_;
 115  return unless defined $wc;
 116  $type ||= 'unix';
 117  return $types{lc $type}($wc);
 118 }
 119
 120 =head1 DEPENDENCIES
 121
 122 L<Text::Balanced>, which is bundled with perl since version 5.7.3
 123
 124 =head1 SEE ALSO
 125
 126 Some modules provide incomplete alternatives as helper functions :
 127
 128 L<Net::FTPServer> has a method for that. Only jokers are translated, and escaping won't preserve them.
 129
 130 L<File::Find::Match::Util> has a C<wildcar> function that compiles a matcher. Only handles C<*>.
 131
 132 L<Text::Buffer> has the C<convertWildcardToRegex> class method that handles jokers.
 133
 134 =head1 AUTHOR
 135
 136 Vincent Pit, C<< <perl at profvince.com> >>
 137
 138 =head1 BUGS
 139
 140 Please report any bugs or feature requests to
 141 C<bug-regexp-wildcards at rt.cpan.org>, or through the web interface at
 142 L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Regexp-Wildcards>.
 143 I will be notified, and then you'll automatically be notified of progress on
 144 your bug as I make changes.
 145
 146 =head1 SUPPORT
 147
 148 You can find documentation for this module with the perldoc command.
 149
 150     perldoc Regexp::Wildcards
 151
 152 =head1 COPYRIGHT & LICENSE
 153
 154 Copyright 2007 Vincent Pit, all rights reserved.
 155
 156 This program is free software; you can redistribute it and/or modify it
 157 under the same terms as Perl itself.
 158
 159 =cut
 160
 161 sub extract { extract_bracketed shift, '{',  qr/.*?(?:(?<!\\)(?:\\\\)*)(?={)/; }
 162
 163 sub do_jokers {
 164  local $_ = shift;
 165  # escape an odd number of \ that doesn't protect a regexp/wildcard special char
 166  s/(?<!\\)((?:\\\\)*\\(?:[\w\s]|$))/\\$1/g;
 167  # substitute ? preceded by an even number of \
 168  s/(?<!\\)((?:\\\\)*)\?/$1./g;
 169  # substitute * preceded by an even number of \
 170  s/(?<!\\)((?:\\\\)*)\*+/$1.*/g;
 171  return $_;
 172 }
 173
 174 sub do_commas {
 175  local $_ = shift;
 176  # substitute , preceded by an even number of \
 177  s/(?<!\\)((?:\\\\)*),/$1|/g;
 178  return $_;
 179 }
 180
 181 sub do_brackets {
 182  my $rest = shift;
 183  substr $rest, 0, 1, '';
 184  chop $rest;
 185  my ($re, $bracket, $prefix) = ('');
 186  while (($bracket, $rest, $prefix) = extract $rest and $bracket) {
 187   $re .= do_commas($prefix) . do_brackets($bracket);
 188  }
 189  $re .= do_commas($rest);
 190  return '(?:' . $re . ')';
 191 }
 192
 193 sub do_bracketed {
 194  my $rest = shift;
 195  my ($re, $bracket, $prefix) = ('');
 196  while (($bracket, $rest, $prefix) = extract $rest and $bracket) {
 197   return undef if $prefix =~ /(?<!\\)((?:\\\\)*),/;
 198   $re .= $prefix . do_brackets($bracket);
 199  }
 200  return undef if $rest =~ /(?<!\\)((?:\\\\)*),/;
 201  $re .= $rest;
 202  $re =~ s/(?<!\\)((?:\\\\)*[\{\}])/\\$1/g;
 203  return $re;
 204 }
 205
 206 1; # End of Regexp::Wildcards