Config::*

Alternatively, you can use data serialization/persistance modules, such as YAML, Data::Denter, Storable, or Data::Dumper.

Take a look at do FILENAME.

For extra redability, have the config file return a hash reference, like this:

{
    foo => 1,
    bar => "frolicsome",
}
[download]

OTOH, hash items are almost as easy to handle than individual variables are. For example, if your hash is %v, then $v{'a'} (or even $v{a}) does the same as your $a would have done.

In that perspective, virtually any Config::* module might do. Or YAML. Even a simple CSV or tab delimited textfile would work.

The next code saves and loads a hash to and from a tab delimited text file — provided the data contains neither a tab or a newline:

sub save {
    my($file, $data) = @_;
    local *FH;
    open FH, ">$file" or die "Can't open file $file: $!";
    local($\, $,) = ("\n", "\t");
    foreach my $key (sort keys %$data){
        print FH $key, $data->{$key};
    }
}

sub load {
    my($file) = @_;
    local *FH;
    my %hash;
    open FH, "<$file" or die "Can't open file $file: $!";
    local $/ = "\n";
    while(<FH>) {
        chomp;
        my($key, $value) = split /\t/;
        $hash{$key} = $value;
    }
    return wantarray ? %hash : \%hash;
}
[download]

Whenever I need my program to read and save settings to a file, I like to use XML::Simple. Basically, you can dump a hashref / array ref or any combination thereof into a file. Then, you can read it back into an array / hash as well. Plus, with all the XML modules / packages out there (and for languages other then Perl) it becomes very easy to interface with your config files.

For instance, by using the XML out function, you could change:

my $data = {
             things => [
                         { foo => 'bar' },
                         { foo => 'baz' },
                         { foo => 'bam' },
                       ]
           };
[download]

Into XML like:

<things>
  <foo>bar</foo>
  <foo>baz</foo>
  <foo>bam</foo>                  
</things>
[download]

And then after calling the function to read XML you can access it right from the hash ref! And, again, I can't stop stressing to you how portable XML is. If, in the future, you want to do something with that data, expand the project, or create a new program to work with the data, it's very simple to do. Of course, using a Perl module for another type of config file will do this for you, but it won't be portable across platforms. (I wish everything were coded in perl, but let's be realistic. Sometimes you need to work with Java/C/ASP/Whatever)