Initial Commit

database/perl/vendor/lib/Config/Any.pm

@@ -0,0 +1,390 @@
+package Config::Any;
+
+use strict;
+use warnings;
+
+use Carp;
+use Module::Pluggable::Object ();
+
+our $VERSION = '0.32';
+
+=head1 NAME
+
+Config::Any - Load configuration from different file formats, transparently
+
+=head1 SYNOPSIS
+
+    use Config::Any;
+
+    my $cfg = Config::Any->load_stems({stems => \@filepath_stems, ... });
+    # or
+    my $cfg = Config::Any->load_files({files => \@filepaths, ... });
+
+    for (@$cfg) {
+        my ($filename, $config) = %$_;
+        $class->config($config);
+        warn "loaded config from file: $filename";
+    }
+
+=head1 DESCRIPTION
+
+L<Config::Any|Config::Any> provides a facility for Perl applications and libraries
+to load configuration data from multiple different file formats. It supports XML, YAML,
+JSON, Apache-style configuration, Windows INI files, and even Perl code.
+
+The rationale for this module is as follows: Perl programs are deployed on many different
+platforms and integrated with many different systems. Systems administrators and end
+users may prefer different configuration formats than the developers. The flexibility
+inherent in a multiple format configuration loader allows different users to make
+different choices, without generating extra work for the developers. As a developer
+you only need to learn a single interface to be able to use the power of different
+configuration formats.
+
+=head1 INTERFACE
+
+=head2 load_files( \%args )
+
+    Config::Any->load_files( { files => \@files } );
+    Config::Any->load_files( { files => \@files, filter  => \&filter } );
+    Config::Any->load_files( { files => \@files, use_ext => 1 } );
+    Config::Any->load_files( { files => \@files, flatten_to_hash => 1 } );
+
+C<load_files()> attempts to load configuration from the list of files passed in
+the C<files> parameter, if the file exists.
+
+If the C<filter> parameter is set, it is used as a callback to modify the configuration
+data before it is returned. It will be passed a single hash-reference parameter which
+it should modify in-place.
+
+If the C<use_ext> parameter is defined, the loader will attempt to parse the file
+extension from each filename and will skip the file unless it matches a standard
+extension for the loading plugins. Only plugins whose standard extensions match the
+file extension will be used. For efficiency reasons, its use is encouraged, but
+be aware that you will lose flexibility -- for example, a file called C<myapp.cfg>
+containing YAML data will not be offered to the YAML plugin, whereas C<myapp.yml>
+or C<myapp.yaml> would be.
+
+When the C<flatten_to_hash> parameter is defined, the loader will return a hash
+keyed on the file names, as opposed to the usual list of single-key hashes.
+
+C<load_files()> also supports a 'force_plugins' parameter, whose value should be an
+arrayref of plugin names like C<Config::Any::INI>. Its intended use is to allow the use
+of a non-standard file extension while forcing it to be offered to a particular parser.
+It is not compatible with 'use_ext'.
+
+You can supply a C<driver_args> hashref to pass special options to a particular
+parser object. Example:
+
+    Config::Any->load_files( { files => \@files, driver_args => {
+        General => { -LowerCaseNames => 1 }
+    } )
+
+=cut
+
+sub load_files {
+    my ( $class, $args ) = @_;
+
+    unless ( $args && exists $args->{ files } ) {
+        warn "No files specified!";
+        return;
+    }
+
+    return $class->_load( $args );
+}
+
+=head2 load_stems( \%args )
+
+    Config::Any->load_stems( { stems => \@stems } );
+    Config::Any->load_stems( { stems => \@stems, filter  => \&filter } );
+    Config::Any->load_stems( { stems => \@stems, use_ext => 1 } );
+    Config::Any->load_stems( { stems => \@stems, flatten_to_hash => 1 } );
+
+C<load_stems()> attempts to load configuration from a list of files which it generates
+by combining the filename stems list passed in the C<stems> parameter with the
+potential filename extensions from each loader, which you can check with the
+C<extensions()> classmethod described below. Once this list of possible filenames is
+built it is treated exactly as in C<load_files()> above, as which it takes the same
+parameters. Please read the C<load_files()> documentation before using this method.
+
+=cut
+
+sub load_stems {
+    my ( $class, $args ) = @_;
+
+    unless ( $args && exists $args->{ stems } ) {
+        warn "No stems specified!";
+        return;
+    }
+
+    my $stems = delete $args->{ stems };
+    my @files;
+    for my $s ( @$stems ) {
+        for my $ext ( $class->extensions ) {
+            push @files, "$s.$ext";
+        }
+    }
+
+    $args->{ files } = \@files;
+    return $class->_load( $args );
+}
+
+sub _load {
+    my ( $class, $args ) = @_;
+    croak "_load requires a arrayref of file paths" unless $args->{ files };
+
+    my $force = defined $args->{ force_plugins };
+    if ( !$force and !defined $args->{ use_ext } ) {
+        warn
+            "use_ext argument was not explicitly set, as of 0.09, this is true by default";
+        $args->{ use_ext } = 1;
+    }
+
+    # figure out what plugins we're using
+    my @plugins = $force
+        ? map { eval "require $_;"; $_; } @{ $args->{ force_plugins } }
+        : $class->plugins;
+
+    # map extensions if we have to
+    my ( %extension_lut, $extension_re );
+    my $use_ext_lut = !$force && $args->{ use_ext };
+    if ( $use_ext_lut ) {
+        for my $plugin ( @plugins ) {
+            for ( $plugin->extensions ) {
+                $extension_lut{ $_ } ||= [];
+                push @{ $extension_lut{ $_ } }, $plugin;
+            }
+        }
+
+        $extension_re = join( '|', keys %extension_lut );
+    }
+
+    # map args to plugins
+    my $base_class = __PACKAGE__;
+    my %loader_args;
+    for my $plugin ( @plugins ) {
+        $plugin =~ m{^$base_class\::(.+)};
+        $loader_args{ $plugin } = $args->{ driver_args }->{ $1 } || {};
+    }
+
+    my @results;
+
+    for my $filename ( @{ $args->{ files } } ) {
+
+        # don't even bother if it's not there
+        next unless -f $filename;
+
+        my @try_plugins = @plugins;
+
+        if ( $use_ext_lut ) {
+            $filename =~ m{\.($extension_re)\z};
+
+            if ( !$1 ) {
+                $filename =~ m{\.([^.]+)\z};
+                croak "There are no loaders available for .${1} files";
+            }
+
+            @try_plugins = @{ $extension_lut{ $1 } };
+        }
+
+        # not using use_ext means we try all plugins anyway, so we'll
+        # ignore it for the "unsupported" error
+        my $supported = $use_ext_lut ? 0 : 1;
+        for my $loader ( @try_plugins ) {
+            next unless $loader->is_supported;
+            $supported = 1;
+            my @configs;
+            my $err = do {
+                local $@;
+                @configs = eval { $loader->load( $filename, $loader_args{ $loader } ); };
+                $@;
+            };
+
+            # fatal error if we used extension matching
+            croak "Error parsing $filename: $err" if $err and $use_ext_lut;
+            next if $err or !@configs;
+
+            # post-process config with a filter callback
+            if ( $args->{ filter } ) {
+                $args->{ filter }->( $_ ) for @configs;
+            }
+
+            push @results,
+                { $filename => @configs == 1 ? $configs[ 0 ] : \@configs };
+            last;
+        }
+
+        if ( !$supported ) {
+            croak
+                "Cannot load $filename: required support modules are not available.\nPlease install "
+                . join( " OR ", map { _support_error( $_ ) } @try_plugins );
+        }
+    }
+
+    if ( defined $args->{ flatten_to_hash } ) {
+        my %flattened = map { %$_ } @results;
+        return \%flattened;
+    }
+
+    return \@results;
+}
+
+sub _support_error {
+    my $module = shift;
+    if ( $module->can( 'requires_all_of' ) ) {
+        return join( ' and ',
+            map { ref $_ ? join( ' ', @$_ ) : $_ } $module->requires_all_of );
+    }
+    if ( $module->can( 'requires_any_of' ) ) {
+        return 'one of '
+            . join( ' or ',
+            map { ref $_ ? join( ' ', @$_ ) : $_ } $module->requires_any_of );
+    }
+}
+
+=head2 finder( )
+
+The C<finder()> classmethod returns the
+L<Module::Pluggable::Object|Module::Pluggable::Object>
+object which is used to load the plugins. See the documentation for that module for
+more information.
+
+=cut
+
+sub finder {
+    my $class  = shift;
+    my $finder = Module::Pluggable::Object->new(
+        search_path => [ __PACKAGE__ ],
+        except      => [ __PACKAGE__ . '::Base' ],
+        require     => 1
+    );
+    return $finder;
+}
+
+=head2 plugins( )
+
+The C<plugins()> classmethod returns the names of configuration loading plugins as
+found by L<Module::Pluggable::Object|Module::Pluggable::Object>.
+
+=cut
+
+sub plugins {
+    my $class = shift;
+
+    # filter out things that don't look like our plugins
+    return grep { $_->isa( 'Config::Any::Base' ) } $class->finder->plugins;
+}
+
+=head2 extensions( )
+
+The C<extensions()> classmethod returns the possible file extensions which can be loaded
+by C<load_stems()> and C<load_files()>. This may be useful if you set the C<use_ext>
+parameter to those methods.
+
+=cut
+
+sub extensions {
+    my $class = shift;
+    my @ext
+        = map { $_->extensions } $class->plugins;
+    return wantarray ? @ext : \@ext;
+}
+
+=head1 DIAGNOSTICS
+
+=over
+
+=item C<No files specified!> or C<No stems specified!>
+
+The C<load_files()> and C<load_stems()> methods will issue this warning if
+called with an empty list of files/stems to load.
+
+=item C<_load requires a arrayref of file paths>
+
+This fatal error will be thrown by the internal C<_load> method. It should not occur
+but is specified here for completeness. If your code dies with this error, please
+email a failing test case to the authors below.
+
+=back
+
+=head1 CONFIGURATION AND ENVIRONMENT
+
+Config::Any requires no configuration files or environment variables.
+
+=head1 DEPENDENCIES
+
+L<Module::Pluggable::Object|Module::Pluggable::Object>
+
+And at least one of the following:
+L<Config::General|Config::General>
+L<Config::Tiny|Config::Tiny>
+L<JSON|JSON>
+L<YAML|YAML>
+L<JSON::Syck|JSON::Syck>
+L<YAML::Syck|YAML::Syck>
+L<XML::Simple|XML::Simple>
+
+=head1 INCOMPATIBILITIES
+
+None reported.
+
+=head1 BUGS AND LIMITATIONS
+
+No bugs have been reported.
+
+Please report any bugs or feature requests to
+C<bug-config-any@rt.cpan.org>, or through the web interface at
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=Config-Any>.
+
+=head1 AUTHOR
+
+Joel Bernstein <rataxis@cpan.org>
+
+=head1 CONTRIBUTORS
+
+This module was based on the original
+L<Catalyst::Plugin::ConfigLoader|Catalyst::Plugin::ConfigLoader>
+module by Brian Cassidy C<< <bricas@cpan.org> >>.
+
+With ideas and support from Matt S Trout C<< <mst@shadowcatsystems.co.uk> >>.
+
+Further enhancements suggested by Evan Kaufman C<< <evank@cpan.org> >>.
+
+=head1 LICENCE AND COPYRIGHT
+
+Copyright (c) 2006, Portugal Telecom C<< http://www.sapo.pt/ >>. All rights reserved.
+Portions copyright 2007, Joel Bernstein C<< <rataxis@cpan.org> >>.
+
+This module is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself. See L<perlartistic>.
+
+=head1 DISCLAIMER OF WARRANTY
+
+BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
+EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
+ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
+YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
+NECESSARY SERVICING, REPAIR, OR CORRECTION.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
+OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
+THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+=head1 SEE ALSO
+
+L<Catalyst::Plugin::ConfigLoader|Catalyst::Plugin::ConfigLoader>
+-- now a wrapper around this module.
+
+=cut
+
+"Drink more beer";

database/perl/vendor/lib/Config/Any/Base.pm

@@ -0,0 +1,87 @@
+package Config::Any::Base;
+
+use strict;
+use warnings;
+
+=head1 NAME
+
+Config::Any::Base - Base class for loaders
+
+=head1 DESCRIPTION
+
+This is a base class for all loaders. It currently handles the specification
+of dependencies in order to ensure the subclass can load the config file
+format.
+
+=head1 METHODS
+
+=head2 is_supported( )
+
+Allows us to determine if the file format can be loaded. The can be done via
+one of two subclass methods:
+
+=over 4
+
+=item * C<requires_all_of()> - returns an array of items that must all be present in order to work
+
+=item * C<requires_any_of()> - returns an array of items in which at least one must be present
+
+=back
+
+You can specify a module version by passing an array reference in the return.
+
+    sub requires_all_of { [ 'My::Module', '1.1' ], 'My::OtherModule' }
+
+Lack of specifying these subs will assume you require no extra modules to function.
+
+=cut
+
+sub is_supported {
+    my ( $class ) = shift;
+    local $@;
+    if ( $class->can( 'requires_all_of' ) ) {
+        return eval {
+            _require($_) for $class->requires_all_of;
+            1;
+        } || 0;
+    }
+    if ( $class->can( 'requires_any_of' ) ) {
+        eval { _require( $_ ); 1 } and return 1
+            for $class->requires_any_of;
+        return 0;
+    }
+
+    # requires nothing!
+    return 1;
+}
+
+sub _require {
+    my ( $input ) = shift;
+    my ( $module, $version ) = ( ref $input ? @$input : $input );
+    (my $file = "$module.pm") =~ s{::}{/}g;
+    require $file;
+    $module->VERSION if $version;
+}
+
+=head1 AUTHOR
+
+Brian Cassidy <bricas@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2008-2009 by Brian Cassidy
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Config::Any>
+
+=back
+
+=cut
+
+1;

database/perl/vendor/lib/Config/Any/General.pm

@@ -0,0 +1,100 @@
+package Config::Any::General;
+
+use strict;
+use warnings;
+
+use base 'Config::Any::Base';
+
+=head1 NAME
+
+Config::Any::General - Load Config::General files
+
+=head1 DESCRIPTION
+
+Loads Config::General files. Example:
+
+    name = TestApp
+    <Component Controller::Foo>
+        foo bar
+        bar [ arrayref-value ]
+    </Component>
+    <Model Baz>
+        qux xyzzy
+    </Model>
+
+=head1 METHODS
+
+=head2 extensions( )
+
+return an array of valid extensions (C<cnf>, C<conf>).
+
+=cut
+
+sub extensions {
+    return qw( cnf conf );
+}
+
+=head2 load( $file )
+
+Attempts to load C<$file> via Config::General.
+
+=cut
+
+sub load {
+    my $class = shift;
+    my $file  = shift;
+    my $args  = shift || {};
+
+    $args->{ -ConfigFile } = $file;
+
+    require Config::General;
+    Config::General->VERSION( '2.47' );
+
+    $args->{ -ForceArray } = 1 unless exists $args->{ -ForceArray };
+
+    my $configfile = Config::General->new( %$args );
+    my $config     = { $configfile->getall };
+
+    return $config;
+}
+
+=head2 requires_all_of( )
+
+Specifies that this module requires L<Config::General> in order to work.
+
+=cut
+
+sub requires_all_of { [ 'Config::General' => '2.47' ] }
+
+=head1 AUTHOR
+
+Brian Cassidy <bricas@cpan.org>
+
+=head1 CONTRIBUTORS
+
+Joel Bernstein <rataxis@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2006-2016 by Brian Cassidy
+
+Portions Copyright 2006 Portugal Telecom
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Catalyst>
+
+=item * L<Config::Any>
+
+=item * L<Config::General>
+
+=back
+
+=cut
+
+1;

database/perl/vendor/lib/Config/Any/INI.pm

@@ -0,0 +1,125 @@
+package Config::Any::INI;
+
+use strict;
+use warnings;
+
+use base 'Config::Any::Base';
+
+our $MAP_SECTION_SPACE_TO_NESTED_KEY = 1;
+
+=head1 NAME
+
+Config::Any::INI - Load INI config files
+
+=head1 DESCRIPTION
+
+Loads INI files. Example:
+
+    name=TestApp
+
+    [Controller::Foo]
+    foo=bar
+
+    [Model::Baz]
+    qux=xyzzy
+
+=head1 METHODS
+
+=head2 extensions( )
+
+return an array of valid extensions (C<ini>).
+
+=cut
+
+sub extensions {
+    return qw( ini );
+}
+
+=head2 load( $file )
+
+Attempts to load C<$file> as an INI file.
+
+=cut
+
+sub load {
+    my $class = shift;
+    my $file  = shift;
+
+    require Config::Tiny;
+    my $config = Config::Tiny->read( $file );
+
+    die $Config::Tiny::errstr if not defined $config;
+
+    my $out = delete $config->{ _ } || {};
+
+    for my $k ( keys %$config ) {
+        my @keys = split /\s+/, $k;
+        my $ref = $config->{ $k };
+
+        if ( $MAP_SECTION_SPACE_TO_NESTED_KEY && @keys > 1 ) {
+            my ( $a, $b ) = @keys[ 0, 1 ];
+            $out->{ $a }->{ $b } = $ref;
+        }
+        else {
+            $out->{ $k } = { %{ $out->{ $k } || {} }, %$ref };
+        }
+    }
+
+    return $out;
+}
+
+=head2 requires_all_of( )
+
+Specifies that this module requires L<Config::Tiny> in order to work.
+
+=cut
+
+sub requires_all_of { 'Config::Tiny' }
+
+=head1 PACKAGE VARIABLES
+
+=over 4
+
+=item $MAP_SECTION_SPACE_TO_NESTED_KEY (boolean)
+
+This variable controls whether spaces in INI section headings will be expanded into nested hash keys.
+e.g. it controls whether [Full Power] maps to $config->{'Full Power'} or $config->{'Full'}->{'Power'}
+
+By default it is set to 1 (i.e. true).
+
+Set it to 0 to preserve literal spaces in section headings:
+
+    use Config::Any;
+    use Config::Any::INI;
+    $Config::Any::INI::MAP_SECTION_SPACE_TO_NESTED_KEY = 0;
+
+=back
+
+=head1 AUTHORS
+
+Brian Cassidy <bricas@cpan.org>
+
+Joel Bernstein <rataxis@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2006-2016 by Brian Cassidy, portions copyright 2006, 2007 by Joel Bernstein
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Catalyst>
+
+=item * L<Config::Any>
+
+=item * L<Config::Tiny>
+
+=back
+
+=cut
+
+1;

database/perl/vendor/lib/Config/Any/JSON.pm

@@ -0,0 +1,141 @@
+package Config::Any::JSON;
+
+use strict;
+use warnings;
+
+use base 'Config::Any::Base';
+
+=head1 NAME
+
+Config::Any::JSON - Load JSON config files
+
+=head1 DESCRIPTION
+
+Loads JSON files. Example:
+
+    {
+        "name": "TestApp",
+        "Controller::Foo": {
+            "foo": "bar"
+        },
+        "Model::Baz": {
+            "qux": "xyzzy"
+        }
+    }
+
+=head1 METHODS
+
+=head2 extensions( )
+
+return an array of valid extensions (C<json>, C<jsn>).
+
+=cut
+
+sub extensions {
+    return qw( json jsn );
+}
+
+=head2 load( $file )
+
+Attempts to load C<$file> as a JSON file.
+
+=cut
+
+sub load {
+    my $class = shift;
+    my $file  = shift;
+
+    open( my $fh, '<', $file ) or die $!;
+    binmode $fh;
+    my $content = do { local $/; <$fh> };
+    close $fh;
+
+    if ( eval { require Cpanel::JSON::XS } ) {
+        my $decoder = Cpanel::JSON::XS->new->utf8->relaxed;
+        return $decoder->decode( $content );
+    }
+    elsif ( eval { require JSON::MaybeXS } ) {
+        my $decoder = JSON::MaybeXS::JSON()->new->utf8->relaxed;
+        return $decoder->decode( $content );
+    }
+    elsif ( eval { require JSON::DWIW } ) {
+        my $decoder = JSON::DWIW->new;
+        my ( $data, $error ) = $decoder->from_json( $content );
+        die $error if $error;
+        return $data;
+    }
+    elsif ( eval { require JSON::XS } ) {
+        my $decoder = JSON::XS->new->utf8->relaxed;
+        return $decoder->decode( $content );
+    }
+    elsif ( eval { require JSON::Syck } ) {
+        require Encode;
+        return JSON::Syck::Load( Encode::decode('UTF-8', $content ) );
+    }
+    elsif ( eval { require JSON::PP; JSON::PP->VERSION( 2 ); } ) {
+        my $decoder = JSON::PP->new->utf8->relaxed;
+        return $decoder->decode( $content );
+    }
+    require JSON;
+    if ( eval { JSON->VERSION( 2 ) } ) {
+        return JSON::decode_json( $content );
+    }
+    else {
+        return JSON::jsonToObj( $content );
+    }
+}
+
+=head2 requires_any_of( )
+
+Specifies that this modules requires one of, L<Cpanel::JSON::XS>,
+L<JSON::MaybeXS>, L<JSON::DWIW>, L<JSON::XS>, L<JSON::Syck>, L<JSON::PP> or
+L<JSON> in order to work.
+
+=cut
+
+sub requires_any_of { qw(
+  Cpanel::JSON::XS
+  JSON::MaybeXS
+  JSON::DWIW
+  JSON::XS
+  JSON::Syck
+  JSON::PP
+  JSON
+) }
+
+=head1 AUTHOR
+
+Brian Cassidy <bricas@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2006-2016 by Brian Cassidy
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Catalyst>
+
+=item * L<Config::Any>
+
+=item * L<Cpanel::JSON::XS>
+
+=item * L<JSON::MaybeXS>
+
+=item * L<JSON::DWIW>
+
+=item * L<JSON::XS>
+
+=item * L<JSON::Syck>
+
+=item * L<JSON>
+
+=back
+
+=cut
+
+1;

database/perl/vendor/lib/Config/Any/Perl.pm

@@ -0,0 +1,89 @@
+package Config::Any::Perl;
+
+use strict;
+use warnings;
+
+use base 'Config::Any::Base';
+use File::Spec;
+use Cwd ();
+
+=head1 NAME
+
+Config::Any::Perl - Load Perl config files
+
+=head1 DESCRIPTION
+
+Loads Perl files. Example:
+
+    {
+        name => 'TestApp',
+        'Controller::Foo' => {
+            foo => 'bar'
+        },
+        'Model::Baz' => {
+            qux => 'xyzzy'
+        }
+    }
+
+=head1 METHODS
+
+=head2 extensions( )
+
+return an array of valid extensions (C<pl>, C<perl>).
+
+=cut
+
+sub extensions {
+    return qw( pl perl );
+}
+
+=head2 load( $file )
+
+Attempts to load C<$file> as a Perl file.
+
+=cut
+
+sub load {
+    my $class = shift;
+    my $file  = shift;
+
+    my( $exception, $content );
+    {
+        local $@;
+        # previously this would load based on . being in @INC, and wouldn't
+        # trigger taint errors even if '.' probably should have been considered
+        # tainted.  untaint for backwards compatibility.
+        my ($cwd) = Cwd::cwd() =~ /\A(.*)\z/s;
+        $content = do File::Spec->rel2abs($file, $cwd);
+        $exception = $@ || $!
+            if !defined $content;
+    }
+    die $exception if $exception;
+
+    return $content;
+}
+
+=head1 AUTHOR
+
+Brian Cassidy <bricas@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2006-2016 by Brian Cassidy
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Catalyst>
+
+=item * L<Config::Any>
+
+=back
+
+=cut
+
+1;

database/perl/vendor/lib/Config/Any/XML.pm

@@ -0,0 +1,124 @@
+package Config::Any::XML;
+
+use strict;
+use warnings;
+
+use base 'Config::Any::Base';
+
+=head1 NAME
+
+Config::Any::XML - Load XML config files
+
+=head1 DESCRIPTION
+
+Loads XML files. Example:
+
+    <config>
+        <name>TestApp</name>
+        <component name="Controller::Foo">
+            <foo>bar</foo>
+        </component>
+        <model name="Baz">
+            <qux>xyzzy</qux>
+        </model>
+    </config>
+
+=head1 METHODS
+
+=head2 extensions( )
+
+return an array of valid extensions (C<xml>).
+
+=cut
+
+sub extensions {
+    return qw( xml );
+}
+
+=head2 load( $file )
+
+Attempts to load C<$file> as an XML file.
+
+=cut
+
+sub load {
+    my $class = shift;
+    my $file  = shift;
+    my $args  = shift || {};
+
+    require XML::Simple;
+    my $config = XML::Simple::XMLin(
+        $file,
+        ForceArray => [ qw( component model view controller ) ],
+        %$args
+    );
+
+    return $class->_coerce( $config );
+}
+
+sub _coerce {
+    # coerce the XML-parsed config into the correct format
+    my $class  = shift;
+    my $config = shift;
+    my $out;
+    for my $k ( keys %$config ) {
+        my $ref = $config->{ $k };
+        my $name = ref $ref eq 'HASH' ? delete $ref->{ name } : undef;
+        if ( defined $name ) {
+            $out->{ $k }->{ $name } = $ref;
+        }
+        else {
+            $out->{ $k } = $ref;
+        }
+    }
+    $out;
+}
+
+=head2 requires_all_of( )
+
+Specifies that this module requires L<XML::Simple> and L<XML::NamespaceSupport>
+in order to work.
+
+=cut
+
+sub requires_all_of { 'XML::Simple', 'XML::NamespaceSupport' }
+
+=head1 CAVEATS
+
+=head2 Strict Mode
+
+If, by some chance, L<XML::Simple> has already been loaded with the strict
+flag turned on, then you will likely get errors as warnings will become
+fatal exceptions and certain arguments to XMLin() will no longer be optional.
+
+See L<XML::Simple's strict mode documentation|XML::Simple/STRICT_MODE> for
+more information.
+
+=head1 AUTHORS
+
+Brian Cassidy <bricas@cpan.org>
+
+Joel Bernstein <rataxis@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2006-2016 by Brian Cassidy
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Catalyst>
+
+=item * L<Config::Any>
+
+=item * L<XML::Simple>
+
+=back
+
+=cut
+
+1;

database/perl/vendor/lib/Config/Any/YAML.pm

@@ -0,0 +1,101 @@
+package Config::Any::YAML;
+
+use strict;
+use warnings;
+
+use base 'Config::Any::Base';
+
+use Carp ();
+
+=head1 NAME
+
+Config::Any::YAML - Load YAML config files
+
+=head1 DESCRIPTION
+
+Loads YAML files. Example:
+
+    ---
+    name: TestApp
+    Controller::Foo:
+        foo: bar
+    Model::Baz:
+        qux: xyzzy
+
+=head1 METHODS
+
+=head2 extensions( )
+
+return an array of valid extensions (C<yml>, C<yaml>).
+
+=cut
+
+sub extensions {
+    return qw( yml yaml );
+}
+
+=head2 load( $file )
+
+Attempts to load C<$file> as a YAML file.
+
+=cut
+
+sub load {
+    my $class = shift;
+    my $file  = shift;
+
+    if (eval { require YAML::XS; 1 }) {
+        return YAML::XS::LoadFile( $file );
+    }
+    elsif ($] > 5.008008 && eval { require YAML::Syck; YAML::Syck->VERSION(0.70) } ) {
+        open( my $fh, $file ) or die $!;
+        my $content = do { local $/; <$fh> };
+        close $fh;
+        return YAML::Syck::Load( $content );
+    }
+
+    require YAML;
+    return YAML::LoadFile( $file );
+}
+
+=head2 requires_any_of( )
+
+Specifies that this modules requires one of L<YAML::XS>, L<YAML::Syck> (0.70) or
+L<YAML> in order to work.
+
+=cut
+
+sub requires_any_of {
+    'YAML::XS', ( $] > 5.008008 ? [ 'YAML::Syck', '0.70' ] : ()), 'YAML';
+}
+
+=head1 AUTHOR
+
+Brian Cassidy <bricas@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2006-2016 by Brian Cassidy
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item * L<Catalyst>
+
+=item * L<Config::Any>
+
+=item * L<YAML::XS>
+
+=item * L<YAML>
+
+=item * L<YAML::Syck>
+
+=back
+
+=cut
+
+1;