Author image Jean-Michel Hiver


Config::Mini - Very simple INI-style configuration parser


In your config file:

  # this is a comment
  # these will go in section [general] which is the default
  foo = bar
  baz = buz
  key1 = val1
  key2 = val2
  key3 = val3
  key4 = arrayvalue
  key4 = arrayvalue2
  key4 = arrayvalue3


In your perl code:

use Config::Mini; my $config = Config::Mini->new ('sample.conf'); print "These are the sections which are defined in the config file:\n"; print join "\n", $config->sections();

# will print 'arrayvalue' print $config->section ('section2')->{'key4'}; print $config->section ('section2')->{'__key4'}->[2];


By default, Config::Mini turns sections into hashes. For instance, the following section:

  foo = bar
  foo = bar2
  baz = buz

Will be turned into:

    foo   => 'bar',
    baz   => 'buz',
    __foo => [ 'bar', 'bar2' ],
    __baz => [ 'buz' ],

When you write your own objects, having this convention is fine. However, you may want to instantiate other objects from CPAN than your own. For example, a Cache::MemCached is constructed like this in Perl:

  $memd = Cache::Memcached->new {
    'servers'            => [ "", "", "" ]
    'debug'              => 0,
    'compress_threshold' => 10_000,

So having the following config won't do:

  %package = Cache::Memcached
  servers  =
  servers  =
  servers  =
  debug    = 0
  compress_threshold = 10_000

Because Cache::Memcached expects 'servers' to be an array, not a scalar.

In this case, you can do the following:

  %package = Cache::Memcached
  @servers =
  @servers =
  @servers =
  debug    = 0
  compress_threshold = 10_000

This will let Config::Mini know that 'servers' is meant to be an array reference.

If you want, you can also let it know that debug and compress_threshold are just scalars so it doesn't create the '__debug' and '__compress_threshold' attributes, using the dollar symbol:

  %package = Cache::Memcached
  @servers =
  @servers =
  @servers =
  $debug   = 0
  $compress_threshold = 10_000

The only problem now is that your configuration file is seriously starting to look like Perl, so I would recommend using these 'tricks' only where it's 100% necessary.

%include, %package, %constructor

You can use the following commands:

%include /path/to/file

Will include /path/to/file. Relative paths are supported (it will act as if you were chdir'ed to the current config file location), but wildcards at not (well, not yet).

%package My::Package::Name

Will attempt to create an object rather than a file name. For example:

  %package = Rose::DB
  %constructor = register_db
  domain   = development
  type     = main
  driver   = mysql
  database = dev_db
  host     = localhost
  username = devuser
  password = mysecret

%constructor constructor_name

Most Perl objects use new() for their constructor method, however sometimes the constructor is called something else. If %constructor is specified, then it will be called instead of new()

%hashref = true

Some folks prefer to construct their objects this way:

  my $object = Foo->new ( { %args } );

Instead of

  my $object = Foo->new ( %args );

This directive allows you to accomodate them (Cache::Cache comes to mind). So for example, you'd have:

  %package = Cache::FileCache
  %hashref = true
  namespace = MyNamespace
  default_expires_in = 600

%args = key1 key2 key3

Some modules have constructors where you don't pass a hash, but a simple list of arguments. For example:

    File::BLOB->from_file( 'filename.txt' );

In this case, you can do:

  %package = File::Blob
  %constructor = from_file
  %args filename
  filename = filename.txt

my $config = Config::Mini->new ($config_file);

Creates a new Config::Mini object.

@config_sections = $config->sections();

Returns a list of section names.

my $hash = $config->section ($section_name);

Returns a hashref (or an object) which represents this config section.


If you don't want to use the OO-style, you can use the functions below.

Config::Mini::parse_file ($filename)

Parses config file $filename

Config::Mini::parse_data (@data)

Parses @data

Config::Mini::get ($context, $key)

Returns the value for $key in $context.

Returns the value as an array if the requested value is an array.

Return the first value otherwise.

Config::Mini::instantiate ($context)

If $context is used to describe an object, Config::Mini will try to instantiate it.

If $section contains a "package" attribute, Config::Mini will try to load that package and call a new() method to instantiate the object.

Otherwise, it will simply return a hash reference.

Values can be considered as a scalar or an array. Hence, Config::Mini uses <attribute_name> for scalar values and '__<attribute_name>' for array values.

Config::Mini::select ($regex)

Selects all section entries matching $regex, and returns a list of instantiated objects using instantiate() for each of them.


Copyright 2006 - Jean-Michel Hiver All rights reserved

This module is free software and is distributed under the same license as Perl itself. Use it at your own risk.