File Coverage

blib/lib/Data/Random/Structure.pm

Criterion	Covered	Total	%
statement	59	74	79.7
branch	16	32	50.0
condition	2	4	50.0
subroutine	11	12	91.6
pod	7	7	100.0
total	95	129	73.6

package Data::Random::Structure;
{
  $Data::Random::Structure::VERSION = '0.01';
}

#ABSTRACT: Generate random data structures


use warnings;
use strict;

use Data::Random qw(rand_chars);
use Carp qw(croak);

# Use grotty old style OO
# No validation, whee

sub new {
    my $class = shift;

    if ( scalar @_ % 2 != 0 ) {
        croak "Constructor requires even number of arguments.\n";
    }

    my $self = { @_ };
    bless $self, $class;

    $self->{max_depth} ||= 3;
    $self->{max_elements} ||= 6;

    $self->_init();

    return $self;
}

sub _init {
    my $self = shift;

    push @{$self->{_types}}, qw(HASH ARRAY);
    push @{$self->{_scalar_types}}, qw(string integer float bool);
}


sub max_depth {
    my $self = shift;
    my $max_depth = shift;

    if ( defined $max_depth ) {
        $self->{max_depth} = $max_depth;
    }

    return $self->{max_depth};
}


sub max_elements {
    my $self = shift;
    my $max_elements = shift;

    if ( defined $max_elements ) {
        $self->{max_elements} = $max_elements;
    }

    return $self->{max_elements};
}


sub generate {
    my ($self, $depth, $ref) = @_;

    $depth = 0 if not defined $depth;

    if ( $depth > $self->max_depth() ) {
        return $ref;
    }

    # decide what we're making
    my $type_count = scalar @{$self->{_types}};
    my $type = $self->{_types}[int(rand($type_count))];

    my $r; # this is the new thing we're going to make

    if ( $type eq 'HASH' ) {
        $r = $self->generate_hash();
    }
    elsif ( $type eq 'ARRAY' ) {
        $r = $self->generate_array();
    }

    # connect $r to $ref
    if ( not defined $ref ) {
        $ref = $r;
    }
    elsif ( ref($ref) eq 'HASH' ) {
        # $ref is a hash, generate a random key and assign $r
        $ref->{$self->generate_scalar()} = $r;
    }
    elsif ( ref($ref) eq 'ARRAY' ) {
        push @{$ref}, $r;
    }

    # decide whether we should add a new level
    if ( rand(1) < 0.5 ) {
        $self->generate($depth+1, $ref);
    }
    else {
        return $ref;
    }
}


sub generate_scalar {
    my $self = shift;

    my $type_count = scalar @{$self->{_scalar_types}};
    my $type = $self->{_scalar_types}[int(rand($type_count))];

    if ( $type eq 'float' ) {
        return rand(1);
    }
    elsif ( $type eq 'integer' ) {
        return int(rand(1_000_000));
    }
    elsif ( $type eq 'string' ) {
        return scalar(rand_chars( set => 'all', min => 6, max => 32 ));
    }
    elsif ( $type eq 'bool' ) {
        return (rand(1) < 0.5) ? 1 : 0;
    }
    else {
        croak "I don't know how to generate $type\n";
    }
}


sub generate_array {
    my $self = shift;

    my $ar = [];

    push @{$ar}, $self->generate_scalar() for 0 .. int(rand($self->max_elements()));

    $ar;
}


sub generate_hash {
    my $self = shift;

    my $hr = {};

    $hr->{$self->generate_scalar()} = $self->generate_scalar() for 0 .. int(rand($self->max_elements()));

    $hr;
}

1;

__END__