But you might also want to look at Other config modules already on CPAN, and specifically Config::General.

Config::General looks very nice indeed...

It even comes with Config::General::Extended which seems to do the "AUTOLOAD" trick you mentioned...
--
Mike

broquaint

I was recently introduced to the Singleton module. It does a lot of what you want.

If you want to roll your own 'config stuff' (business specific?) then this module may be of interest.

A quick scan of them indicates that none of them will help me avoid either hard-coding config file paths into my modules, or needing to pass config hashes/objects into my modules so they know what's in the config file as well as my program.

Time to put my code where my mouth is and attempt what I suggest above.... should be interesting.

Don't despair. Put together the Class::Singleton and AppConfig suuguestions. Then you can just have:

package Some::Module;

use MyConfig;

## ...
sub do_something {
  my $self = shift;
  my $config = MyConfig->instance;

  $self->_blah_de_blah() if $config->do_blah();

  return $self->bloop() unless $config->no_bloop();
}
[download]

Nobody had to pass anyone else anything.

For an example of how to set this up with Class::Singleton (using just hardcoded info), see Re: how to make a universally inherited method?. For non-hardcoded info, just have it call some configuration reading routine to set the data.

The usage suggested by Fletch is fairly simple and quite powerful. You just need to setup (read in) your configuration once and then it's available to all your modules in that process.

Chris
M-x auto-bs-mode

package Config;

use strict;                           # always be strict
use Carp;
use vars qw ($AUTOLOAD);

my ($config);                        # our global config object

my (%config);                        # config hash, the actual config 
+data

sub new {

    my $proto = shift;
    my $class = ref($proto) || $proto;

    # setup the new object

    my $self = {
        %config,
           };
    
    bless ($self, $class);
    return ($self);
}

sub AUTOLOAD {
    my $self = $config;
    my $type = ref($self);
    my $name = $AUTOLOAD;

    $name =~ s/.*://;      # strip fully-qualified portion

    unless ( defined $self->{$name} ) {
      croak "Can't access `$name' field in class $type";
    }

    # just return the attribute
    return $self->{$name};
}

sub read_config {
  my $conf_file = shift;

  open (FILE, "$conf_file") || return 0;

  while (<FILE>) {
    if ( /^(\w+)\s*=?\s*(.*)$/ ) {
      $config->{$1} = $2;
      carp "w00t! set $1 to $2";
    }
  }

  close (FILE);

  return 1;
}

# package constructor

BEGIN {

  my (@config_files);

  $config = Config->new;

  # we have an empty configuration object, lets read in
  # a config file

  # if we fail, fail silently, give the user code a chance to call rea
+d_config
  # with it's own specifier

  @config_files = qw ( ../etc/journal.conf /usr/local/etc/journal.conf
+ );

  # try each one until we succeed
  foreach (@config_files) {
    if (read_config ($_)) {
      last;
    }
  }

  # error check
  if (! $config ) {
    carp "Failed to get config";
  }

}

# keep stuff happy

1;
[download]

rootdir = /usr/tmp
[download]

use Config;

print "Root Directory is " . Config->rootdir . "\n";
[download]

The other bit of my criteria, allowing for a user override of the config file I haven't yet nutted out. I have a feeling it's going to cause me problems, given that some of my modules need config data during their class constructers. I'll keep on that.

May be it is late reply but anyway. Do not name your module Config. Perl distro already has core module Config. By giving your module same name you just asking for troubles. It is almost as bad as if you created your own perl module named lib.

--
Ilya Martynov (http://martynov.org/)