NAME

       Data::Faker - Perl extension for generating fake data

SYNOPSIS

         use Data::Faker;

         my $faker = Data::Faker->new();

         print "Name:    ".$faker->name."\n";
         print "Company: ".$faker->company."\n";
         print "Address: ".$faker->street_address."\n";
         print "         ".$faker->city.", ".$faker->us_state_abbr." ".$faker->us_zip_code."\n";

DESCRIPTION

       This module creates fake (but reasonable) data that can be used for things such as filling
       databases with fake information during development of database related applications.

OBJECT METHODS

       new()
           Object constructor.  As a shortcut, you can pass names of plugin modules to load to
           new(), although this does not actually restrict the functions available to the object,
           it just causes those plugins to be loaded if they haven't been loaded already. All
           Data::Faker objects in one interpreter share the plugin data, so that multiple objects
           don't multiply the memory requirements.

       methods();
           Return a list of the methods that have been provided by all of the loaded plugins.

       register_plugin();
           Plugin modules call register_plugin() to provide data methods.  See any of the
           included plugin modules for examples.

LOADING PLUGINS

       You can specify which plugins to load by including just the base part of their name as an
       argument when loading the module with 'use'.  For example if you only wanted to use data
       from the Data::Faker::Name module, you would load Data::Faker like this:

         use Data::Faker qw(Name);

       By default any modules matching Data::Faker::* in any directory in @INC will be loaded.
       You can also pass plugin names when calling the new() method, and they will be loaded if
       not already in memory.  See new().

WRITING PLUGINS

       Writing a plugin to provide new kinds of data is easy, all you have to do is create a
       module named Data::Faker::SomeModuleName that inherits from Data::Faker.

       To provide data, the plugin merely needs to call the register_plugin function with one or
       more pairs of function name and function data, like this:

         #!/usr/bin/perl -w
         use strict;
         use warnings;
         use Data::Faker;

         my $faker = Data::Faker->new();
         print "My fake data is ".$faker->some_data_function."\n";

         package Data::Faker::SomeData;
         use base 'Data::Faker';

         __PACKAGE__->register_plugin(
           some_data_function => [qw(foo bar baz gazonk)],
           another_data_item => sub { return '$some_data_function' },
         );

       The first argument is the method that will be made available to your object, the second is
       a data source.  If the data source is not a reference, it will simply be returned as the
       data, if it is a reference to an array, a random element from the array will be returned,
       and if it is a subroutine reference, the subroutine will be run and the results will be
       returned.  The data that your data source provides is checked for two things, tokens (that
       look like perl variables, starting with a $), and numeric indicators (#).  Any tokens
       found will be replaced with their values, and any numeric indicators will be replaced with
       random numbers.  You can include a literal $ or # by prefacing it with a backslash.  If
       you load more than one module that defines the same function, it has an additive effect,
       when the function is called one of the data sources provided will be selected at random
       and then it will be called to get a piece of data.

       Some data source examples:

         __PACKAGE__->register_plugin(
           age              => ['#','##'],
           monetary_amount  => ['\$####.##','\$###.##', '\$##.##', '\$#.##'],
           adult_age        => sub { int(rand(70)+18) },
         );

       If your data source is a code reference, it will receive the calling object as an argument
       so you can build data out of other data if you need to.  See Data::Faker::DateTime for
       some examples of this.

BUGS AND KNOWN ISSUES

       There is no way to selectively remove data sources from a plugin that was loaded, even if
       you didn't load it.

SEE ALSO

       Text::Lorem

AUTHOR

       Jason Kohles, <email@jasonkohles.com>

COPYRIGHT AND LICENSE

       Copyright 2004-2005 by Jason Kohles

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