You're confusing string literals (code) and strings (values).

In the source, "$2$1" is a string literal. It results in a string made up of the values of $1 and $2.

my $p = "$2$1";       # my $p = $2.$1;
                      # Doesn't change the value of $2 or $1.
[download]

In the source, "$ARGV[0]" is a string literal. It results in a string made up of the value of $ARGV[0].

my $p = "$ARGV[0]";   # my $p = "".$ARGV[0];
                      # Doesn't change the value of $ARGV[0].
[download]

If you want process the value of a variable for $1 and $2 and replace them, you are trying to implement a templating system. There's a one that matches your specs called String::Interpolate.

use String::Interpolate qw( interpolate);

my $t = '$1$2';
  or 
my $t = $ARGV[0];

my $p = interpolate($t);
[download]

Thank you very much! String::Interpolate worked in conjunction with "replace()" code used by methods 4 & 5. We new about the string literal vs string value, but we didn't know how to "cast" it (not mentioned in any of the docs), so we'd hoped Perl would figure it out from context like it does for so many other type conversions. You have saved us. Many thanks again.

Here's the modified code for others reference:

use String::Interpolate qw( interpolate );

...[snip]...

# Method 4: worked! (not global)
#my ($before, $after) = $regex =~ m{/(.*)/(.*)/};
#$filename = replace($filename, $before, sub {interpolate($after)},0);

# Method 5: worked! (global)
my ($before, $after) = $regex =~ m{/(.*)/(.*)/};
$filename = replace($filename, $before, sub {interpolate($after)},1);
[download]

Any ideas to make capture groups work when patterns defined in INI?

Try

use Config::IniFiles;

my $global_ini_data = Config::IniFiles->new( -file => "test.ini" );
my $regex           = $global_ini_data->val( 'client1', 'rename' );
my $filename        = "201306051200foobar.dat";

eval "sub vodoo { \$_[0] =~ $regex }";
vodoo ( $filename ); # this does in-place edit.

print $filename,$/;
__END__
060520.1200foobar.dat
[download]

If you want a string to be a command, you have to compile it - with string eval. Just the same way as any other perl source is compiled.

update

I admit no having read through all of your code. If you have only one substitution per filename, you could get around with

eval "\$filename =~ $regex";
die $@ if $@;
[download]

Having multiple patterns and clients, you surely don't want to have a named subroutine for each of them. You could construct a dispatch table with

sub makesub {
    # my ($client, $regex) = @_; update: wrong, we have 1 param
    my $regex = shift;
    my $sub = eval "sub { \$_[0] =~ $regex }";
    die $@ if $@;
    return $sub;
}
[download]

and populate a hash with the client identifier as key and the resulting anonymous sub as value, which you then call. Like so:

$hash{$client} = makesub($regex);
$hash{$client}->($filename); # $filename changed
[download]

We'd seen dispatch table mentioned in our design patterns book and it was one of the ideas we'd thought we'd pursue if we couldn't figure out the interpolation issue. Not having done a dispatch table before your code example will help--thanks. I'll read up on this for future reference.

As an additional suggestion, for this sort of problem, you might also wish to make use of the named capture buffers feature available since Perl 5.10. This way you are not stuck trying to keep brackets in the same relative position for each regexp across many config files. For example, parsing a date:

my $re = qr/(?<yyyy>\d{4})(?<mm>\d{2}(?<dd>\d{2})/;
printf "The date was %04d-%02d-%02d", $+{yyyy}, $+{mm}, $+{dd};
[download]

If you have to support a different format that is mm-dd-yyyy, for example, you're fine as long as you put the (?<name>...) capture buffers in the correct places.