+ 'brackets' converts all matching "{ ... , ... }" brackets to "(?: ... |
+ ... )" alternations. If some brackets are unbalanced, it tries to
+ substitute as many of them as possible, and then escape the remaining
+ unmatched "{" and "}". 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\\}'
+
+ 'groups' keeps the parenthesis "( ... )" 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)
+
+ Each $c can be any of :
+
+ A hash reference, with wanted metacharacter group names (described
+ above) as keys and booleans as values ;
+ An array reference containing the list of wanted metacharacter classes ;
+ A plain scalar, when only one group is required.
+
+ When "set" is present, the classes given as its value replace the
+ current object options. Then the "add" classes are added, and the "rem"
+ classes removed.
+
+ Passing a sole scalar $what is equivalent as passing "set => $what". No
+ argument means "set => [ ]".
+
+ $rw->do(set => 'jokers'); # Only translate jokers.
+ $rw->do('jokers'); # Same.
+ $rw->do(add => [ qw/sql commas/ ]); # Translate also SQL and commas.
+ $rw->do(rem => 'jokers'); # Specifying both 'sql' and 'jokers' is useless.
+ $rw->do(); # Translate nothing.
+
+ "type $type"
+ Notifies to convert the metacharacters that corresponds to the
+ predefined type $type. $type can be any of 'jokers', 'sql', 'commas',
+ 'brackets', 'win32' or 'unix'. An unknown or undefined value defaults to
+ 'unix', except for 'dos', 'os2', 'MSWin32' and 'cygwin' that default to
+ 'win32'. This means that you can pass $^O as the $type and get the
+ corresponding shell behaviour. Returns the object.
+
+ $rw->type('win32'); # Set type to win32.
+ $rw->type(); # Set type to unix.
+
+ "capture [ $captures | set => $c1, add => $c2, rem => $c3 ]"
+ Specifies the list of atoms to capture. This method works like "do",
+ except that the classes are different :
+
+ 'single' will capture all unescaped *"exactly one"* metacharacters, i.e.
+ "?" for wildcards or "_" for SQL ;
+ 'a???b\\??' ==> 'a(.)(.)(.)b\\?(.)'
+ 'a___b\\__' ==> 'a(.)(.)(.)b\\_(.)'
+
+ 'any' will capture all unescaped *"any"* metacharacters, i.e. "*" for
+ wildcards or "%" for SQL ;
+ 'a***b\\**' ==> 'a(.*)b\\*(.*)'
+ 'a%%%b\\%%' ==> 'a(.*)b\\%(.*)'
+
+ 'greedy', when used in conjunction with 'any', will make the 'any'
+ captures greedy (by default they are not) ;
+ 'a***b\\**' ==> 'a(.*?)b\\*(.*?)'
+ 'a%%%b\\%%' ==> 'a(.*?)b\\%(.*?)'
+
+ 'brackets' will capture matching "{ ... , ... }" alternations.
+ 'a{b\\},\\{c}' ==> 'a(b\\}|\\{c)'
+
+ $rw->capture(set => 'single'); # Only capture "exactly one" metacharacters.
+ $rw->capture('single'); # Same.
+ $rw->capture(add => [ qw/any greedy/ ]); # Also greedily capture "any" metacharacters.
+ $rw->capture(rem => 'greedy'); # No more greed please.
+ $rw->capture(); # Capture nothing.
+
+ "convert $wc [ , $type ]"
+ Converts the wildcard expression $wc into a regular expression according
+ to the options stored into the Regexp::Wildcards object, or to $type if
+ it's supplied. It successively escapes all unprotected regexp special
+ characters that doesn't hold any meaning for wildcards, then replace
+ 'jokers' or 'sql' and 'commas' or 'brackets' (depending on the "do" or
+ "type" options), all of this by applying the 'capture' rules specified
+ in the constructor or by "capture".