File Coverage

blib/lib/Indent/Word.pm

Criterion	Covered	Total	%
statement	82	85	96.4
branch	27	30	90.0
condition	11	12	91.6
subroutine	11	11	100.0
pod	2	2	100.0
total	133	140	95.0

package Indent::Word;

use strict;
use warnings;

use Class::Utils qw(set_params);
use English qw(-no_match_vars);
use Error::Pure qw(err);
use Indent::Utils qw(line_size_check);
use Readonly;

# Constants.
Readonly::Scalar my $EMPTY_STR => q{};
Readonly::Scalar my $LINE_SIZE => 79;

our $VERSION = 0.11;

# Constructor.
sub new {
	my ($class, @params) = @_;
	my $self = bless {}, $class;

	# Use with ANSI sequences.
	$self->{'ansi'} = undef;

	# Options.
	$self->{'line_size'} = $LINE_SIZE;
	$self->{'next_indent'} = "\t";

	# Output.
	$self->{'output_separator'} = "\n";

	# Process params.
	set_params($self, @params);

	# 'line_size' check.
	line_size_check($self);

	if (! defined $self->{'ansi'}) {
		if (exists $ENV{'NO_COLOR'}) {
			$self->{'ansi'} = 0;
		} elsif (defined $ENV{'COLOR'}) {
			$self->{'ansi'} = 1;
		} else {
			$self->{'ansi'} = 0;
		}
	}

	# Check rutine for removing ANSI sequences.
	if ($self->{'ansi'}) {
		eval {
			require Text::ANSI::Util;
		};
		if ($EVAL_ERROR) {
			err "Cannot load 'Text::ANSI::Util' module.";
		}
	}

	# Object.
	return $self;
}

# Indent text by words to line_size block size.
sub indent {
	my ($self, $data, $indent, $non_indent) = @_;

	# 'indent' initialization.
	if (! defined $indent) {
		$indent = $EMPTY_STR;
	}

	# If non_indent data, than return.
	if ($non_indent) {
		return $indent.$data;
	}

	# Normalize whitespace: collapse all whitespace (including newlines) to single spaces.
	$data =~ s/\s+/ /g;

	# Remove leading and trailing whitespace.
	$data =~ s/^\s+//;
	$data =~ s/\s+$//;

	my ($first, $second) = (undef, $indent.$data);
	my $last_second_length = 0;
	my @data;
	my $one = 1;
	while ($self->_length($second) >= $self->{'line_size'}
		&& $second =~ /^\s*\S+\s+/ms
		&& $last_second_length != $self->_length($second)) {

		# Last length of non-parsed part of data.
		$last_second_length = $self->_length($second);

		# Parse to indent length.
		($first, my $tmp) = $self->_parse_to_indent_length($second);

		# If string is non-breakable in indent length, than parse to
		# blank char.
		if (! $first
			|| $self->_length($first) < $self->_length($indent)
			|| $first =~ /^$indent\s*$/ms) {

			($first, $tmp) = $second
				=~ /^($indent\s*[^\s]+?)\s(.*)$/msx;
		}

		# If parsing is right.
		if ($tmp) {

			# Non-parsed part of data.
			$second = $tmp;

			# Add next_indent to string.
			if ($one == 1) {
				$indent .= $self->{'next_indent'};
			}
			$one = 0;
			$second = $indent.$second;

			# Parsed part of data to @data array.
			push @data, $first;
		}
	}

	# Add other data to @data array.
	$second =~ s/\s+$//ms;
	if ($second) {
		push @data, $second;
	}

	# Return as array or one line with output separator between its.
	return wantarray ? @data : join($self->{'output_separator'}, @data);
}

# Get length.
sub _length {
	my ($self, $string) = @_;
	if ($self->{'ansi'}) {
		return length Text::ANSI::Util::ta_strip($string);
	} else {
		return length $string;
	}
}

# Parse to indent length.
sub _parse_to_indent_length {
	my ($self, $string) = @_;
	my @ret;
	if ($self->{'ansi'}) {
		my $string_wo_ansi = Text::ANSI::Util::ta_strip($string);

		# First part.
		my ($first_wo_ansi) = $string_wo_ansi
			=~ m/^(.{0,$self->{'line_size'}})\s+(.*)$/msx;
		if (defined $first_wo_ansi) {
			push @ret, Text::ANSI::Util::ta_trunc($string, length $first_wo_ansi);

			# Second part. (Remove first part + whitespace from string.)
			my $other_string_wo_ansi = Text::ANSI::Util::ta_strip(
				Text::ANSI::Util::ta_substr($string, length $first_wo_ansi,
					Text::ANSI::Util::ta_length($string))
			);
			$other_string_wo_ansi =~ m/^(\s*)/ms;
			my $count_of_spaces = length $1;
			push @ret, Text::ANSI::Util::ta_substr($string, 0, (length $first_wo_ansi)
				+ $count_of_spaces, '');
		}
	} else {
		@ret = $string =~ m/^(.{0,$self->{'line_size'}})\s+(.*)$/msx;
	}
	return @ret;
}

1;

__END__