NAME

Hash::Convert - Rule based Hash converter.

SYNOPSIS

#!/usr/bin/env perl
use strict;
use warnings;
use Hash::Convert;

my $rules = {
    visit   => { from => 'created_at' },
    count   => { from => 'count', via => sub { $_[0] + 1 }, default => 1 },
    visitor => {
        contain => {
            name => { from => 'name' },
            mail => { from => 'mail' },
        },
        default => {
            name => 'anonymous',
            mail => 'anonymous',
        }
    },
    price => {
        from => [qw/item.cost item.discount/],
        via => sub {
            my $cost     = $_[0];
            my $discount = $_[1];
            return $cost * ( (100 - $discount) * 0.01 );
        },
    },
};
my $opts = { pass => 'locate' };

my $converter = Hash::Convert->new($rules, $opts);

my $before = {
    created_at => time,
    count      => 1,
    name       => 'hixi',
    mail       => 'hixi@cpan.org',
    locate     => 'JP',
    item => {
        name     => 'chocolate',
        cost     => 100,
        discount => 10,
    },
};
my $after = $converter->convert($before);
print Dumper $after;
#{
#    'visitor' => {
#        'mail' => 'hixi@cpan.org',
#        'name' => 'hixi'
#    },
#    'count' => 2,
#    'visit' => '1377019766',
#    'price' => 90,
#    'locate' => 'JP'
#}

DESCRIPTION

Hash::Convert is can define hash converter based on the rules.

Function

convert

Convert hash structure from before value.

my $rules = {
    mail => { from => 'email' }
};
my $converter = Hash::Convert->new($rules);
my $before = { email => 'hixi@cpan.org' };
my $after  = $converter->convert($before);
#{
#  mail => 'hixi@cpan.org',
#}

Rules

Command

• from

    my $rules = { visit => { from => 'created_at' } };
    #(
    #(exists $before->{created_at})?
    #    (visit => $before->{created_at}): (),
    #)
  

• from + via

  `via` add after method toward `from`. `via` can receive multiple args from `from`.

  Single args

    my $rules = { version => { from => 'version', via => sub { $_[0] + 1 } } };
    #(
    #(exists $before->{version})?
    #    (version => sub {
    #        $_[0] + 1;
    #    }->($before->{version})): (),
    #)
  

  Multi args

    my $rules = { price => {
        from => [qw/cost discount/],
        via => sub {
            my $cost     = $_[0];
            my $discount = $_[1];
            return $cost * (100 - $discount);
    }};
    #(
    #(exists $before->{item}->{cost} && exists $before->{item}->{discount})?
    #    (price => sub {
    #        my $cost = $_[0];
    #        my $discount = $_[1];
    #        return $cost * (100 - $discount);
    #    }->($before->{item}->{cost}, $before->{item}->{discount})): (),
    #)
  

• contain

    my $rules = { visitor => {
        contain => {
            name => { from => 'name' },
            mail => { from => 'mail' },
        }
    }};
    #(
    #(exists $before->{name} && exists $before->{mail})?
    #    (visitor => {
    #    (exists $before->{mail})?
    #        (mail => $before->{mail}): (),
    #    (exists $before->{name})?
    #        (name => $before->{name}): (),
    #    }): (),
    #)
  

Others expression

• default

  default can add all command (`from`, `from`+`via`, `contain`) .

    my $rules = { visitor => {
        contain => {
            name => { from => 'name' },
            mail => { from => 'mail' },
        },
        default => {
            name => 'anonymous',
            mail => 'anonymous',
        }
    }};
    #(
    #(visitor => {
    #(exists $before->{mail})?
    #    (mail => $before->{mail}): (),
    #(exists $before->{name})?
    #    (name => $before->{name}): (),
    #}):
    #(visitor => {
    #  'name' => 'anonymous',
    #  'mail' => 'anonymous'
    #}),
    #)
  

• dot notation

  `dot notation` make available nested hash structure.

    my $rules = { price => {
        from => [qw/item.cost item.discount/],
        via => sub {
            my $cost     = $_[0];
            my $discount = $_[1];
            return $cost * ( (100 - $discount) * 0.01 );
        },
    }};
    #(
    #(exists $before->{item}->{cost} && exists $before->{item}->{discount})?
    #    (price => sub {
    #        my $cost = $_[0];
    #        my $discount = $_[1];
    #        return $cost * ( (100 - $discount) * 0.01 );
    #    }->($before->{item}->{cost}, $before->{item}->{discount})): (),
    #)
  

LICENSE

Copyright (C) Hiroyoshi Houchi.

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

AUTHOR

Hiroyoshi Houchi hixi@cpan.org