35e279a68232c7b0a6e6fb353d3af448cd35df94
[ikiwiki.git] / IkiWiki / Render.pm
1 #!/usr/bin/perl
2
3 package IkiWiki;
4
5 use warnings;
6 use strict;
7 use File::Spec;
8 use IkiWiki;
9
10 sub linkify ($$) { #{{{
11         my $content=shift;
12         my $page=shift;
13
14         $content =~ s{(\\?)$config{wiki_link_regexp}}{
15                 $2 ? ( $1 ? "[[$2|$3]]" : htmllink($page, titlepage($3), 0, 0, pagetitle($2)))
16                    : ( $1 ? "[[$3]]" :    htmllink($page, titlepage($3)))
17         }eg;
18         
19         return $content;
20 } #}}}
21
22 my $_scrubber;
23 sub scrubber { #{{{
24         return $_scrubber if defined $_scrubber;
25         
26         eval q{use HTML::Scrubber};
27         # Lists based on http://feedparser.org/docs/html-sanitization.html
28         $_scrubber = HTML::Scrubber->new(
29                 allow => [qw{
30                         a abbr acronym address area b big blockquote br
31                         button caption center cite code col colgroup dd del
32                         dfn dir div dl dt em fieldset font form h1 h2 h3 h4
33                         h5 h6 hr i img input ins kbd label legend li map
34                         menu ol optgroup option p pre q s samp select small
35                         span strike strong sub sup table tbody td textarea
36                         tfoot th thead tr tt u ul var
37                 }],
38                 default => [undef, { map { $_ => 1 } qw{
39                         abbr accept accept-charset accesskey action
40                         align alt axis border cellpadding cellspacing
41                         char charoff charset checked cite class
42                         clear cols colspan color compact coords
43                         datetime dir disabled enctype for frame
44                         headers height href hreflang hspace id ismap
45                         label lang longdesc maxlength media method
46                         multiple name nohref noshade nowrap prompt
47                         readonly rel rev rows rowspan rules scope
48                         selected shape size span src start summary
49                         tabindex target title type usemap valign
50                         value vspace width
51                 }}],
52         );
53         return $_scrubber;
54 } # }}}
55
56 sub htmlize ($$) { #{{{
57         my $type=shift;
58         my $content=shift;
59         
60         if (! $INC{"/usr/bin/markdown"}) {
61                 no warnings 'once';
62                 $blosxom::version="is a proper perl module too much to ask?";
63                 use warnings 'all';
64                 do "/usr/bin/markdown";
65         }
66         
67         if ($type eq '.mdwn') {
68                 $content=Markdown::Markdown($content);
69         }
70         else {
71                 error("htmlization of $type not supported");
72         }
73
74         if ($config{sanitize}) {
75                 $content=scrubber()->scrub($content);
76         }
77         
78         return $content;
79 } #}}}
80
81 sub backlinks ($) { #{{{
82         my $page=shift;
83
84         my @links;
85         foreach my $p (keys %links) {
86                 next if bestlink($page, $p) eq $page;
87                 if (grep { length $_ && bestlink($p, $_) eq $page } @{$links{$p}}) {
88                         my $href=File::Spec->abs2rel(htmlpage($p), dirname($page));
89                         
90                         # Trim common dir prefixes from both pages.
91                         my $p_trimmed=$p;
92                         my $page_trimmed=$page;
93                         my $dir;
94                         1 while (($dir)=$page_trimmed=~m!^([^/]+/)!) &&
95                                 defined $dir &&
96                                 $p_trimmed=~s/^\Q$dir\E// &&
97                                 $page_trimmed=~s/^\Q$dir\E//;
98                                        
99                         push @links, { url => $href, page => $p_trimmed };
100                 }
101         }
102
103         return sort { $a->{page} cmp $b->{page} } @links;
104 } #}}}
105
106 sub parentlinks ($) { #{{{
107         my $page=shift;
108         
109         my @ret;
110         my $pagelink="";
111         my $path="";
112         my $skip=1;
113         foreach my $dir (reverse split("/", $page)) {
114                 if (! $skip) {
115                         $path.="../";
116                         unshift @ret, { url => "$path$dir.html", page => $dir };
117                 }
118                 else {
119                         $skip=0;
120                 }
121         }
122         unshift @ret, { url => length $path ? $path : ".", page => $config{wikiname} };
123         return @ret;
124 } #}}}
125
126 sub preprocess ($$) { #{{{
127         my $page=shift;
128         my $content=shift;
129
130         my $handle=sub {
131                 my $escape=shift;
132                 my $command=shift;
133                 my $params=shift;
134                 if (length $escape) {
135                         return "[[$command $params]]";
136                 }
137                 elsif (exists $plugins{preprocess}{$command}) {
138                         my %params;
139                         while ($params =~ /(\w+)=\"([^"]+)"(\s+|$)/g) {
140                                 $params{$1}=$2;
141                         }
142                         return $plugins{preprocess}{$command}->(page => $page, %params);
143                 }
144                 else {
145                         return "[[$command not processed]]";
146                 }
147         };
148         
149         $content =~ s{(\\?)$config{wiki_processor_regexp}}{$handle->($1, $2, $3)}eg;
150         return $content;
151 } #}}}
152
153 sub add_depends ($$) { #{{{
154         my $page=shift;
155         my $globlist=shift;
156         
157         if (! exists $depends{$page}) {
158                 $depends{$page}=$globlist;
159         }
160         else {
161                 $depends{$page}.=" ".$globlist;
162         }
163 } # }}}
164
165 sub genpage ($$$) { #{{{
166         my $content=shift;
167         my $page=shift;
168         my $mtime=shift;
169
170         my $title=pagetitle(basename($page));
171         
172         my $template=HTML::Template->new(blind_cache => 1,
173                 filename => "$config{templatedir}/page.tmpl");
174         
175         if (length $config{cgiurl}) {
176                 $template->param(editurl => cgiurl(do => "edit", page => $page));
177                 $template->param(prefsurl => cgiurl(do => "prefs"));
178                 if ($config{rcs}) {
179                         $template->param(recentchangesurl => cgiurl(do => "recentchanges"));
180                 }
181         }
182
183         if (length $config{historyurl}) {
184                 my $u=$config{historyurl};
185                 $u=~s/\[\[file\]\]/$pagesources{$page}/g;
186                 $template->param(historyurl => $u);
187         }
188         if ($config{hyperestraier}) {
189                 $template->param(hyperestraierurl => cgiurl());
190         }
191
192         $template->param(
193                 title => $title,
194                 wikiname => $config{wikiname},
195                 parentlinks => [parentlinks($page)],
196                 content => $content,
197                 backlinks => [backlinks($page)],
198                 discussionlink => htmllink($page, "Discussion", 1, 1),
199                 mtime => scalar(gmtime($mtime)),
200                 styleurl => styleurl($page),
201         );
202         
203         return $template->output;
204 } #}}}
205
206 sub check_overwrite ($$) { #{{{
207         # Important security check. Make sure to call this before saving
208         # any files to the source directory.
209         my $dest=shift;
210         my $src=shift;
211         
212         if (! exists $renderedfiles{$src} && -e $dest && ! $config{rebuild}) {
213                 error("$dest already exists and was rendered from ".
214                         join(" ",(grep { $renderedfiles{$_} eq $dest } keys
215                                 %renderedfiles)).
216                         ", before, so not rendering from $src");
217         }
218 } #}}}
219
220 sub mtime ($) { #{{{
221         my $file=shift;
222         
223         return (stat($file))[9];
224 } #}}}
225
226 sub findlinks ($$) { #{{{
227         my $content=shift;
228         my $page=shift;
229
230         my @links;
231         while ($content =~ /(?<!\\)$config{wiki_link_regexp}/g) {
232                 push @links, titlepage($2);
233         }
234         # Discussion links are a special case since they're not in the text
235         # of the page, but on its template.
236         return @links, "$page/discussion";
237 } #}}}
238
239 sub render ($) { #{{{
240         my $file=shift;
241         
242         my $type=pagetype($file);
243         my $srcfile=srcfile($file);
244         if ($type ne 'unknown') {
245                 my $content=readfile($srcfile);
246                 my $page=pagename($file);
247                 
248                 $links{$page}=[findlinks($content, $page)];
249                 delete $depends{$page};
250                 
251                 $content=linkify($content, $page);
252                 $content=preprocess($page, $content);
253                 $content=htmlize($type, $content);
254                 
255                 check_overwrite("$config{destdir}/".htmlpage($page), $page);
256                 writefile(htmlpage($page), $config{destdir},
257                         genpage($content, $page, mtime($srcfile)));
258                 $oldpagemtime{$page}=time;
259                 $renderedfiles{$page}=htmlpage($page);
260         }
261         else {
262                 my $content=readfile($srcfile, 1);
263                 $links{$file}=[];
264                 delete $depends{$file};
265                 check_overwrite("$config{destdir}/$file", $file);
266                 writefile($file, $config{destdir}, $content, 1);
267                 $oldpagemtime{$file}=time;
268                 $renderedfiles{$file}=$file;
269         }
270 } #}}}
271
272 sub prune ($) { #{{{
273         my $file=shift;
274
275         unlink($file);
276         my $dir=dirname($file);
277         while (rmdir($dir)) {
278                 $dir=dirname($dir);
279         }
280 } #}}}
281
282 sub estcfg () { #{{{
283         my $estdir="$config{wikistatedir}/hyperestraier";
284         my $cgi=basename($config{cgiurl});
285         $cgi=~s/\..*$//;
286         open(TEMPLATE, ">$estdir/$cgi.tmpl") ||
287                 error("write $estdir/$cgi.tmpl: $!");
288         print TEMPLATE misctemplate("search", 
289                 "<!--ESTFORM-->\n\n<!--ESTRESULT-->\n\n<!--ESTINFO-->\n\n");
290         close TEMPLATE;
291         open(TEMPLATE, ">$estdir/$cgi.conf") ||
292                 error("write $estdir/$cgi.conf: $!");
293         my $template=HTML::Template->new(
294                 filename => "$config{templatedir}/estseek.conf"
295         );
296         eval q{use Cwd 'abs_path'};
297         $template->param(
298                 index => $estdir,
299                 tmplfile => "$estdir/$cgi.tmpl",
300                 destdir => abs_path($config{destdir}),
301                 url => $config{url},
302         );
303         print TEMPLATE $template->output;
304         close TEMPLATE;
305         $cgi="$estdir/".basename($config{cgiurl});
306         unlink($cgi);
307         symlink("/usr/lib/estraier/estseek.cgi", $cgi) ||
308                 error("symlink $cgi: $!");
309 } # }}}
310
311 sub estcmd ($;@) { #{{{
312         my @params=split(' ', shift);
313         push @params, "-cl", "$config{wikistatedir}/hyperestraier";
314         if (@_) {
315                 push @params, "-";
316         }
317         
318         my $pid=open(CHILD, "|-");
319         if ($pid) {
320                 # parent
321                 foreach (@_) {
322                         print CHILD "$_\n";
323                 }
324                 close(CHILD) || error("estcmd @params exited nonzero: $?");
325         }
326         else {
327                 # child
328                 open(STDOUT, "/dev/null"); # shut it up (closing won't work)
329                 exec("estcmd", @params) || error("can't run estcmd");
330         }
331 } #}}}
332
333 sub refresh () { #{{{
334         # find existing pages
335         my %exists;
336         my @files;
337         eval q{use File::Find};
338         find({
339                 no_chdir => 1,
340                 wanted => sub {
341                         if (/$config{wiki_file_prune_regexp}/) {
342                                 $File::Find::prune=1;
343                         }
344                         elsif (! -d $_ && ! -l $_) {
345                                 my ($f)=/$config{wiki_file_regexp}/; # untaint
346                                 if (! defined $f) {
347                                         warn("skipping bad filename $_\n");
348                                 }
349                                 else {
350                                         $f=~s/^\Q$config{srcdir}\E\/?//;
351                                         push @files, $f;
352                                         $exists{pagename($f)}=1;
353                                 }
354                         }
355                 },
356         }, $config{srcdir});
357         find({
358                 no_chdir => 1,
359                 wanted => sub {
360                         if (/$config{wiki_file_prune_regexp}/) {
361                                 $File::Find::prune=1;
362                         }
363                         elsif (! -d $_ && ! -l $_) {
364                                 my ($f)=/$config{wiki_file_regexp}/; # untaint
365                                 if (! defined $f) {
366                                         warn("skipping bad filename $_\n");
367                                 }
368                                 else {
369                                         # Don't add files that are in the
370                                         # srcdir.
371                                         $f=~s/^\Q$config{underlaydir}\E\/?//;
372                                         if (! -e "$config{srcdir}/$f" && 
373                                             ! -l "$config{srcdir}/$f") {
374                                                 push @files, $f;
375                                                 $exists{pagename($f)}=1;
376                                         }
377                                 }
378                         }
379                 },
380         }, $config{underlaydir});
381
382         my %rendered;
383
384         # check for added or removed pages
385         my @add;
386         foreach my $file (@files) {
387                 my $page=pagename($file);
388                 if (! $oldpagemtime{$page}) {
389                         debug("new page $page") unless exists $pagectime{$page};
390                         push @add, $file;
391                         $links{$page}=[];
392                         $pagesources{$page}=$file;
393                         $pagectime{$page}=mtime(srcfile($file))
394                                 unless exists $pagectime{$page};
395                 }
396         }
397         my @del;
398         foreach my $page (keys %oldpagemtime) {
399                 if (! $exists{$page}) {
400                         debug("removing old page $page");
401                         push @del, $pagesources{$page};
402                         prune($config{destdir}."/".$renderedfiles{$page});
403                         delete $renderedfiles{$page};
404                         $oldpagemtime{$page}=0;
405                         delete $pagesources{$page};
406                 }
407         }
408         
409         # render any updated files
410         foreach my $file (@files) {
411                 my $page=pagename($file);
412                 
413                 if (! exists $oldpagemtime{$page} ||
414                     mtime(srcfile($file)) > $oldpagemtime{$page}) {
415                         debug("rendering changed file $file");
416                         render($file);
417                         $rendered{$file}=1;
418                 }
419         }
420         
421         # if any files were added or removed, check to see if each page
422         # needs an update due to linking to them or inlining them.
423         # TODO: inefficient; pages may get rendered above and again here;
424         # problem is the bestlink may have changed and we won't know until
425         # now
426         if (@add || @del) {
427 FILE:           foreach my $file (@files) {
428                         my $page=pagename($file);
429                         foreach my $f (@add, @del) {
430                                 my $p=pagename($f);
431                                 foreach my $link (@{$links{$page}}) {
432                                         if (bestlink($page, $link) eq $p) {
433                                                 debug("rendering $file, which links to $p");
434                                                 render($file);
435                                                 $rendered{$file}=1;
436                                                 next FILE;
437                                         }
438                                 }
439                         }
440                 }
441         }
442
443         # Handle backlinks; if a page has added/removed links, update the
444         # pages it links to. Also handles rebuilding dependat pages.
445         # TODO: inefficient; pages may get rendered above and again here;
446         # problem is the backlinks could be wrong in the first pass render
447         # above
448         if (%rendered || @del) {
449                 foreach my $f (@files) {
450                         my $p=pagename($f);
451                         if (exists $depends{$p}) {
452                                 foreach my $file (keys %rendered, @del) {
453                                         next if $f eq $file;
454                                         my $page=pagename($file);
455                                         if (globlist_match($page, $depends{$p})) {
456                                                 debug("rendering $f, which depends on $page");
457                                                 render($f);
458                                                 $rendered{$f}=1;
459                                                 last;
460                                         }
461                                 }
462                         }
463                 }
464                 
465                 my %linkchanged;
466                 foreach my $file (keys %rendered, @del) {
467                         my $page=pagename($file);
468                         
469                         if (exists $links{$page}) {
470                                 foreach my $link (map { bestlink($page, $_) } @{$links{$page}}) {
471                                         if (length $link &&
472                                             (! exists $oldlinks{$page} ||
473                                              ! grep { bestlink($page, $_) eq $link } @{$oldlinks{$page}})) {
474                                                 $linkchanged{$link}=1;
475                                         }
476                                 }
477                         }
478                         if (exists $oldlinks{$page}) {
479                                 foreach my $link (map { bestlink($page, $_) } @{$oldlinks{$page}}) {
480                                         if (length $link &&
481                                             (! exists $links{$page} || 
482                                              ! grep { bestlink($page, $_) eq $link } @{$links{$page}})) {
483                                                 $linkchanged{$link}=1;
484                                         }
485                                 }
486                         }
487                 }
488                 foreach my $link (keys %linkchanged) {
489                         my $linkfile=$pagesources{$link};
490                         if (defined $linkfile) {
491                                 debug("rendering $linkfile, to update its backlinks");
492                                 render($linkfile);
493                                 $rendered{$linkfile}=1;
494                         }
495                 }
496         }
497
498         if ($config{hyperestraier} && (%rendered || @del)) {
499                 debug("updating hyperestraier search index");
500                 if (%rendered) {
501                         estcmd("gather -cm -bc -cl -sd", 
502                                 map { $config{destdir}."/".$renderedfiles{pagename($_)} }
503                                 keys %rendered);
504                 }
505                 if (@del) {
506                         estcmd("purge -cl");
507                 }
508                 
509                 debug("generating hyperestraier cgi config");
510                 estcfg();
511         }
512 } #}}}
513
514 1