Mojo-DB-Results-Role-MoreMethods

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

t/hashify.t
t/hashify_collect.t
t/one.t
t/one_array.t
t/one_by_name.t
t/one_c.t
t/one_c_by_name.t
t/one_hash.t
t/one_struct.t
t/struct_or_die.t
t/transform_validate.t

lib/Mojo/DB/Results/Role/MoreMethods.pm  view on Meta::CPAN

    my ($collection, $get_keys, $get_value, $flatten) = shift->_parse_transform_options({flatten_allowed => 1}, @_);

    return $collection->with_roles('+Transform')->collect_by({flatten => $flatten}, $get_keys, $get_value);
}

sub _parse_transform_options {
    my $self = shift;
    my $private_options = shift;
    my $options = ref $_[0] eq 'HASH' ? shift : {};

    my ($key, $key_ref)                       = _parse_and_validate_transform_key(shift);
    my ($value, $value_is_column, $value_ref) = _parse_and_validate_transform_value(@_);

    my ($type, $flatten) = _parse_and_validate_transform_options($private_options, $options);

    # if user will not access the rows and the type won't be used, default rows to arrays for speed
    if (($value_is_column or $flatten) and $key_ref ne 'CODE' and $value_ref ne 'CODE') {
        if ($type and $type ne 'array') {
            Carp::cluck 'Useless type option provided. array will be used for performance.';
        }
        $type = 'array';
    } elsif (not $type) {
        $type = 'hash';
    }

lib/Mojo/DB/Results/Role/MoreMethods.pm  view on Meta::CPAN

                   ;
    my $collection = $type eq 'array' ? $self->arrays
                   : $type eq 'c'     ? $self->collections
                   : $type eq 'hash'  ? $self->hashes
                   : $self->structs
                   ;

    return $collection, $get_keys, $get_value, $flatten;
}

sub _parse_and_validate_transform_key {
    my ($key) = @_;

    my $key_ref = ref $key;
    if ($key_ref) {
        Carp::confess qq{key must be an arrayref, a sub or a non-empty string, but had ref '$key_ref'}
            unless $key_ref eq 'ARRAY' or $key_ref eq 'CODE';

        if ($key_ref eq 'ARRAY') {
            Carp::confess 'key array must not be empty' unless @$key;
            Carp::confess 'key array elements must be defined and non-empty' if grep { not defined or $_ eq '' } @$key;
        }
    } else {
        Carp::confess 'key was undefined or an empty string' unless defined $key and $key ne '';
        $key = [$key];
    }

    return $key, $key_ref;
}

sub _parse_and_validate_transform_value {
    my ($value, $value_is_column);

    my $value_ref;
    if (@_ == 1) {
        $value = shift;

        $value_ref = ref $value;
        if ($value_ref) {
            Carp::confess qq{value must be a sub or non-empty string, but was '$value_ref'} unless $value_ref eq 'CODE';
        } elsif (not defined $value or $value eq '') {

lib/Mojo/DB/Results/Role/MoreMethods.pm  view on Meta::CPAN

        } else {
            $value_is_column = 1;
        }
    } elsif (@_ > 1) {
        Carp::confess 'too many arguments provided (more than one value)';
    }

    return $value, $value_is_column, $value_ref // '';
}

sub _parse_and_validate_transform_options {
    my ($private_options, $options) = @_;

    my $flatten;
    if ($private_options->{flatten_allowed}) {
        $flatten = delete $options->{flatten};
    } else {
        Carp::confess 'flatten not allowed' if exists $options->{flatten};
    }

    my $flatten_allowed_text = $private_options->{flatten_allowed} ? 'In addition to flatten, ' : '';

t/transform_validate.t  view on Meta::CPAN

    my ($db, $drop_table_sql, $create_table_sql, $role, $methods, $options) = @_;

    for my $method (@$methods) {
        note "Testing method $method";

        $db->query($drop_table_sql);
        $db->query($create_table_sql);
        $db->insert(people => {name => 'Bob', age => 23, favorite_food => 'Pizza'});

        test_useless_options_warning($db, $role, $method);
        test_validate_transform_options($db, $role, $method);

        for my $option (@$options) {
            note "Testing method $method and option " . dumper $option;
            test_method($db, $role, $method, $option ? $option : ());
        }
    }
}

sub test_useless_options_warning {
    my ($db, $role, $method) = @_;

t/transform_validate.t  view on Meta::CPAN

            my $results = get_results($db, $role);
            warning_like
                { $results->$method({array => 1, flatten => 1}, $key) }
                undef,
                qq{$prefix with flatten option with array option doesn't warn when no value is provided};
        }
    }
}

sub test_validate_transform_options {
    my ($db, $role, $method) = @_;

    if ($method eq 'hashify') {
        my $results = get_results($db, $role);
        throws_ok
            { $results->$method({flatten => 1}, 'name') }
            qr/flatten not allowed/,
            'flatten option throws for hashify';
    } else {
        my $results = get_results($db, $role);

t/transform_validate.t  view on Meta::CPAN

                { $results->$method({flatten => 1, $unknown_option => 1}, 'name') }
                qr/option must be one of: $options_sep_comma/,
                "unknown $unknown_option option with flatten option throws";
        }
    }
}

sub test_method {
    my ($db, $role, $method, @options) = @_;

    test_parse_transform_key_validate($db, $role, $method, @options);
    test_parse_transform_value_validate($db, $role, $method, @options);
    test_unknown_columns_throw($db, $role, $method, @options);
}

sub test_parse_transform_key_validate {
    my ($db, $role, $method, @options) = @_;

    my $results = get_results($db, $role);
    throws_ok
        { $results->$method(@options, \'key') }
        qr/key must be an arrayref, a sub or a non-empty string, but had ref 'SCALAR'/,
        'SCALAR key throws';

    $results = get_results($db, $role);
    throws_ok

t/transform_validate.t  view on Meta::CPAN

        { $results->$method(@options, '') }
        qr/key was undefined or an empty string/,
        'empty string key throws';

    $results = get_results($db, $role);
    lives_ok
        { $results->$method(@options, 'name') }
        'string column key lives';
}

sub test_parse_transform_value_validate {
    my ($db, $role, $method, @options) = @_;

    my $results = get_results($db, $role);
    throws_ok
        { $results->$method(@options, 'name', []) }
        qr/value must be a sub or non-empty string, but was 'ARRAY'/,
        'ARRAY value throws';

    $results = get_results($db, $role);
    throws_ok