File Coverage

blib/lib/Dotiac/DTL/Value.pm

Criterion	Covered	Total	%
statement	104	193	53.8
branch	72	174	41.3
condition	20	72	27.7
subroutine	21	23	91.3
pod	21	21	100.0
total	238	483	49.2

###############################################################################
#Value.pm
#Last Change: 2009-01-19
#Copyright (c) 2009 Marc-Seabstian "Maluku" Lucksch
#Version 0.8
####################
#This file is part of the Dotiac::DTL project.
#http://search.cpan.org/perldoc?Dotiac::DTL
#
#Value.pm is published under the terms of the MIT license, which basically
#means "Do with it whatever you want". For more information, see the
#license.txt file that should be enclosed with libsofu distributions. A copy of
#the license is (at the time of writing) also available at
#http://www.opensource.org/licenses/mit-license.php .
###############################################################################

package Dotiac::DTL::Value;
use strict;
use warnings;
require Scalar::Util;

our $VERSION = 0.8;

sub new {
	my $class=shift;
	my $data=shift;
	my $safe=shift;
	$safe=0 unless $safe;
	$safe=1 if $safe;
	my $r=Scalar::Util::reftype($data);
	$r="" unless $r;
	my $self=[$data,$safe,$r,Scalar::Util::blessed($data),($r?0:Scalar::Util::looks_like_number($data))];
	bless $self,$class;
	return $self;

}

sub safe {
	my $self=shift;
	return Dotiac::DTL::Value->new(shift(@_),1) unless ref $self;
	if (@_ and $_[0]) {
		$self->[1]=1;
	}
	return $self->[1];
}

sub escape {
	my $self=shift;
	return Dotiac::DTL::Value->new(shift(@_),0) unless ref $self;
	if (@_ and $_[0]) {
		$self->[1]=0;
	}
	return !$self->[1];
}

sub array {
	return $_[0]->[2] eq "ARRAY"
}

sub hash {
	return $_[0]->[2] eq "HASH"
}

sub object {
	return !(!$_[0]->[3]);
}

sub number {
	return $_[0]->[4];
}

sub undef {
	return !defined $_[0]->[0];
}

sub defined {
	return defined $_[0]->[0];
}

sub scalar {
	return !$_[0]->[2] and defined $_[0]->[0];
}

sub true {
	return "" unless $_[0]->[0];
	return $_[0]->[0] unless $_[0]->[2];
	return $_[0]->[0]->count() if $_[0]->[3] and $_[0]->[0]->can("count");
	return 1 if $_[0]->[3];
	return scalar @{$_[0]->[0]} if $_[0]->[2] eq "ARRAY";
	return scalar keys %{$_[0]->[0]} if $_[0]->[2] eq "HASH";
	return 1;
}

sub get {
	return $_[0]->[0];
}

sub content {
	return $_[0]->[0];
}

#Recursive string rendering
sub str {
	my $data=shift;
	my $level=shift;
	return unless $level;
	if (not defined $data) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID;
	}
	if (not ref $data) {
		return $data;
	}
	if (Scalar::Util::blessed($data)) {
		return $data->string() if $data->can("string");
		return $data->__str__() if $data->can("__str__");
		return $data->ToString() if $data->can("ToString");
		return $data->repr() if $data->can("repr");
		return $data->__repr__() if $data->can("__repr__");
		return $data;
	}
	if (Scalar::Util::reftype($data) eq "HASH" and $level > 1) {
		return join(" ",map {str($data->{$_},$level-1)} sort keys %{$data});
	}
	if (Scalar::Util::reftype($data) eq "ARRAY" and $level > 1) {
		return join(" ",map {str($_,$level-1)} @{$data});
	}
	return $data;
}

sub string {
	my $self=shift;
	my $data=$self->[0];
	my $value="Error";
	if ($self->undef()) {
		$value=$Dotiac::DTL::TEMPLATE_STRING_IF_INVALID;
		$self->[1]=1;
	}
	elsif ($self->scalar()) {
		$value=$data;
	}
	elsif ($self->object and $data->can("string")) {
		$value=$data->string();
	}
	elsif ($self->object and $data->can("__str__")) {
		return $data->__str__();
	}
	elsif ($self->object and $data->can("ToString")) {
		return $data->ToString();
	}
	elsif ($self->object and $data->can("repr")) {
		return $data->repr();
	}
	elsif ($self->object and $data->can("__repr__")) {
		return $data->__repr__();
	}
	elsif ($self->array) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID unless $Dotiac::DTL::Max_Depth;
		$value=join(" ",map {str($_,$Dotiac::DTL::Max_Depth)} @{$data});
	}
	elsif ($self->hash) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID unless $Dotiac::DTL::Max_Depth;
		$value=join(" ",map {str($data->{$_},$Dotiac::DTL::Max_Depth)} sort keys  %{$data});
	}
	unless ($self->[1]) {
		$value=~s/&/&/g;
		$value=~s/
		$value=~s/>/>/g;
		$value=~s/\"/"/g;
		$value=~s/\'/'/g;
	}
	return $value;
}


