File Coverage

blib/lib/ZM/Template.pm

Criterion	Covered	Total	%
statement	15	315	4.7
branch	0	76	0.0
condition	0	21	0.0
subroutine	5	35	14.2
pod	0	23	0.0
total	20	470	4.2

# Zet Maximum template parser
#
#		2002-2009
#		Version 0.7.2 production
#		Author	Maxim Kashliak	([e-mail])
#				Aleksey V. Ivanov	([e-mail])
#
#		For latest releases, documentation, faqs, etc see the homepage at
#			http://perl.zmaximum.ru
#
#
package ZM::Template;

use strict;
use vars qw($AUTOLOAD);
use Carp;
use MIME::Base64;
no strict 'refs';

$ZM::Template::VERSION = '0.7.2';

sub new()
{
    my $class = shift;
    my %baseHtml=@_;
    $baseHtml{tag}="__" if (!defined $baseHtml{tag} || $baseHtml{tag} eq "");
    $baseHtml{_loops_filled}=0;
    bless \%baseHtml, $class;
    return \%baseHtml
}

sub src()
{
    if ($#_ !=1)
    {
        die_msg("Error! template function requires a single parameter\n");
    }

    my $self = shift;
    my $src = shift;

    my $suxx=$/;
    undef $/;
    open(HTML, "<$src") || die_msg("Cannot open html template file!($src)");
    my $tmplString = ;
    close HTML;
    $/=$suxx;
    # ÏÂÒÁÂÏÔËÁ SSI ÄÅÒÅËÔÉ× ×ÎÕÔÒÉ ÔÅÍÐÌÅÊÔÁ
    eval('require ZM::SSI;');
    $tmplString = ZM::SSI::parse($tmplString) unless $@;
    # ÚÁÄÁÅÍ ÐÁÐËÕ ÄÌÑ ÈÒÁÎÅÎÉÑ ËÅÛÁ, ÅÓÌÉ ÏÎÁ ÎÅ ÂÙÌÁ ÕËÁÚÁÎÁ ÐÒÉ ÓÏÚÄÁÎÉÉ ÏÂßÅËÔÁ
    unless (defined $self->{cacheDIR})
    {
	$src=~s/\/.*?$//;
	$self->{cacheDIR}=$src.'/cache';
    }

    $self->srcString($tmplString);
}

sub srcString
{
    my $self = shift;
    my $str = shift;
    $self->{html}=$str;
    _parse_tokens($self,$str);
}
sub srcStringSSI
{
    my $self = shift;
    my $str = shift;
    eval('require ZM::SSI;');
    $str = ZM::SSI::parse($str) unless $@;
    $self->{html}=$str;
    _parse_tokens($self,$str);
}


sub listAllTokens
{
	my $self=shift;
	return(keys %{$self->{tokens}});
}

sub _parse_tokens
{
    my $self=shift;
    my $htmlString=shift;
    my ($padding, $token, $remainder);

#    while ($htmlString =~ /.*?(($self->{tag}x_.+?$self->{tag}\n)|($self->{tag}([^_]).*?$self->{tag}))/sg)
#    while ($htmlString =~ /.*?$self->{tag}((x_)?.+?)$self->{tag}/sg) #orig
    while ($htmlString =~ /.*?$self->{tag}([\da-zA-Z]([\_\-]*[\da-zA-Z])*?)$self->{tag}/sg)
    {
        $token = $1;
        $token =~ s/\n$//g;         # chomp $token (chomp bust as $/ undef'd)
#	$token =~ s/(^$self->{tag}|$self->{tag}$)//g;
	$self->{tokens}{$token}=1;
    }
}

sub AUTOLOAD
{
	my $token = $AUTOLOAD;
	my ($self, $value, $block) = @_;
	$token =~ s/.*:://;
	# ÚÄÅÓØ ÎÁÄÏ ÐÒÏ×ÅÒÉÔØ ÎÅ ×ÙÇÌÑÄÉÔ ÌÉ ÎÁÛÁ ÚÁÍÅÎÁ ËÁË ÔÏËÅÎ, ÉÎÁÞÅ ÏÎÁ ÓÏÔÒÅÔÓÑ × ÐÏÓÌÅÄÓÔ×ÉÉ
	#while ($value =~ /.*?$self->{tag}([^_].*?)$self->{tag}/s)
	#{
	# 	my $vtoken = $1;
        #	$vtoken =~ s/\n$//g;
	#	$nottokens{$vtoken}=1;
	#}
	if (defined $self->{tokens}{$token})
	{
	    if (defined $block and $block ne "")
	    {
		my $bl_new=$block."_new";
		$bl_new=~s/^x_//; #ÎÁÄÏ ÏÂÏÊÔÉÓØ ÂÅÚ ÒÅÇÅËÓÐÁ
		my $loop;
		if (defined $self->{loops}{$bl_new})
		{
		    my $flag=0;
		    foreach $loop(@{$self->{loops}{$bl_new}})
		    {
			if(strstr($loop,"$self->{tag}".$token."$self->{tag}"))
			{
			    $flag++;
			    last;
			}
		    }
		    $self->_post_loop($block) unless($flag);
		}
		$self->_set_loop($token,$value,$block);
	    }
	    else
	    {
    		$self->{html}=$self->set_to_str($token,$value,$self->{html});
	    }
	}
}

sub setif
{
	my $self = shift;
	my $token = shift;
	my $loop = shift;

	if(!defined $loop or $loop eq "")
	{
		$self->{ifs}->{$token}=1;
	}
	else
	{
		$self->{ifs_loop}->{$loop}->{$token}=1;
	}
}

sub delif
{
	my $self = shift;
	my $token = shift;
	my $loop = shift;

	if(!defined $loop or $loop eq "")
	{
		delete $self->{ifs}->{$token};
	}
	else
	{
		delete $self->{ifs_loop}->{$loop}->{$token};
	}
}

sub fromfile
{
    my $self = shift;
    my $token = shift;
    my $file = shift;
    my $block = shift;

    open (my $f,"<$file") or return;
    my $suxx=$/;
    undef $/;
    my $filecontent=<$f>;
    $/=$suxx;
    close($f);
    $self->$token($filecontent,$block);
}

sub _set_loop
{
    my $self=shift;
    my $token=shift;
    my $value=shift;
    my $block=shift;

    $block=~s/^x_//;
    my ($loop, $loop_name, $loop_begin, $num, $loop2, $loop3, $loop_after, $loops_ref);
    my @loops=();
    if(defined $self->{loops}{$block."_new"})
    {
	# ÅÓÌÉ ÕÖÅ ×ÙÓÔÁ×ÌÑÌÉÓØ ÔÏËÅÎÙ × ÜÔÏÍ ÃÉËÌÅ
        $loops_ref=$self->{loops}{$block."_new"};
    }
    else
    {
	# ÅÓÌÉ ÅÝÅ ÎÅ ×ÓÔÁ×ÌÑÌÉÓØ ÔÏËÅÎÙ × ÜÔÏÍ ÃÉËÌÅ,
	# ÔÏ ×ÙÄÉÒÁÅÍ ÔÅÌÏ ÃÉËÌÁ ÉÚ ×ÓÅÇÏ ÛÁÂÌÏÎÁ
        $loop_name="$self->{tag}x_".$block."$self->{tag}";
	# ÍÙ ÉÝÅÍ ×ÓÅ ÃÉËÌÙ Ó ÔÁËÉÍ ÉÍÅÎÅÍ ×Ï ×ÓÅÍ ÄÏËÕÍÅÎÔÅ
	$loop_after=$self->{html};
        while($loop_begin=strstr($loop_after,$loop_name))
	{
    	    $loop_begin=substr($loop_begin,length($loop_name));
    	    ($loop,$loop_after)=str_split($loop_begin,$loop_name);
	    push(@{$loops_ref},$loop);
	}
    }
    my $loop_number=0;
    foreach $loop(@$loops_ref)
    {
        if(strstr($loop,"$self->{tag}z_".$block."$self->{tag}"))
	{
	    $self->{strnum}{$block}++;
    	    $num=$self->{strnum}{$block};
            $loop2=$loop3=$loop;
	    while(($num)&&(($loop2=str_before($loop3,"$self->{tag}z_".$block."$self->{tag}")) ne $loop3))
    	    {
    		$num--;
	        $loop3=str_after($loop3,"$self->{tag}z_".$block."$self->{tag}");
    	    }
            if($num==0)
	    {
    	        $loop=$loop2;
        	#$self->{strnum}{$block}++;
            }
	    elsif($num>=1)
	    {
        	#$loop=str_before($loop,"$self->{tag}z_".$block."$self->{tag}");
		$loop=$loop3;
		$self->{strcount}{$block}=$self->{strnum}{$block}-1; #ÚÁÐÏÍÎÉÍ ÎÏÍÅÒ ÐÏÓÌÅÄÎÅÇÏ ÂÌÏËÁ ÐÅÒÅÄ ÐÅÒÅÈÏÄÏÍ ÎÁ ÐÅÒ×ÙÊ
                $self->{strnum}{$block}=0;
    	    }
        }
	$self->{loops}{$block.'_new'}[$loop_number]=$self->set_to_str($token,$value,$loop);
	$loop_number++;
    }
}

sub _post_loop
{
    my $self=shift;
    my $block=shift;

    $block=~s/^x_//;

    my ($text,$pos, $before_loop, $loop, $loop_name, $after_loop);
    my $loop_number;
    if($self->{strnum}{$block}>1)
    {
	$loop_number=$self->{strnum}{$block}-1;
    }
    elsif(defined $self->{strnum}{$block} && $self->{strnum}{$block}==0)
    {
	$loop_number=$self->{strcount}{$block};
    }
    else
    {
        $loop_number=0;
    }
    my $i=0;
    foreach $text (@{$self->{loops}{$block."_new"}})
    {
	#Find and post inner loops
	my %found_loops;
	while($pos=strstr($text,"$self->{tag}x_"))
	{
    	    $before_loop=substr($text,0,length($text)-length($pos));
    	    $loop_name=substr($pos,4);
    	    $loop_name=substr($loop_name,0,length($loop_name)-length(strstr($loop_name,"$self->{tag}")));
	    $loop=strstr($text,"$self->{tag}x_".$loop_name."$self->{tag}");
    	    $after_loop=str_after(str_after($loop,"$self->{tag}x_".$loop_name."$self->{tag}"),"$self->{tag}x_".$loop_name."$self->{tag}");
            $loop=substr($loop,0,length($loop)-length($after_loop));
	    $self->_post_loop($loop_name) if (defined $self->{loops}{$loop_name.'_new'});
	    $found_loops{$loop_name}++;
	    $text=$before_loop.$self->{loops}{$loop_name}[$loop_number].$after_loop;
	}
	# delete inner loops
	foreach $loop_name (keys %found_loops)
	{
	    delete $self->{loops}{$loop_name};
	    delete $self->{strnum}{$loop_name};
	    delete $self->{strcount}{$loop_name};
	}
	$text=_fill_ifs($self,$text,'x_'.$block);
	#$self->{loops}{$block."_new"}=$text;
	#POST
        $self->{loops}{$block}[$i] .= $text;
	$i++;
    }
    delete $self->{ifs_loop}->{'x_'.$block}; # we must clear IFs for this loop
    delete $self->{loops}{$block.'_new'};
}

sub set_to_str
{
    my $self=shift;
    my $token=shift;
    my $value=shift;
    my $str=shift;

    my $ret="";
    my $sub_str;
    my $loop_name;
    while(($sub_str=str_before($str,"$self->{tag}x_")) ne $str)
    {
	# ÐÏÌÕÞÁÅÍ ÉÍÑ ÃÉËÌÁ
	$loop_name=str_before(substr($str,length($sub_str)+4),"$self->{tag}");
	# ÚÁÍÅÎÑÅÍ ÐÅÒÅÍÅÎÎÕÀ ÐÅÒÅÄ ÃÉËÌÏÍ, ÅÓÌÉ ÏÎÁ ÔÁÍ ÅÓÔØ
        $ret.=str_replace("$self->{tag}".$token."$self->{tag}",$value,$sub_str);
        $ret.="$self->{tag}x_".$loop_name."$self->{tag}".str_before(substr($str,length($sub_str)+length($loop_name)+6),"$self->{tag}x_".$loop_name."$self->{tag}")."$self->{tag}x_".$loop_name."$self->{tag}";
        $str=str_after(substr($str,length($sub_str)+length($loop_name)+6),"$self->{tag}x_".$loop_name."$self->{tag}");
    }
    $ret.=str_replace("$self->{tag}".$token."$self->{tag}",$value,$str);
    return($ret);
}

sub _fill_ifs
{
    my $self=shift;
    my $text=shift;
    my $l_name=shift;
    my ($pos,$before_loop,$if_name,$loop,$loop_name,$after_loop,$h_ifs);
    if(!defined $l_name || $l_name eq '')
    {
    	$h_ifs=$self->{ifs};
    }
    else
    {
	# ÎÁÄÏ ÚÁÐÏÌÎÉÔØ IF ÄÌÑ ÃÉËÌÁ
    	$h_ifs=$self->{ifs_loop}->{$l_name};
    }
    # ÕÄÁÌÑÅÍ ÎÅÚÁÐÏÌÎÅÎÎÙÅ IF É ×ÓÔÁ×ÌÑÅÍ ÚÁÐÏÌÎÅÎÎÙÅ × ÏËÏÎÞÁÔÅÌØÎÙÊ ÔÅËÓÔ
    while($pos=strstr($text,"$self->{tag}if_"))
    {
        $before_loop=substr($text,0,length($text)-length($pos));
        $loop_name=substr($pos,5);
        $loop_name=substr($loop_name,0,length($loop_name)-length(strstr($loop_name,"$self->{tag}")));
	$if_name="$self->{tag}if_".$loop_name."$self->{tag}";
	$loop=$pos;
	$after_loop=str_after(str_after($loop,$if_name),$if_name);
	$loop=substr($loop,length($if_name),length($loop)-length($after_loop)-length($if_name)*2);
	unless(defined $h_ifs->{$loop_name})
	{
		#IF ÎÅ ×ÙÓÔÁ×ÌÑÌÓÑ
		if($pos=strstr($loop,"$self->{tag}else_".$loop_name))
		{
			#else ÅÓÔØ É ÅÇÏ ÎÁÄÏ ÏÓÔÁ×ÉÔØ
			$loop=substr($pos,9+length($loop_name));
		}
		else
		{
			#else ÎÅÔ
			$loop="";
		}
	}
	else
	{
	    #ÕÂÉÒÁÅÍ ÓÏÄÅÒÖÉÍÏÅ ELSE, ÅÓÌÉ ÔÁËÏ×ÏÊ ÅÓÔØ
	    if($pos=strstr($loop,"$self->{tag}else_".$loop_name))
	    {
		#else ÅÓÔØ É ÅÇÏ ÎÁÄÏ ÏÓÔÁ×ÉÔØ
		$loop=str_before($loop,$pos);
	    }
	    #undef $h_ifs->{$loop_name} if(!defined $l_name || $l_name eq '')

	}
	$text=$before_loop.$loop.$after_loop;
    }
    return($text);
}

sub _fill_loops
{
    my $self=shift;
    my $text=shift;
    unless($self->{_loops_filled})
    {
        my ($pos, $before_loop, $loop_name, $loop, $after_loop);

	# ÐÏÓÔÉÍ ÔÅ ÌÕÐÙ, ÞÔÏ ÚÁÐÏÎÉÌÉÓØ, ÎÏ ÎÅ ÚÁÐÏÌÎÉÌÉÓØ
        foreach(keys %{$self->{loops}})
	{
	    if (($loop_name=str_before($_,"_new")) ne $_)
	    {
		$self->_post_loop($loop_name) if($self->{loops}{$_} ne "");
	    }
	}
	# ÕÄÁÌÑÅÍ ÎÅÚÁÐÏÌÎÅÎÎÙÅ ÌÕÐÙ É ×ÓÔÁ×ÌÑÅÍ ÚÁÐÏÌÎÅÎÎÙÅ × ÏËÏÎÞÁÔÅÌØÎÙÊ ÔÅËÓÔ
	while($pos=strstr($text,"$self->{tag}x_"))
	{
    	    $before_loop=substr($text,0,length($text)-length($pos));
    	    $loop_name=substr($pos,4);
    	    $loop_name=substr($loop_name,0,length($loop_name)-length(strstr($loop_name,"$self->{tag}")));
    	    #$loop=strstr($text,"$self->{tag}x_".$loop_name."$self->{tag}");
	    $loop=$pos;
    	    $after_loop=str_after(str_after($loop,"$self->{tag}x_".$loop_name."$self->{tag}"),"$self->{tag}x_".$loop_name."$self->{tag}");
    	    $loop=substr($loop,0,length($loop)-length($after_loop));
    	    $text=$before_loop.shift(@{$self->{loops}{$loop_name}}).$after_loop;
	}
	my $tag=$self->{tag};
	my $if_name;
	$text=_fill_ifs($self,$text);
	$text=~s/($tag)[\da-zA-Z\-][\w\-]*?($tag)//g;
	$self->{_loops_filled}=1;
    }
    return($text);
}


sub strstr
{
    my $str=shift;
    my $str2=shift;
    my $index=index($str,$str2);
    if ($index>-1)
    {
        $str=substr($str,$index,length($str)-$index);
        return($str);
    }
    else
    {
		return undef;
    }
}

sub str_before
{
    my $str=shift;
    my $str2=shift;
    my $indx=index($str,$str2);
    if($indx!=-1)
    {
	$str=substr($str,0,$indx);
    }
    return $str;
}
sub str_split
{
    my $str=shift;
    my $str2=shift;
    my $indx=index($str,$str2);
    if($indx!=-1)
    {
        my $lstr2=length($str2);
        $str2=substr($str,$indx+$lstr2,length($str)-$indx-$lstr2);
        $str=substr($str,0,$indx);
    }
    else
    {
        $str2='';
    }
    return ($str,$str2);
}
sub str_3_split
{
    my $str=shift;
    my $str1=shift;
    my $str2=shift;
    ($str1,$str)=str_split($str,$str1);
    if($str ne '')
    {
        ($str2,$str)=str_split($str,$str2);
    }
    else
    {
        $str2='';
    }
    return($str1,$str2,$str);
}
sub str_after
{
    my $str=shift;
    my $str2=shift;
    my $indx=index($str,$str2);
    if($indx!=-1)
    {
        $str=substr($str,$indx+length($str2),length($str)-$indx-length($str2));
    }
    return($str);
}


sub str_between
{
    my $str=shift;
    my $str1=shift;
    my $str2=shift;
    my $ret=str_after($str,$str1);
    return(str_before($ret,$str2));
}

sub str_replace
{
    my $str=shift;
    my $str1=shift;
    my $str2=shift;

    $str2=~s/$str/$str1/g;
    return($str2);
}

sub output()
{
    my $self = shift;
    my $hdr;

    foreach $hdr (@_)
    {
        print "$hdr\n";
    }

    print "\n";
#    $self->{html}=$self->_fill_loops($self->{html});
    print $self->htmlString();
}

sub setCache
{
    my $self = shift;
    my $cacheKey = shift;
    return 0 unless (defined $self->{cacheDIR});
    mkdir($self->{cacheDIR}) unless(-d $self->{cacheDIR});
    my $encodedKey=encode_base64($cacheKey);
#    chomp($encodedKey);
    $encodedKey=~s/[\n\s]//sg;
    open(my $f,'>'.$self->{cacheDIR}.'/'.$encodedKey);
    print $f $self->htmlString();
    close($f);
    return 1;
}

sub getCache
{
    my $self = shift;
    my $cacheKey = shift;
    return 0 unless (defined $self->{cacheDIR});
    my $encodedKey=encode_base64($cacheKey);
#    chomp($encodedKey);
    $encodedKey=~s/[\n\s]//sg;
    my $cacheFile = $self->{cacheDIR}.'/'.$encodedKey;
    return 0 unless(-f $cacheFile);
    my $suxx=$/;
    undef $/;
    open(my $f, $cacheFile);
    $self->{html}=<$f>;
    close($f);
    $/=$suxx;
    $self->{_loops_filled}=1;
    return 1;
}

sub rmCache
{
    my $self = shift;
    my $cacheKey = shift;
    my $encodedKey=encode_base64($cacheKey);
    $encodedKey=~s/[\n\s]//sg;
#    chomp($encodedKey);
    return unlink($self->{cacheDIR}.'/'.$encodedKey);
}

sub clearCache
{
    my $self = shift;
    return 0 unless (defined $self->{cacheDIR});
    unlink (glob($self->{cacheDIR}.'/*'));
    return 1;
}

sub htmlString()
{
    my $self = shift;
    $self->{html}=$self->_fill_loops($self->{html});
    return $self->{html};
}

sub DESTROY()
{
}

sub die_msg
{
    my $msg = shift;
	print "Content-type: text/html\n\n";
	print <



		ZM::Template Error: $msg


EOF
    exit;
}

1;

__END__