File Coverage

blib/lib/HTML/TagCloud/Extended.pm

Criterion	Covered	Total	%
statement	27	136	19.8
branch	0	40	0.0
condition	0	19	0.0
subroutine	9	26	34.6
pod	2	13	15.3
total	38	234	16.2

package HTML::TagCloud::Extended;
use strict;
use warnings;
use base qw/Class::Data::Inheritable Class::Accessor::Fast/;
use Readonly;
use HTML::TagCloud::Extended::TagColors;
use HTML::TagCloud::Extended::TagList;
use HTML::TagCloud::Extended::Tag;
use HTML::TagCloud::Extended::Factor;
use HTML::TagCloud::Extended::Exception;

our $VERSION = '0.10';

Readonly my $DEFAULT_BASE_FONT_SIZE  => 24;
Readonly my $DEFAULT_FONT_SIZE_RANGE => 12;
Readonly my $DEFAULT_CSS_CLASS       => "tagcloud";
Readonly my $DEFAULT_SIZE_SUFFIX     => "px";

__PACKAGE__->mk_classdata('_epoch_level');
__PACKAGE__->_epoch_level([qw/earliest earlier later latest/]);

__PACKAGE__->mk_accessors(qw/
    colors
    tags
    base_font_size
    font_size_range
    css_class
    use_hot_color
    hot_tags_size
    _size_suffix
    _hot_tags_name
/);

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

sub _init {
    my $self = shift;
    $self->_set_default_parameters();
    $self->_set_custom_parameters(@_);
    $self->colors ( HTML::TagCloud::Extended::TagColors->new );
    $self->tags   ( HTML::TagCloud::Extended::TagList->new   );
}

sub hot_tags_name {
    my $self = shift;
    if($_[0]) {
        my $tags = ref $_[0] ? $_[0] : [@_];
        $self->_hot_tags_name($tags);
    }
    return $self->_hot_tags_name;
}

sub _check_hot_tag_name {
    my ($self, $name) = @_;
    foreach my $tag_name ( @{ $self->hot_tags_name } ) {
        return 1 if $name eq $tag_name;
    }
    return 0;
}

sub _set_default_parameters {
    my $self  = shift;
    $self->base_font_size  ( $DEFAULT_BASE_FONT_SIZE  );
    $self->font_size_range ( $DEFAULT_FONT_SIZE_RANGE );
    $self->css_class       ( $DEFAULT_CSS_CLASS       );
    $self->_size_suffix    ( $DEFAULT_SIZE_SUFFIX     );
}

sub _set_custom_parameters {
    my ($self, %args) = @_;

    if ( exists $args{base_font_size} ) {
        $self->base_font_size($args{base_font_size});
    }
    if ( exists $args{font_size_range} ) {
        $self->font_size_range($args{font_size_range});
    }
    if ( exists $args{css_class} ) {
        $self->css_class($args{css_class});
    }
    if ( exists $args{hot_tags_size} ) {
        $self->hot_tags_size($args{hot_tags_size});
    }
    else {
        my $size = $self->base_font_size + ($self->font_size_range / 2);
        $self->hot_tags_size($size);
    }
    if ( exists $args{size_suffix} ) {
        $self->size_suffix($args{size_suffix});
    }
    $self->_hot_tags_name( exists $args{hot_tags_name} ? $args{hot_tags_name} : []     );
    $self->use_hot_color ( exists $args{use_hot_color} ? $args{use_hot_color} : undef  );
}

sub size_suffix {
    my ($self, $suffix) = @_;
    if ($suffix) {
        my $correct_suffix;
        foreach my $registered ( qw/mm cm in pt pc px/ ) {
            $correct_suffix = $suffix if $suffix eq $registered;
        }
        if ($correct_suffix) {
            $self->_size_suffix($correct_suffix);
        }
        else {
            HTML::TagCloud::Extended::Exception->throw(
            qq/You should correct suffix for text-size [ mm cm in pt pc px ]. /
            );
        }
    }
    $self->_size_suffix;
}

sub add {
    my($self, $tag_name, $url, $count, $timestamp) = @_;
    my $tag = HTML::TagCloud::Extended::Tag->new(
        name      => $tag_name  || '',
        url       => $url       || '',
        count     => $count     || 0,
        timestamp => $timestamp,
    );
    $self->tags->add($tag);
}

sub max_font_size {
    my $self = shift;
    return $self->base_font_size + $self->font_size_range;
}

sub min_font_size {
    my $self = shift;
    my $num  = $self->base_font_size - $self->font_size_range;
    return $num > 0 ? $num : 0;
}

sub html_and_css {
    my ($self, $conf) = @_;
    my $html = qq|\n|.$self->css.qq|\n|;
    $html .= $self->html($conf);
    return $html;
}

sub css {
    my $self = shift;
    my $css  = '';
    foreach my $type ( keys %{ $self->colors } ) {
        my $color = $self->colors->{$type};
        my $class = $self->css_class;
        foreach my $attr ( keys %$color ) {
            my $code = $color->{$attr};
            $css .= ".${class} .${type} a:${attr} {text-decoration: none; color: #${code};}\n";
        }
    }
    return $css;
}

sub html {
    my ($self, $conf) = @_;
    my $html_tags = $self->html_tags($conf);
    my $html = join "", @$html_tags;
    return $self->wrap_div($html);
}

sub wrap_span {
    my($self, $html) = @_;
    return "" unless $html;
    return sprintf qq|\n%s\n|, $self->css_class, $html;
}

sub wrap_div {
    my($self, $html) = @_;
    return "" unless $html;
    return sprintf qq|\n%s\n|, $self->css_class, $html;
}

sub html_tags {
    my($self, $conf) = @_;

    my $tags_amount = $self->tags->count;
    if ($tags_amount == 0) {
        return [];
    } elsif ($tags_amount == 1) {
        my $ite  = $self->tags->iterator;
        my $tag  = $ite->first;
        my $html = $self->create_html_tag($tag, 'latest', $self->max_font_size);
        return [$html];
    }

    $conf ||= {};
    my $order_by = $conf->{order_by} || 'name';
    $self->tags->sort($order_by);
    my $limit = $conf->{limit};
    my $tags  = $limit ? $self->tags->splice(0, $limit) : $self->tags;

    my $count_factor = HTML::TagCloud::Extended::Factor->new(
        min   => $tags->min_count,
        max   => $tags->max_count,
        range => $self->max_font_size - $self->min_font_size,
    );

    my $epoch_factor = HTML::TagCloud::Extended::Factor->new(
        min   => $tags->min_epoch,
        max   => $tags->max_epoch,
        range => 3,
    );

    my @html_tags = ();
    my $ite = $tags->iterator;
    while( my $tag = $ite->next ) {
        my $count_lv   = $count_factor->get_level($tag->count);
        my $epoch_lv   = $epoch_factor->get_level($tag->epoch);
        my $color_type = $self->_epoch_level->[$epoch_lv];
        my $font_size  = $self->min_font_size + $count_lv;
        if (  ( $self->use_hot_color eq 'name' && $self->_check_hot_tag_name($tag->name) )
           || ( $self->use_hot_color eq 'size' && $font_size >= $self->hot_tags_size     ) ) {
            $color_type = 'hot';
        }
        my $html_tag   = $self->create_html_tag($tag, $color_type, $font_size);
        push @html_tags, $html_tag;
    }
    return \@html_tags;
}

sub create_html_tag {
    my($self, $tag, $type, $size) = @_;
    return sprintf qq|%s\n|,
        $type,
        $size,
        $self->size_suffix,
        $tag->url,
        $tag->name;
}

1;
__END__