File Coverage

blib/lib/Tree/Visualize/ASCII/BoundingBox.pm

Criterion	Covered	Total	%
statement	99	100	99.0
branch	19	28	67.8
condition	9	30	30.0
subroutine	18	18	100.0
pod	14	14	100.0
total	159	190	83.6

package Tree::Visualize::ASCII::BoundingBox;

use strict;
use warnings;

use Tree::Visualize::Exceptions;

our $VERSION = '0.01';

## constructor

sub new {
    my ($_class, $string) = @_;
    my $class = ref($_class) || $_class;
    my $box = {
        string => [ split(/\n/, $string) ]
        };
    bless($box, $class);
    return $box;
}

## accessors

sub height {
    my ($self) = @_;
    scalar @{$self->{string}};
}

sub width {
    my ($self) = @_;
    defined($self->{string}->[0]) || return 0;
    length($self->{string}->[0]);
}

sub getLinesAsArray {
    my ($self) = @_;
    return @{$self->{string}};
}

sub getAsString {
    my ($self) = @_;
    join "\n" => @{$self->{string}};
}

sub getFirstConnectionPointIndex {
    my ($self) = @_;
    my ($space, $top_line_of_box) = ($self->{string}->[0] =~ /(\s*)(\S*)/);
    return length($space) + int(length($top_line_of_box) / 2);
}

## mutators

sub flipVertical {
    my ($self) = @_;
    $self->{string} = [ reverse(@{$self->{string}}) ];
    $self;
}

sub flipHorizontal {
    my ($self) = @_;
    $self->{string} = [ map { join "" => reverse(split // => $_) } @{$self->{string}} ];
    $self;
}

sub padLeft {
    my ($self, $padding) = @_;
    ($padding =~ /^\s*$/)
        || throw Tree::Visualize::InsufficientArguments "padding can not contain newlines and only be spaces ($padding)";
    $self->{string} = [ map { ($padding . $_) } @{$self->{string}} ];
    $self;
}

sub padRight {
    my ($self, $padding) = @_;
    ($padding =~ /^\s*$/)
        || throw Tree::Visualize::InsufficientArguments "padding can not contain newlines and only be spaces ($padding)";
    $self->{string} = [ map { ($_ . $padding) } @{$self->{string}} ];
    $self;
}

sub pasteRight {
    my ($self, $right) = @_;
    (defined($right) && ref($right) && UNIVERSAL::isa($right, "Tree::Visualize::ASCII::BoundingBox"))
        || throw Tree::Visualize::InsufficientArguments "right argument must be a Tree::Visualize::ASCII::BoundingBox ($right)";
    # split the left
    my @left = $self->getLinesAsArray();
    # and the right
    my @right = $right->getLinesAsArray();

    # figure out which has the most lines
    my $num_lines = ($self->height() < $right->height()) ? $right->height() : $self->height();

    # get the widths of the first item in the list
    my $first_left_width = $self->width();
    my $first_right_width = $right->width();

    my @new_string;
    foreach my $line_num (0 .. $num_lines - 1) {
        push @new_string => (
            _normalizeLine($left[$line_num], $first_left_width) .
            _normalizeLine($right[$line_num], $first_right_width)
            );
    }
    # and now paste it into the new string
    $self->{string} = \@new_string;
    $self;
}

sub pasteLeft {
    my ($self, $left) = @_;
    (defined($left) && ref($left) && UNIVERSAL::isa($left, "Tree::Visualize::ASCII::BoundingBox"))
        || throw Tree::Visualize::InsufficientArguments "left argument must be a Tree::Visualize::ASCII::BoundingBox ($left)";
    # split the left
    my @left = $left->getLinesAsArray();
    # and the right
    my @right = $self->getLinesAsArray();

    # figure out which has the most lines
    my $num_lines = ($self->height() < $left->height()) ? $left->height() : $self->height();

    # get the widths of the first item in the list
    my $first_left_width = $left->width();
    my $first_right_width = $self->width();

    my @new_string;
    foreach my $line_num (0 .. $num_lines - 1) {
        push @new_string => (
            _normalizeLine($left[$line_num], $first_left_width) .
            _normalizeLine($right[$line_num], $first_right_width)
            );
    }
    # and now paste it into the new string
    $self->{string} = \@new_string;
    $self;
}

sub pasteTop {
    my ($self, $top) = @_;
    (defined($top) && ref($top) && UNIVERSAL::isa($top, "Tree::Visualize::ASCII::BoundingBox"))
        || throw Tree::Visualize::InsufficientArguments "top argument must be a Tree::Visualize::ASCII::BoundingBox ($top)";
    if ($top->width() < $self->width()) {
        unshift @{$self->{string}} => map { _normalizeLine($_, $self->width()) } $top->getLinesAsArray();
    }
    else {
        $self->{string} = [ $top->getLinesAsArray(), map { _normalizeLine($_, $top->width()) } @{$self->{string}} ];
    }
    $self;
}

sub pasteBottom {
    my ($self, $bottom) = @_;
    (defined($bottom) && ref($bottom) && UNIVERSAL::isa($bottom, "Tree::Visualize::ASCII::BoundingBox"))
        || throw Tree::Visualize::InsufficientArguments "bottom argument must be a Tree::Visualize::ASCII::BoundingBox ($bottom)";
    if ($bottom->width() < $self->width()) {
        push @{$self->{string}} => map { _normalizeLine($_, $self->width()) } $bottom->getLinesAsArray();
    }
    else {
        $self->{string} = [ map { _normalizeLine($_, $bottom->width()) } @{$self->{string}}, $bottom->getLinesAsArray() ];
    }
    $self;
}

## private helper functions

sub _normalizeLine {
    my ($line, $width) = @_;
    unless ($line) {
        $line = (" " x $width);
    }
    elsif ($width > length($line)) {
        $line = $line . (" " x ($width - length($line)));
    }
    elsif ($width < length($line)) {
        # strip any trailing spaces that are larger
        # then the width of the first line of the
        # left node
        chop($line) while ($line =~ /\s$/o && $width < length($line));
    }
    return $line;
}

1;

__END__