File Coverage

blib/lib/SVG/Sparkline/RangeBar.pm

Criterion	Covered	Total	%
statement	102	102	100.0
branch	20	20	100.0
condition	4	4	100.0
subroutine	13	13	100.0
pod	2	2	100.0
total	141	141	100.0

package SVG::Sparkline::RangeBar;

use warnings;
use strict;
use Carp;
use SVG;
use List::Util ();
use SVG::Sparkline::Utils;

use 5.008000;
our $VERSION = 1.12;

# alias to make calling shorter.
*_f = *SVG::Sparkline::Utils::format_f;

sub valid_param {
    return scalar grep { $_[1] eq $_ } qw/gap thick/;
}

sub make
{
    my ($class, $args) = @_;
    # validate parameters
    SVG::Sparkline::Utils::validate_array_param( $args, 'values' );
    croak "'values' must be an array of pairs.\n"
        if grep { 'ARRAY' ne ref $_ || 2 != @{$_} } @{$args->{values}};
    my $vals = SVG::Sparkline::Utils::summarize_values(
        [ map { @{$_} } @{$args->{values}} ]
    );

    my $height = $args->{height} - 2*$args->{pady};
    my $yscale = -$height / $vals->{range};
    my $baseline = _f(-$yscale*$vals->{min});

    # Figure out the width I want and define the viewBox
    my $dwidth;
    my $gap = $args->{gap} || 0;
    $args->{thick} ||= 3;
    my $space = $args->{thick}+$gap;
    if($args->{width})
    {
        $dwidth = $args->{width} - $args->{padx}*2;
        $space = _f( $dwidth / @{$args->{values}} );
        $args->{thick} = $space - $gap;
    }
    else
    {
        $dwidth = @{$args->{values}} * $space;
        $args->{width} = $dwidth + 2*$args->{padx};
    }
    $args->{yoff} = -($baseline+$height+$args->{pady});
    $args->{xscale} = $space;
    my $svg = SVG::Sparkline::Utils::make_svg( $args );

    my $off = _f( $gap/2 );
    my $prev = 0;
    my $path = "M". _f(-$args->{thick}-$off).",0";
    foreach my $v (@{$args->{values}})
    {
        # Move from previous x,y to low value
        $path .= 'm'. _f($args->{thick}+$gap) .','. _f($yscale*($v->[0]-$prev));
        my $vert = _f( $yscale * ($v->[1]-$v->[0]) );
        if($vert)
        {
            $path .= "v${vert}h$args->{thick}v". _f(-$vert)."h-$args->{thick}";
        }
        else
        {
            $path .= _zero_height_path( $args->{thick} );
        }
        $prev = $v->[0];
    }
    $path = _clean_path( $path );
    $svg->path( stroke=>'none', fill=>$args->{color}, d=>$path );

    if( exists $args->{mark} )
    {
        _make_marks( $svg,
            thick=>$args->{thick}, off=>$off,
            space=>$space, yscale=>$yscale,
            values=>$args->{values}, mark=>$args->{mark}
        );
    }
    return $svg;
}

sub _zero_height_path
{
    my ($thick) = @_;
    my $path = 'v-0.5';
    my $step = 1;
    $step = $thick/4 if $thick <= 2;
    $step = 2 if $thick >= 8;
    my $num_steps = int( $thick/$step ) - 1;
    my $leftover = $thick-($num_steps*$step);
    foreach my $i (1 .. $num_steps)
    {
        $path .= "h${step}v" . ($i%2? 1 :-1);
    }
    $path .= "h${leftover}v". ($thick%2?0.5: -0.5) . "h-$thick";
    return $path;
}

sub _make_marks
{
    my ($svg, %args) = @_;

    my @marks = @{$args{mark}};
    while(@marks)
    {
        my ($index,$color) = splice( @marks, 0, 2 );
        $index = SVG::Sparkline::Utils::range_mark_to_index( 'RangeBar', $index, $args{values} );
        _make_mark( $svg, %args, index=>$index, color=>$color );
    }
    return;
}

sub _make_mark
{
    my ($svg, %args) = @_;
    my $index = $args{index};
    my ($lo, $hi) = @{$args{values}->[$index]};
    my $y = _f( $hi * $args{yscale} );
    my $h = _f( ($hi-$lo) * $args{yscale});
    if($h)
    {
        my $x = _f($index * $args{space} + $args{off});
        $svg->rect( x=>$x, y=>$y,
            width=>$args{thick}, height=>abs($h),
            stroke=>'none', fill=>$args{color}
        );
    }
    else
    {
        my $x = _f($index * $args{space} +$args{off});
        $svg->path(
            d=>"M$x,$y". _zero_height_path( $args{thick} ),
            stroke=>'none', fill=>$args{color}
        );
    }
    return;
}

sub _clean_path
{
    my ($path) = @_;
    $path =~ s/^M([-.\d]+),([-.\d]+)m([-.\d]+),([-.\d]+)/'M'. _f($1+$3) .','. _f($2+$4)/e;
    $path =~ s/h0(?![.\d])//g;
    return $path;
}

1;

__END__