lsg

Template.pm (6268B)

---

 #!/usr/bin/env perl
 
 # LSG::Template - template processor for the LSG
 # Written by lumidify <nobody@lumidify.org>
 #
 # To the extent possible under law, the author has dedicated
 # all copyright and related and neighboring rights to this
 # software to the public domain worldwide. This software is
 # distributed without any warranty.
 #
 # You should have received a copy of the CC0 Public Domain
 # Dedication along with this software. If not, see
 # <http://creativecommons.org/publicdomain/zero/1.0/>.
 
 package LSG::Template;
 use strict;
 use warnings;
 use utf8;
 use open qw< :encoding(UTF-8) >;
 binmode STDIN, ":encoding(UTF-8)";
 binmode STDOUT, ":encoding(UTF-8)";
 binmode STDERR, ":encoding(UTF-8)";
 use File::Spec::Functions qw(catfile);
 use Storable 'dclone';
 use LSG::Config qw($config);
 use LSG::Metadata;
 
 sub parse_template {
 	my $template_name = shift;
 	my $state = 0;
 	my $IN_BRACE = 1;
 	my $IN_BLOCK = 2;
 	my $txt = "";
 	my $bs = 0;
 
 	# Note: there needs to be a line between metadata and content since the
 	# metadata parser takes a line to realize it is not in fm anymore
 	my $inpath = catfile("templates", $template_name);
 	open(my $in, "<", $inpath) or die "ERROR: template: Can't open $inpath for reading.";
 	my $template = LSG::Metadata::parse_metadata_file($in);
 
 	foreach (<$in>) {
 		foreach my $char (split //, $_) {
 			if ($char eq "\\") {
 				$bs++;
 				if (!($bs %= 2)) {$txt .= "\\"};
 			} elsif ($bs % 2) {
 				$txt .= $char;
 				$bs = 0;
 			} elsif ($char eq "{" && !($state & $IN_BRACE)) {
 				$state |= $IN_BRACE;
 				if ($txt ne "") {
 					if ($state & $IN_BLOCK) {
 						push(@{$template->{"contents"}->[-1]->{"contents"}},
 						     {type => "txt", contents => $txt});
 					} else {
 						push(@{$template->{"contents"}}, {type => "txt", contents => $txt});
 					}
 					$txt = "";
 				}
 			} elsif ($char eq "}" && $state & $IN_BRACE) {
 				$state &= ~$IN_BRACE;
 				my @brace = split(/ /, $txt);
 				if (!@brace) {
 					die("ERROR: empty brace in $inpath:\n$_\n");
 				} else {
 					if ($brace[0] eq "endblock") {
 						$state &= ~$IN_BLOCK
 					} elsif ($brace[0] eq "block") {
 						$state |= $IN_BLOCK;
 						if ($#brace != 1) {
 							die("ERROR: wrong number of arguments for block in $inpath\n");
 						} else {
 							push(@{$template->{"contents"}}, {type => $brace[0],
 									 id => $brace[1],
 									 contents => []});
 						}
 					} else {
 						my %tmp = (type => $brace[0]);
 						if ($#brace > 0) {
 							@{$tmp{"args"}} = @brace[1..$#brace];
 						}
 						if ($state & $IN_BLOCK) {
 							push(@{$template->{"contents"}->[-1]->{"contents"}}, \%tmp);
 						} else {
 							push(@{$template->{"contents"}}, \%tmp);
 						}
 					}
 				}
 				$txt = "";
 			} else {
 				$txt .= $char;
 			}
 		}
 	}
 	if ($state & ($IN_BRACE | $IN_BLOCK)) {
 		die("ERROR: unclosed block or brace in $inpath\n");
 	} elsif ($txt ne "") {
 		push(@{$template->{"contents"}}, {type => "txt", contents => $txt});
 	}
 	close($in);
 	my $modified_date = (stat($inpath))[9];
 	$template->{"modified"} = $modified_date;
 	return $template;
 }
 
 sub handle_parent_template {
 	my $parentid = shift;
 	my $childid = shift;
 	if (exists $config->{"templates"}->{$parentid}->{"extends"}) {
 		handle_parent_template($config->{"templates"}->{$parentid}->{"extends"}, $parentid);
 	}
 	if ($config->{"templates"}->{$parentid}->{"modified"} > $config->{"templates"}->{$childid}->{"modified"}) {
 		$config->{"templates"}->{$childid}->{"modified"} = $config->{"templates"}->{$parentid}->{"modified"};
 	}
 	my $parent = $config->{"templates"}->{$parentid}->{"contents"};
 	my $child = $config->{"templates"}->{$childid}->{"contents"};
 	my $child_new = dclone($parent);
 	# Replace blocks from parent template with child blocks
 	# Not very efficient...
 	foreach my $item (@{$child_new}) {
 		if ($item->{"type"} eq "block") {
 			foreach my $item_new (@{$child}) {
 				if ($item_new->{"type"} eq "block" && $item_new->{"id"} eq $item->{"id"}) {
 					$item->{"contents"} = $item_new->{"contents"};
 					last;
 				}
 			}
 		}
 	}
 	$config->{"templates"}->{$childid}->{"contents"} = $child_new;
 	delete $config->{"templates"}->{$childid}->{"extends"};
 }
 
 sub do_template_inheritance {
 	foreach my $template_id (keys %{$config->{"templates"}}) {
 		if (exists $config->{"templates"}->{$template_id}->{"extends"}) {
 			handle_parent_template($config->{"templates"}->{$template_id}->{"extends"}, $template_id);
 		}
 	}
 }
 
 sub init_templates {
 	opendir(my $dir, "templates") or die "ERROR: couldn't open dir templates/\n";
 	my @files = grep {!/\A\.\.?\z/} readdir($dir);
 	closedir($dir);
 	foreach my $filename (@files) {
 		$config->{"templates"}->{$filename} = parse_template($filename);
 	}
 	do_template_inheritance();
 }
 
 # FIXME: more error checking - arg numbers
 # -> not too important though since these are just templates (won't be edited too often)
 sub do_template_items {
 	my $main_content = shift;
 	my $lang = shift;
 	my $pageid = shift;
 	my $template = shift;
 	my $final = "";
 	for my $item (@{$template->{"contents"}}) {
 		if ($item->{"type"} eq "txt") {
 			$final .= $item->{"contents"};
 		} elsif ($item->{"type"} eq "var") {
 			$final .= $config->{"metadata"}->{$pageid}->{$lang}->{$item->{"args"}->[0]};
 		} elsif ($item->{"type"} eq "content") {
 			$final .= $main_content;
 		} elsif ($item->{"type"} eq "block") {
 			$final .= do_template_items($main_content, $lang, $pageid, $item);
 		} elsif ($item->{"type"} eq "func") {
 			my $func = $item->{"args"}->[0];
 			my @func_args = @{$item->{"args"}}[1..$#{$item->{"args"}}];
 			# Pass in the array rather than a reference, so these arguments
 			# are received like all other arguments
 			if (!exists($config->{"funcs"}->{$func})) {
 				# FIXME: need more information to give for error
 				die "ERROR: undefined function \"$func\" in template.\n";
 			}
 			$final .= $config->{"funcs"}->{$func}->($pageid, $lang, @func_args);
 		}
 	}
 	return $final;
 }
 
 sub render_template {
 	my $html = shift;
 	my $lang = shift;
 	my $pageid = shift;
 	my $template = $config->{"metadata"}->{$pageid}->{"template"};
 	if (!exists($config->{"templates"}->{"$template.$lang.html"})) {
 		die "ERROR: can't open template $template.$lang.html\n";
 	}
 	return do_template_items($html, $lang, $pageid, $config->{"templates"}->{"$template.$lang.html"});
 }
 
 1;