Data::Fake::Core - General purpose generators
version 0.005
use Data::Fake::Core; $generator = fake_hash( { ssn => fake_digits("###-##-###"), phrase => fake_template( "%s world", fake_pick(qw/hello goodbye/) ), die_rolls => fake_array( 3, fake_int(1, 6) ), temperature => fake_float(-20.0, 120.0), } );
This module provides a general-purpose set of fake data functions to generate structured data, numeric data, structured strings, and weighted alternatives.
All functions are exported by default.
$generator = fake_hash( { name => fake_name, pet => fake_pick(qw/dog cat frog/), } ); $generator = fake_hash( @hash_or_hash_generators );
The fake_hash function returns a code reference that, when run, generates a hash reference.
fake_hash
The simplest way to use it is to provide a hash reference with some values replaced with fake_* generator functions. When the generator runs, the hash will be walked recursively and any code reference found will be replaced with its output.
fake_*
If more than one argument is provided, when the generator runs, they will be merged according to the following rules:
code references will be replaced with their outputs
after replacement, if any arguments aren't hash references, an exception will be thrown
hash references will be shallow-merged
This merging allows for generating sections of hashes differently or generating hashes that have missing keys (e.g. using "fake_binomial"):
# 25% of the time, generate a hash with a 'spouse' key $factory = fake_hash( { ... }, fake_binomial( 0.25, { spouse => fake_name() }, {} ), );
$generator = fake_array( 5, fake_digits("###-###-####") );
The fake_array takes a positive integer size and source argument and returns a generator that returns an array reference with each element built from the source.
fake_array
If the size is a code reference, it will be run and can set a different size for every array generated:
# arrays from size 1 to size 6 $generator = fake_array( fake_int(1,6), fake_digits("###-###-###") );
If the source is a code reference, it will be run; if the source is a hash or array reference, it will be recursively evaluated like fake_hash.
$generator = fake_pick( qw/one two three/ ); $generator = fake_pick( @generators );
Given literal values or code references, returns a generator that randomly selects one of them with equal probability. If the choice is a code reference, it will be run; if the choice is a hash or array reference, it will be recursively evaluated like fake_hash or fake_array would do.
$generator = fake_binomial( 0.90, { name => fake_name() }, # 90% likely {}, # 10% likely ); $generator = fake_binomial( $prob, $lte_outcome, $gt_outcome );
The fake_binomial function takes a probability and two outcomes. The probability (between 0 and 1.0) indicates the likelihood that the return value will the first outcome. The rest of the time, the return value will be the second outcome. If the outcome is a code reference, it will be run; if the outcome is a hash or array reference, it will be recursively evaluated like fake_hash or fake_array would do.
fake_binomial
$generator = fake_weighted( [ 'a_choice', 1 ], [ 'ten_times_likely', 10 ], [ $another_generator, 1 ], );
Given a list of array references, each containing a value and a non-negative weight, returns a generator that randomly selects a value according to the relative weights.
If the value is a code reference, it will be run; if it is a hash or array reference, it will be recursively evaluated like fake_hash or fake_array would do.
$generator = fake_int(1, 6);
Given a minimum and a maximum value as inputs, returns a generator that will produce a random integer in that range.
$generator = fake_float(1.0, 6.0);
Given a minimum and a maximum value as inputs, returns a generator that will produce a random floating point value in that range.
$generator = fake_digits('###-####'); # "555-1234" $generator = fake_digits('\###'); # "#12"
Given a text pattern, returns a generator that replaces all occurrences of the sharp character (#) with a randomly selected digit. To have a literal sharp character, escape it with a backslash (do it in a single-quoted string to avoid having to double your backslash to get a backslash in the string.).
#
Use this for phone numbers, currencies, or whatever else needs random digits:
fake_digits('###-##-####'); # US Social Security Number fake_digits('(###) ###-####'); # (800) 555-1212
$generator = fake_template("Hello, %s", fake_name());
Given a sprintf-style text pattern and a list of generators, returns a generator that, when run, executes the generators and returns the string populated with the output.
Use this for creating custom generators from other generators.
$generator = fake_join(" ", fake_first_name(), fake_surname() );
Given a character to join on a list of literals or generators, returns a generator that, when run, executes any generators and returns them concatenated together, separated by the separator character.
The separator itself may also be a generator if you want that degree of randomness as well.
$generator = fake_join( fake_pick( q{}, q{ }, q{,} ), @args );
$flatten_generator = fake_flatten( fake_array( 3, fake_first_name() ) ); @array_of_names = $flatten_generator->();
Given a generator that returns an array ref (such as fake_array) or a hash ref (fake_hash), fake_flatten returns a generator that, when run, executes the generators and returns their result in a dereferenced state.
This is particularly useful when the return value is used directly as input to another function, for example within a fake_join.
$generator = fake_join( " ", $flatten_generator );
David Golden <dagolden@cpan.org>
This software is Copyright (c) 2015 by David Golden.
This is free software, licensed under:
The Apache License, Version 2.0, January 2004
To install Data::Fake, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Data::Fake
CPAN shell
perl -MCPAN -e shell install Data::Fake
For more information on module installation, please visit the detailed CPAN module installation guide.