#Recursive repr rendering
sub rep {
	my $data=shift;
	my $level=shift;
	return unless $level;
	if (not defined $data) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID;
	}
	if (not ref $data) {
		return $data;
	}
	if (Scalar::Util::blessed($data)) {
		return $data->string() if $data->can("string");
		return $data->__str__() if $data->can("__str__");
		return $data->ToString() if $data->can("ToString");
		return $data->repr() if $data->can("repr");
		return $data->__repr__() if $data->can("__repr__");
		return $data;
	}
	if (Scalar::Util::reftype($data) eq "HASH" and $level > 1) {
		return join(" ",map {rep($data->{$_},$level-1)} sort keys %{$data});
	}
	if (Scalar::Util::reftype($data) eq "ARRAY" and $level > 1) {
		return join(" ",map {rep($_,$level-1)} @{$data});
	}
	return $data;
}

sub repr {
	my $self=shift;
	my $data=$self->[0];
	if ($self->undef()) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID;
	}
	elsif ($self->scalar()) {
		return $data;
	}
	elsif ($self->object and $data->can("string")) {
		return $data->string();
	}
	elsif ($self->object and $data->can("__str__")) {
		return $data->__str__();
	}
	elsif ($self->object and $data->can("ToString")) {
		return $data->ToString();
	}
	elsif ($self->object and $data->can("repr")) {
		return $data->repr();
	}
	elsif ($self->object and $data->can("__repr__")) {
		return $data->__repr__();
	}
	elsif ($self->array) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID unless $Dotiac::DTL::Max_Depth;
		return join(" ",map {rep($_,$Dotiac::DTL::Max_Depth)} @{$data});
	}
	elsif ($self->hash) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID unless $Dotiac::DTL::Max_Depth;
		return join(" ",map {rep($data->{$_},$Dotiac::DTL::Max_Depth)} sort keys %{$data});
	}
	return $data;
}


sub pyrep {
	my $data=shift;
	my $level=shift;
	return unless $level;
	if (not defined $data) {
		return "null";
	}
	if (not ref $data) {
		return $data if Scalar::Util::looks_like_number($data);
		return '"'.$data.'"';
	}
	if (Scalar::Util::blessed($data)) {
		return $data->repr() if $data->can("repr");
		return $data->__repr__() if $data->can("__repr__");
		return $data->string() if $data->can("string");
		return $data->__str__() if $data->can("__str__");
		return $data->ToString() if $data->can("ToString");
		return $data;
	}
	if (Scalar::Util::reftype($data) eq "HASH" and $level > 1) {
		return "(".join(", ",map {"$_:".pyrep($data->{$_},$level-1)} sort keys %{$data}).")";
	}
	if (Scalar::Util::reftype($data) eq "ARRAY" and $level > 1) {
		return "(".join(", ",map {pyrep($_,$level-1)} @{$data}).")";
	}
	return $data;
}

sub pyrepr {
	my $self=shift;
	my $data=$self->[0];
	if ($self->undef()) {
		return "null";
	}
	elsif ($self->number()) {
		return $data;
	}
	elsif ($self->scalar()) {
		return '"'.$data.'"';
	}
	elsif ($self->object and $data->can("repr")) {
		return $data->repr();
	}
	elsif ($self->object and $data->can("__repr__")) {
		return $data->__repr__();
	}
	elsif ($self->object and $data->can("string")) {
		return $data->string();
	}
	elsif ($self->object and $data->can("__str__")) {
		return $data->__str__();
	}
	elsif ($self->object and $data->can("ToString")) {
		return $data->ToString();
	}
	elsif ($self->array) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID unless $Dotiac::DTL::Max_Depth;
		return "(".join(", ",map {pyrep($_,$Dotiac::DTL::Max_Depth)} @{$data}).")";
	}
	elsif ($self->hash) {
		return $Dotiac::DTL::TEMPLATE_STRING_IF_INVALID unless $Dotiac::DTL::Max_Depth;
		return "(".join(", ",map {"$_:".pyrep($data->{$_},$Dotiac::DTL::Max_Depth)} sort keys %{$data}).")";
	}
	return $data;
}


sub stringnodefault {
	my $self=shift;
	if ($self->undef) {
		return undef;
	}
	return $self->string();
}

sub set {
	my $self=shift;
	my $data=shift;
	$self->[0]=$data;
	my $r=Scalar::Util::reftype($data);
	$r="" unless $r;
	$self->[2]=$r;
	$self->[3]=Scalar::Util::blessed($data);
	$self->[4]=($r?0:Scalar::Util::looks_like_number($data));
	return $self;
}

1;

__END__