File Coverage

blib/lib/Hash/Compact.pm

Criterion	Covered	Total	%
statement	63	65	96.9
branch	16	18	88.8
condition	22	28	78.5
subroutine	11	12	91.6
pod	6	7	85.7
total	118	130	90.7

package Hash::Compact;
use 5.008001;
use strict;
use warnings;
use Carp qw(croak);
use Scalar::Util qw(blessed);

our $VERSION = '0.06';

sub new {
    my $class   = shift;
    my $options = @_ > 1 && (ref $_[-1] || '') eq 'HASH' ? pop : {};
    my $self    = bless { __HASH_COMPACT_OPTIONS__ => $options }, $class;
    my $args    = shift || {};

    croak '$args must be a hash-ref'
        if (ref $args || '') ne 'HASH';

    while (my ($key, $value) = each %$args) {
        $self->param($key, $value);
    }

    $self;
}

sub options { $_[0]->{__HASH_COMPACT_OPTIONS__} }

sub keys {
    my $self = shift;
    my %alias_map;
    my @defaults;

    for my $key (CORE::keys %{$self->options}) {
        if (my $raw = $self->options->{$key}{alias_for}) {
            $alias_map{$raw} = $key;
        }
        if ($self->options->{$key}{default}) {
            push @defaults, $key;
        }
    }

    my %seen;
    grep { !$seen{$_}++ } map {
        my $key = $_;
        my $original_key = $alias_map{$key} ? $alias_map{$key} : $key;
    } grep { $_ ne '__HASH_COMPACT_OPTIONS__' } (keys %$self, @defaults);
}

sub param {
    my $self = shift;
    my $value;

    if (@_ > 1) {
        croak 'incorrect key/value pair'
            if @_ % 2;

        my %args = @_;
        while (my ($key, $value) = each %args) {
            my $option = $self->options->{$key} || {};
            $key = $option->{alias_for} || $key;

            if (defined $value && !ref $value && $value eq ($option->{default} || '')) {
                delete $self->{$key};
            }
            else {
                $self->{$key} = $value;
            }
        }
    }
    else {
        my $key    = shift;
        my $option = $self->options->{$key} || {};

        $value = $self->{$option->{alias_for} || $key} || $option->{default};
    }

    $value;
}

sub to_hash {
    warn 'to_hash() method will be deprecated at later version. use compact() instead';
    $_[0]->compact;
}

sub compact {
    my $self = shift;

    +{
        map  {
            my $value = $self->{$_};

            if (blessed $value && $value->can('to_hash')) {
                $_ => $value->compact;
            }
            else {
                $_ => $value;
            }
        } grep { $_ ne '__HASH_COMPACT_OPTIONS__' } CORE::keys %$self
    }
}

sub original {
    my $self = shift;
    +{ map { $_ => $self->param($_) } $self->keys }
}

!!1;

__END__