File Coverage

blib/lib/Hash/Transform.pm

Criterion	Covered	Total	%
statement	41	42	97.6
branch	17	30	56.6
condition	2	6	33.3
subroutine	9	9	100.0
pod	4	4	100.0
total	73	91	80.2

package Hash::Transform;

use warnings;
use strict;

our $VERSION = '0.01';

use Carp ();



sub new {
  my $class = shift;
  my $self = bless {}, $class;
  $self->init(@_);
  return $self;
}


sub init {
  my $self = shift;
  $self->{rules} = {};
  $self->rules(@_) if @_;
  return $self;
}


sub rules {
  my $self = shift;
  Carp::croak "Missing rules" unless @_;
  my $hash_ref = _hash_arg(@_);
  Carp::croak "Invalid rules" unless $hash_ref;
  $self->{rules} = $hash_ref;
  return $self;
}


sub _apply_rule {
  my ($self, $code, $data) = @_;
  return unless defined $code && ref $data eq 'HASH';

  '' eq ref $code
    and return $data->{$code};

  'SCALAR' eq ref $code
    and return $$code;

  'CODE' eq ref $code
    and return $code->($data);

  'ARRAY' eq ref $code
    and return join(
                    $code->[0],
                    map {
                      my $entry = $self->_apply_rule($_, $data);
                      defined $entry ? $entry : '';
                    } @$code[1..$#$code]
                   );

  ## default
  return;
}


sub apply {
  my $self = shift;
  my $source = _hash_arg (@_)
    or Carp::croak "Invalid data set";
  my $rules = $self->{rules}
    or Carp::croak "Missing rules table";

  my %target = map {
    my $key = $_;
    my $value = $self->_apply_rule ($rules->{$key}, $source);
    ($key => $value);
  } keys %$rules;

  return wantarray ? %target : \%target;
}


sub _hash_arg {
  my $hash_ref
    = (@_ == 1 and ref $_[0] eq 'HASH') ? $_[0]
    : (@_ % 2 == 0)                     ? { @_ }
    : return
    ;
  return wantarray ? %$hash_ref : $hash_ref;
}



1;

__END__