NAME
    Config::Hash

DESCRIPTION
    Handle config files containing Perl hashes

SYNOPSIS
    Read, parse and merge config files containing Perl hashes:

        my $c = Config::Hash->new( filename => 'MyApp.conf' );
        my $user = $c->get('mysql.test.user');
        my $pass = $c->get('mysql.test.pass');

        # The contents of the config file named MyApp.conf:
        # {
        #   mysql => {
        #       test => {
        #           user => 'rick',
        #           pass => 'james'
        #       }
        #   }
        # };

    Manually initialize the config data:

        my $c = Config::Hash->new(
            data => {
                user => 'james',
                pass => 'rick',
                ips  => {
                    alpha => '127.0.0.1',
                    beta  => '10.0.0.2'
                }
              }
        );

        say "Beta is at: " . $c->get('ips.beta');

    Merge data with config files:

        my $c = Config::Hash->new(
            data => { server => 'localhost' },
            filename => 'MyApp.conf'
        );

    In this case the contents of the file will merge with the data hash,
    with precedent given to the config file.

DESCRIPTION
    Simple yet powerful config module. Why simple? Because it uses Perl
    hashes. Why powerful? Because it uses Perl hashes.

MERGING
    Config::Hash merges two hashes so that the second hash overrides the
    first one. Let's say we have two hashes, A and B. Merging will proceed
    as follows:

    *   Each key in B that doesn't contain a hash will be copied to A.
        Duplicate keys will be overwriten in favor of B.

    *   Each key in B that contains a hash will be merged using the same
        algorithm described here.

    Example:

        # Example 1
        $a      = { a => 1, b => 2 };
        $b      = { a => 3 };
        $merged = { a => 2, b => 2 };

        # Example 2
        $a      = { a => { b => 'foo' } };
        $b      = { a => { b => 'baz' }, c => 'bar' };
        $merged = { a => { b => 'baz', c => 'bar' } };    # Hashes merge

        # Example 3:
        $a      = { a => [ 1, 2, 3 ] };
        $b      = { a => [] };
        $merged = { a => [] };            # Non-hashes overwrite the other key

ATTRIBUTES
  filename
    Full pathname of the config file.

        my $c = Config::Hash->new( filename => 'conf/stuff.pl' );

    It does not matter what file extension is used, as long as the file
    contains a legitimate Perl hash. Example:

        # conf/stuff.pl
        {
            redis => 1,
            mongo => {
                table => 'stuff',
                data  => 'general'
            }
        };

  data
    Load a Perl hash instead of a file.

        my $c = Config::Hash->new(
            data => {
                redis => 1,
                mysql => {
                    user => 'test',
                    pass => 'secret'
                }
            }
        );

  mode
    Application mode or modes. Files that match the modes will be merged
    into the configuration data. Example:

        my $c = Config::Hash->new(
            filename => 'app.conf',
            mode     => 'development'
        );

    This will look first for a file "app.conf", then for
    "app_development.conf" and both files will be merged. "mode" can be a
    comma separated list of modes, so:

        my $c = Config::Hash->new(
            filename => 'app.conf',
            mode     => 'development, local, test'
        );

    will look for and merge "app.conf", "app_development.conf",
    "app_local.conf" and "app_test.conf".

  param
    Allows for passing variables to the config hash.

        my $c = Config::Hash->new(
            filename => 'app.conf',
            param    => { base_path => '/path/to/stuff' }
        );

    Each key of the "param" hash can be accessed via a function with the
    same name inside the config file:

        # app.conf

        {
            name => 'Rick James',
            path => base_path() . 'rick/james'
        };

    The evaluation of the config code is isolated from the rest of the code,
    so it doesn't have access to $self. If you need to use $self, you'll
    have to pass it in the "params" hash and then reference it with "self()"

    Note: You will have to add "()" to the function name, otherwise Perl
    will not recognize it as such and will die with an error.

  separator
    A regular expression for the value separator used by "get". The default
    is "qr/\./", i.e. a dot.

SUBROUTINES
  get
    Get a value from the config hash.

        my $value = $c->get('bar.foo.baz');
        my $same  = $c->get('bar')->{foo}->{baz};
        my $again = $c->data->{bar}->{foo}->{baz};

    By default the subhash separator is a dot, but this can be changed via
    the "separator" attribute.

        my $c = Config::Hash->new(
            filename  => 'app.conf',
            separator => qr/\-/
        );

        my $value = $c->get('bar-foo-baz');

AUTHOR
    minimalist - minimal@cpan.org

LICENSE
    Same as Perl itself.