NAME

ConfigReader::Simple - Simple configuration file parser

SYNOPSIS

        use ConfigReader::Simple;

        # parse one file
        $config = ConfigReader::Simple->new("configrc", [qw(Foo Bar Baz Quux)]);

        # parse multiple files, in order
        $config = ConfigReader::Simple->new_multiple(
                Files => [ "global", "configrc" ], 
                Keys  => [qw(Foo Bar Baz Quux)]
                );

        my @directives = $config->directives;

        $config->get( "Foo" );
   
   if( $config->exists( "Bar" ) )
                {
                print "Bar was in the config file\n";
                }
   

DESCRIPTION

   C<ConfigReader::Simple> reads and parses simple configuration files. It's
   designed to be smaller and simpler than the C<ConfigReader> module
   and is more suited to simple configuration files.

METHODS

new ( FILENAME, DIRECTIVES )

Creates a ConfigReader::Simple object.

FILENAME tells the instance where to look for the configuration file.

DIRECTIVES is an optional argument and is a reference to an array. Each member of the array should contain one valid directive. A directive is the name of a key that must occur in the configuration file. If it is not found, the module will die. The directive list may contain all the keys in the configuration file, a sub set of keys or no keys at all.

The new method is really a wrapper around new_multiple.

new_multiple( Files => ARRAY_REF, Keys => ARRAY_REF )

Create a configuration object from several files listed in the anonymous array value for the Files key. The module reads the files in the same order that they appear in the array. Later values override earlier ones. This allows you to specify global configurations which you may override with more specific ones:

        ConfigReader::Simple->new_multiple(
                Files => [ qw( /etc/config /usr/local/etc/config /home/usr/config ) ],
                );

This function carps if the values are not array references.

parse( FILENAME )

This does the actual work. No parameters needed.

This is automatically called from new(), although you can reparse the configuration file by calling parse() again.

get( DIRECTIVE )

Returns the parsed value for that directive. For directives which did not have a value in the configuration file, get returns the empty string.

set( DIRECTIVE, VALUE )

Sets the value for DIRECTIVE to VALUE. The DIRECTIVE need not already exist. This overwrites previous values.

unset( DIRECTIVE )

Remove the value from DIRECTIVE, which will still exist. It's value is undef. If the DIRECTIVE does not exist, it will not be created. Returns FALSE if the DIRECTIVE does not already exist, and TRUE otherwise.

remove( DIRECTIVE )

Remove the DIRECTIVE. Returns TRUE is DIRECTIVE existed and FALSE otherwise.

directives()

Returns a list of all of the directive names found in the configuration file. The keys are sorted ASCII-betically.

exists( DIRECTIVE )

Return TRUE if the specified directive exists, and FALSE otherwise.

clone

Return a copy of the object. The new object is distinct from the original.

_validate_keys ( )

If any keys were declared when the object was constructed, check that those keys actually occur in the configuration file.

LIMITATIONS/BUGS

Directives are case-sensitive.

If a directive is repeated, the first instance will silently be ignored.

CREDITS

Kim Ryan <kimaryan@ozemail.com.au> adapted the module to make declaring keys optional. Thanks Kim.

Alan W. Jurgensen <jurgensen@berbee.com> added a change to allow the NAME=VALUE format in the configuration file.

AUTHORS

Bek Oberin <gossamer@tertius.net.au>

now maintained by brian d foy <bdfoy@cpan.org>

COPYRIGHT

Copyright (c) 2000 Bek Oberin. All rights reserved.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.