Merge branch 'master' of ssh://git.ikiwiki.info/srv/git/ikiwiki.info
[ikiwiki.git] / IkiWiki.pm
blobfdf3e5c471441a8af1b5605ea12213177df4b757
1 #!/usr/bin/perl
3 package IkiWiki;
5 use warnings;
6 use strict;
7 use Encode;
8 use URI::Escape q{uri_escape_utf8};
9 use POSIX ();
10 use Storable;
11 use open qw{:utf8 :std};
13 use vars qw{%config %links %oldlinks %pagemtime %pagectime %pagecase
14 %pagestate %wikistate %renderedfiles %oldrenderedfiles
15 %pagesources %delpagesources %destsources %depends %depends_simple
16 @mass_depends %hooks %forcerebuild %loaded_plugins %typedlinks
17 %oldtypedlinks %autofiles};
19 use Exporter q{import};
20 our @EXPORT = qw(hook debug error htmlpage template template_depends
21 deptype add_depends pagespec_match pagespec_match_list bestlink
22 htmllink readfile writefile pagetype srcfile pagename
23 displaytime will_render gettext ngettext urlto targetpage
24 add_underlay pagetitle titlepage linkpage newpagefile
25 inject add_link add_autofile
26 %config %links %pagestate %wikistate %renderedfiles
27 %pagesources %destsources %typedlinks);
28 our $VERSION = 3.00; # plugin interface version, next is ikiwiki version
29 our $version='unknown'; # VERSION_AUTOREPLACE done by Makefile, DNE
30 our $installdir='/usr'; # INSTALLDIR_AUTOREPLACE done by Makefile, DNE
32 # Page dependency types.
33 our $DEPEND_CONTENT=1;
34 our $DEPEND_PRESENCE=2;
35 our $DEPEND_LINKS=4;
37 # Optimisation.
38 use Memoize;
39 memoize("abs2rel");
40 memoize("sortspec_translate");
41 memoize("pagespec_translate");
42 memoize("template_file");
44 sub getsetup () {
45 wikiname => {
46 type => "string",
47 default => "wiki",
48 description => "name of the wiki",
49 safe => 1,
50 rebuild => 1,
52 adminemail => {
53 type => "string",
54 default => undef,
55 example => 'me@example.com',
56 description => "contact email for wiki",
57 safe => 1,
58 rebuild => 0,
60 adminuser => {
61 type => "string",
62 default => [],
63 description => "users who are wiki admins",
64 safe => 1,
65 rebuild => 0,
67 banned_users => {
68 type => "string",
69 default => [],
70 description => "users who are banned from the wiki",
71 safe => 1,
72 rebuild => 0,
74 srcdir => {
75 type => "string",
76 default => undef,
77 example => "$ENV{HOME}/wiki",
78 description => "where the source of the wiki is located",
79 safe => 0, # path
80 rebuild => 1,
82 destdir => {
83 type => "string",
84 default => undef,
85 example => "/var/www/wiki",
86 description => "where to build the wiki",
87 safe => 0, # path
88 rebuild => 1,
90 url => {
91 type => "string",
92 default => '',
93 example => "http://example.com/wiki",
94 description => "base url to the wiki",
95 safe => 1,
96 rebuild => 1,
98 cgiurl => {
99 type => "string",
100 default => '',
101 example => "http://example.com/wiki/ikiwiki.cgi",
102 description => "url to the ikiwiki.cgi",
103 safe => 1,
104 rebuild => 1,
106 cgi_wrapper => {
107 type => "string",
108 default => '',
109 example => "/var/www/wiki/ikiwiki.cgi",
110 description => "filename of cgi wrapper to generate",
111 safe => 0, # file
112 rebuild => 0,
114 cgi_wrappermode => {
115 type => "string",
116 default => '06755',
117 description => "mode for cgi_wrapper (can safely be made suid)",
118 safe => 0,
119 rebuild => 0,
121 rcs => {
122 type => "string",
123 default => '',
124 description => "rcs backend to use",
125 safe => 0, # don't allow overriding
126 rebuild => 0,
128 default_plugins => {
129 type => "internal",
130 default => [qw{mdwn link inline meta htmlscrubber passwordauth
131 openid signinedit lockedit conditional
132 recentchanges parentlinks editpage}],
133 description => "plugins to enable by default",
134 safe => 0,
135 rebuild => 1,
137 add_plugins => {
138 type => "string",
139 default => [],
140 description => "plugins to add to the default configuration",
141 safe => 1,
142 rebuild => 1,
144 disable_plugins => {
145 type => "string",
146 default => [],
147 description => "plugins to disable",
148 safe => 1,
149 rebuild => 1,
151 templatedir => {
152 type => "string",
153 default => "$installdir/share/ikiwiki/templates",
154 description => "additional directory to search for template files",
155 advanced => 1,
156 safe => 0, # path
157 rebuild => 1,
159 underlaydir => {
160 type => "string",
161 default => "$installdir/share/ikiwiki/basewiki",
162 description => "base wiki source location",
163 advanced => 1,
164 safe => 0, # path
165 rebuild => 0,
167 underlaydirbase => {
168 type => "internal",
169 default => "$installdir/share/ikiwiki",
170 description => "parent directory containing additional underlays",
171 safe => 0,
172 rebuild => 0,
174 wrappers => {
175 type => "internal",
176 default => [],
177 description => "wrappers to generate",
178 safe => 0,
179 rebuild => 0,
181 underlaydirs => {
182 type => "internal",
183 default => [],
184 description => "additional underlays to use",
185 safe => 0,
186 rebuild => 0,
188 verbose => {
189 type => "boolean",
190 example => 1,
191 description => "display verbose messages?",
192 safe => 1,
193 rebuild => 0,
195 syslog => {
196 type => "boolean",
197 example => 1,
198 description => "log to syslog?",
199 safe => 1,
200 rebuild => 0,
202 usedirs => {
203 type => "boolean",
204 default => 1,
205 description => "create output files named page/index.html?",
206 safe => 0, # changing requires manual transition
207 rebuild => 1,
209 prefix_directives => {
210 type => "boolean",
211 default => 1,
212 description => "use '!'-prefixed preprocessor directives?",
213 safe => 0, # changing requires manual transition
214 rebuild => 1,
216 indexpages => {
217 type => "boolean",
218 default => 0,
219 description => "use page/index.mdwn source files",
220 safe => 1,
221 rebuild => 1,
223 discussion => {
224 type => "boolean",
225 default => 1,
226 description => "enable Discussion pages?",
227 safe => 1,
228 rebuild => 1,
230 discussionpage => {
231 type => "string",
232 default => gettext("Discussion"),
233 description => "name of Discussion pages",
234 safe => 1,
235 rebuild => 1,
237 html5 => {
238 type => "boolean",
239 default => 0,
240 description => "generate HTML5? (experimental)",
241 advanced => 1,
242 safe => 1,
243 rebuild => 1,
245 sslcookie => {
246 type => "boolean",
247 default => 0,
248 description => "only send cookies over SSL connections?",
249 advanced => 1,
250 safe => 1,
251 rebuild => 0,
253 default_pageext => {
254 type => "string",
255 default => "mdwn",
256 description => "extension to use for new pages",
257 safe => 0, # not sanitized
258 rebuild => 0,
260 htmlext => {
261 type => "string",
262 default => "html",
263 description => "extension to use for html files",
264 safe => 0, # not sanitized
265 rebuild => 1,
267 timeformat => {
268 type => "string",
269 default => '%c',
270 description => "strftime format string to display date",
271 advanced => 1,
272 safe => 1,
273 rebuild => 1,
275 locale => {
276 type => "string",
277 default => undef,
278 example => "en_US.UTF-8",
279 description => "UTF-8 locale to use",
280 advanced => 1,
281 safe => 0,
282 rebuild => 1,
284 userdir => {
285 type => "string",
286 default => "",
287 example => "users",
288 description => "put user pages below specified page",
289 safe => 1,
290 rebuild => 1,
292 numbacklinks => {
293 type => "integer",
294 default => 10,
295 description => "how many backlinks to show before hiding excess (0 to show all)",
296 safe => 1,
297 rebuild => 1,
299 hardlink => {
300 type => "boolean",
301 default => 0,
302 description => "attempt to hardlink source files? (optimisation for large files)",
303 advanced => 1,
304 safe => 0, # paranoia
305 rebuild => 0,
307 umask => {
308 type => "integer",
309 example => "022",
310 description => "force ikiwiki to use a particular umask",
311 advanced => 1,
312 safe => 0, # paranoia
313 rebuild => 0,
315 wrappergroup => {
316 type => "string",
317 example => "ikiwiki",
318 description => "group for wrappers to run in",
319 advanced => 1,
320 safe => 0, # paranoia
321 rebuild => 0,
323 libdir => {
324 type => "string",
325 default => "",
326 example => "$ENV{HOME}/.ikiwiki/",
327 description => "extra library and plugin directory",
328 advanced => 1,
329 safe => 0, # directory
330 rebuild => 0,
332 ENV => {
333 type => "string",
334 default => {},
335 description => "environment variables",
336 safe => 0, # paranoia
337 rebuild => 0,
339 timezone => {
340 type => "string",
341 default => "",
342 example => "US/Eastern",
343 description => "time zone name",
344 safe => 1,
345 rebuild => 1,
347 include => {
348 type => "string",
349 default => undef,
350 example => '^\.htaccess$',
351 description => "regexp of normally excluded files to include",
352 advanced => 1,
353 safe => 0, # regexp
354 rebuild => 1,
356 exclude => {
357 type => "string",
358 default => undef,
359 example => '^(*\.private|Makefile)$',
360 description => "regexp of files that should be skipped",
361 advanced => 1,
362 safe => 0, # regexp
363 rebuild => 1,
365 wiki_file_prune_regexps => {
366 type => "internal",
367 default => [qr/(^|\/)\.\.(\/|$)/, qr/^\//, qr/^\./, qr/\/\./,
368 qr/\.x?html?$/, qr/\.ikiwiki-new$/,
369 qr/(^|\/).svn\//, qr/.arch-ids\//, qr/{arch}\//,
370 qr/(^|\/)_MTN\//, qr/(^|\/)_darcs\//,
371 qr/(^|\/)CVS\//, qr/\.dpkg-tmp$/],
372 description => "regexps of source files to ignore",
373 safe => 0,
374 rebuild => 1,
376 wiki_file_chars => {
377 type => "string",
378 description => "specifies the characters that are allowed in source filenames",
379 default => "-[:alnum:]+/.:_",
380 safe => 0,
381 rebuild => 1,
383 wiki_file_regexp => {
384 type => "internal",
385 description => "regexp of legal source files",
386 safe => 0,
387 rebuild => 1,
389 web_commit_regexp => {
390 type => "internal",
391 default => qr/^web commit (by (.*?(?=: |$))|from ([0-9a-fA-F:.]+[0-9a-fA-F])):?(.*)/,
392 description => "regexp to parse web commits from logs",
393 safe => 0,
394 rebuild => 0,
396 cgi => {
397 type => "internal",
398 default => 0,
399 description => "run as a cgi",
400 safe => 0,
401 rebuild => 0,
403 cgi_disable_uploads => {
404 type => "internal",
405 default => 1,
406 description => "whether CGI should accept file uploads",
407 safe => 0,
408 rebuild => 0,
410 post_commit => {
411 type => "internal",
412 default => 0,
413 description => "run as a post-commit hook",
414 safe => 0,
415 rebuild => 0,
417 rebuild => {
418 type => "internal",
419 default => 0,
420 description => "running in rebuild mode",
421 safe => 0,
422 rebuild => 0,
424 setup => {
425 type => "internal",
426 default => undef,
427 description => "running in setup mode",
428 safe => 0,
429 rebuild => 0,
431 clean => {
432 type => "internal",
433 default => 0,
434 description => "running in clean mode",
435 safe => 0,
436 rebuild => 0,
438 refresh => {
439 type => "internal",
440 default => 0,
441 description => "running in refresh mode",
442 safe => 0,
443 rebuild => 0,
445 test_receive => {
446 type => "internal",
447 default => 0,
448 description => "running in receive test mode",
449 safe => 0,
450 rebuild => 0,
452 wrapper_background_command => {
453 type => "internal",
454 default => '',
455 description => "background shell command to run",
456 safe => 0,
457 rebuild => 0,
459 gettime => {
460 type => "internal",
461 description => "running in gettime mode",
462 safe => 0,
463 rebuild => 0,
465 w3mmode => {
466 type => "internal",
467 default => 0,
468 description => "running in w3mmode",
469 safe => 0,
470 rebuild => 0,
472 wikistatedir => {
473 type => "internal",
474 default => undef,
475 description => "path to the .ikiwiki directory holding ikiwiki state",
476 safe => 0,
477 rebuild => 0,
479 setupfile => {
480 type => "internal",
481 default => undef,
482 description => "path to setup file",
483 safe => 0,
484 rebuild => 0,
486 setuptype => {
487 type => "internal",
488 default => "Yaml",
489 description => "perl class to use to dump setup file",
490 safe => 0,
491 rebuild => 0,
493 allow_symlinks_before_srcdir => {
494 type => "boolean",
495 default => 0,
496 description => "allow symlinks in the path leading to the srcdir (potentially insecure)",
497 safe => 0,
498 rebuild => 0,
502 sub defaultconfig () {
503 my %s=getsetup();
504 my @ret;
505 foreach my $key (keys %s) {
506 push @ret, $key, $s{$key}->{default};
508 return @ret;
511 # URL to top of wiki as a path starting with /, valid from any wiki page or
512 # the CGI; if that's not possible, an absolute URL. Either way, it ends with /
513 my $local_url;
514 # URL to CGI script, similar to $local_url
515 my $local_cgiurl;
517 sub checkconfig () {
518 # locale stuff; avoid LC_ALL since it overrides everything
519 if (defined $ENV{LC_ALL}) {
520 $ENV{LANG} = $ENV{LC_ALL};
521 delete $ENV{LC_ALL};
523 if (defined $config{locale}) {
524 if (POSIX::setlocale(&POSIX::LC_ALL, $config{locale})) {
525 $ENV{LANG}=$config{locale};
526 define_gettext();
530 if (! defined $config{wiki_file_regexp}) {
531 $config{wiki_file_regexp}=qr/(^[$config{wiki_file_chars}]+$)/;
534 if (ref $config{ENV} eq 'HASH') {
535 foreach my $val (keys %{$config{ENV}}) {
536 $ENV{$val}=$config{ENV}{$val};
539 if (defined $config{timezone} && length $config{timezone}) {
540 $ENV{TZ}=$config{timezone};
542 else {
543 $config{timezone}=$ENV{TZ};
546 if ($config{w3mmode}) {
547 eval q{use Cwd q{abs_path}};
548 error($@) if $@;
549 $config{srcdir}=possibly_foolish_untaint(abs_path($config{srcdir}));
550 $config{destdir}=possibly_foolish_untaint(abs_path($config{destdir}));
551 $config{cgiurl}="file:///\$LIB/ikiwiki-w3m.cgi/".$config{cgiurl}
552 unless $config{cgiurl} =~ m!file:///!;
553 $config{url}="file://".$config{destdir};
556 if ($config{cgi} && ! length $config{url}) {
557 error(gettext("Must specify url to wiki with --url when using --cgi"));
560 if (defined $config{url} && length $config{url}) {
561 eval q{use URI};
562 my $baseurl = URI->new($config{url});
564 $local_url = $baseurl->path . "/";
565 $local_cgiurl = undef;
567 if (length $config{cgiurl}) {
568 my $cgiurl = URI->new($config{cgiurl});
570 $local_cgiurl = $cgiurl->path;
572 if ($cgiurl->scheme ne $baseurl->scheme or
573 $cgiurl->authority ne $baseurl->authority) {
574 # too far apart, fall back to absolute URLs
575 $local_url = "$config{url}/";
576 $local_cgiurl = $config{cgiurl};
580 $local_url =~ s{//$}{/};
582 else {
583 $local_cgiurl = $config{cgiurl};
586 $config{wikistatedir}="$config{srcdir}/.ikiwiki"
587 unless exists $config{wikistatedir} && defined $config{wikistatedir};
589 if (defined $config{umask}) {
590 umask(possibly_foolish_untaint($config{umask}));
593 run_hooks(checkconfig => sub { shift->() });
595 return 1;
598 sub listplugins () {
599 my %ret;
601 foreach my $dir (@INC, $config{libdir}) {
602 next unless defined $dir && length $dir;
603 foreach my $file (glob("$dir/IkiWiki/Plugin/*.pm")) {
604 my ($plugin)=$file=~/.*\/(.*)\.pm$/;
605 $ret{$plugin}=1;
608 foreach my $dir ($config{libdir}, "$installdir/lib/ikiwiki") {
609 next unless defined $dir && length $dir;
610 foreach my $file (glob("$dir/plugins/*")) {
611 $ret{basename($file)}=1 if -x $file;
615 return keys %ret;
618 sub loadplugins () {
619 if (defined $config{libdir} && length $config{libdir}) {
620 unshift @INC, possibly_foolish_untaint($config{libdir});
623 foreach my $plugin (@{$config{default_plugins}}, @{$config{add_plugins}}) {
624 loadplugin($plugin);
627 if ($config{rcs}) {
628 if (exists $hooks{rcs}) {
629 error(gettext("cannot use multiple rcs plugins"));
631 loadplugin($config{rcs});
633 if (! exists $hooks{rcs}) {
634 loadplugin("norcs");
637 run_hooks(getopt => sub { shift->() });
638 if (grep /^-/, @ARGV) {
639 print STDERR "Unknown option (or missing parameter): $_\n"
640 foreach grep /^-/, @ARGV;
641 usage();
644 return 1;
647 sub loadplugin ($;$) {
648 my $plugin=shift;
649 my $force=shift;
651 return if ! $force && grep { $_ eq $plugin} @{$config{disable_plugins}};
653 foreach my $dir (defined $config{libdir} ? possibly_foolish_untaint($config{libdir}) : undef,
654 "$installdir/lib/ikiwiki") {
655 if (defined $dir && -x "$dir/plugins/$plugin") {
656 eval { require IkiWiki::Plugin::external };
657 if ($@) {
658 my $reason=$@;
659 error(sprintf(gettext("failed to load external plugin needed for %s plugin: %s"), $plugin, $reason));
661 import IkiWiki::Plugin::external "$dir/plugins/$plugin";
662 $loaded_plugins{$plugin}=1;
663 return 1;
667 my $mod="IkiWiki::Plugin::".possibly_foolish_untaint($plugin);
668 eval qq{use $mod};
669 if ($@) {
670 error("Failed to load plugin $mod: $@");
672 $loaded_plugins{$plugin}=1;
673 return 1;
676 sub error ($;$) {
677 my $message=shift;
678 my $cleaner=shift;
679 log_message('err' => $message) if $config{syslog};
680 if (defined $cleaner) {
681 $cleaner->();
683 die $message."\n";
686 sub debug ($) {
687 return unless $config{verbose};
688 return log_message(debug => @_);
691 my $log_open=0;
692 sub log_message ($$) {
693 my $type=shift;
695 if ($config{syslog}) {
696 require Sys::Syslog;
697 if (! $log_open) {
698 Sys::Syslog::setlogsock('unix');
699 Sys::Syslog::openlog('ikiwiki', '', 'user');
700 $log_open=1;
702 return eval {
703 Sys::Syslog::syslog($type, "[$config{wikiname}] %s", join(" ", @_));
706 elsif (! $config{cgi}) {
707 return print "@_\n";
709 else {
710 return print STDERR "@_\n";
714 sub possibly_foolish_untaint ($) {
715 my $tainted=shift;
716 my ($untainted)=$tainted=~/(.*)/s;
717 return $untainted;
720 sub basename ($) {
721 my $file=shift;
723 $file=~s!.*/+!!;
724 return $file;
727 sub dirname ($) {
728 my $file=shift;
730 $file=~s!/*[^/]+$!!;
731 return $file;
734 sub isinternal ($) {
735 my $page=shift;
736 return exists $pagesources{$page} &&
737 $pagesources{$page} =~ /\._([^.]+)$/;
740 sub pagetype ($) {
741 my $file=shift;
743 if ($file =~ /\.([^.]+)$/) {
744 return $1 if exists $hooks{htmlize}{$1};
746 my $base=basename($file);
747 if (exists $hooks{htmlize}{$base} &&
748 $hooks{htmlize}{$base}{noextension}) {
749 return $base;
751 return;
754 my %pagename_cache;
756 sub pagename ($) {
757 my $file=shift;
759 if (exists $pagename_cache{$file}) {
760 return $pagename_cache{$file};
763 my $type=pagetype($file);
764 my $page=$file;
765 $page=~s/\Q.$type\E*$//
766 if defined $type && !$hooks{htmlize}{$type}{keepextension}
767 && !$hooks{htmlize}{$type}{noextension};
768 if ($config{indexpages} && $page=~/(.*)\/index$/) {
769 $page=$1;
772 $pagename_cache{$file} = $page;
773 return $page;
776 sub newpagefile ($$) {
777 my $page=shift;
778 my $type=shift;
780 if (! $config{indexpages} || $page eq 'index') {
781 return $page.".".$type;
783 else {
784 return $page."/index.".$type;
788 sub targetpage ($$;$) {
789 my $page=shift;
790 my $ext=shift;
791 my $filename=shift;
793 if (defined $filename) {
794 return $page."/".$filename.".".$ext;
796 elsif (! $config{usedirs} || $page eq 'index') {
797 return $page.".".$ext;
799 else {
800 return $page."/index.".$ext;
804 sub htmlpage ($) {
805 my $page=shift;
807 return targetpage($page, $config{htmlext});
810 sub srcfile_stat {
811 my $file=shift;
812 my $nothrow=shift;
814 return "$config{srcdir}/$file", stat(_) if -e "$config{srcdir}/$file";
815 foreach my $dir (@{$config{underlaydirs}}, $config{underlaydir}) {
816 return "$dir/$file", stat(_) if -e "$dir/$file";
818 error("internal error: $file cannot be found in $config{srcdir} or underlay") unless $nothrow;
819 return;
822 sub srcfile ($;$) {
823 return (srcfile_stat(@_))[0];
826 sub add_literal_underlay ($) {
827 my $dir=shift;
829 if (! grep { $_ eq $dir } @{$config{underlaydirs}}) {
830 unshift @{$config{underlaydirs}}, $dir;
834 sub add_underlay ($) {
835 my $dir = shift;
837 if ($dir !~ /^\//) {
838 $dir="$config{underlaydirbase}/$dir";
841 add_literal_underlay($dir);
842 # why does it return 1? we just don't know
843 return 1;
846 sub readfile ($;$$) {
847 my $file=shift;
848 my $binary=shift;
849 my $wantfd=shift;
851 if (-l $file) {
852 error("cannot read a symlink ($file)");
855 local $/=undef;
856 open (my $in, "<", $file) || error("failed to read $file: $!");
857 binmode($in) if ($binary);
858 return \*$in if $wantfd;
859 my $ret=<$in>;
860 # check for invalid utf-8, and toss it back to avoid crashes
861 if (! utf8::valid($ret)) {
862 $ret=encode_utf8($ret);
864 close $in || error("failed to read $file: $!");
865 return $ret;
868 sub prep_writefile ($$) {
869 my $file=shift;
870 my $destdir=shift;
872 my $test=$file;
873 while (length $test) {
874 if (-l "$destdir/$test") {
875 error("cannot write to a symlink ($test)");
877 if (-f _ && $test ne $file) {
878 # Remove conflicting file.
879 foreach my $p (keys %renderedfiles, keys %oldrenderedfiles) {
880 foreach my $f (@{$renderedfiles{$p}}, @{$oldrenderedfiles{$p}}) {
881 if ($f eq $test) {
882 unlink("$destdir/$test");
883 last;
888 $test=dirname($test);
891 my $dir=dirname("$destdir/$file");
892 if (! -d $dir) {
893 my $d="";
894 foreach my $s (split(m!/+!, $dir)) {
895 $d.="$s/";
896 if (! -d $d) {
897 mkdir($d) || error("failed to create directory $d: $!");
902 return 1;
905 sub writefile ($$$;$$) {
906 my $file=shift; # can include subdirs
907 my $destdir=shift; # directory to put file in
908 my $content=shift;
909 my $binary=shift;
910 my $writer=shift;
912 prep_writefile($file, $destdir);
914 my $newfile="$destdir/$file.ikiwiki-new";
915 if (-l $newfile) {
916 error("cannot write to a symlink ($newfile)");
919 my $cleanup = sub { unlink($newfile) };
920 open (my $out, '>', $newfile) || error("failed to write $newfile: $!", $cleanup);
921 binmode($out) if ($binary);
922 if ($writer) {
923 $writer->(\*$out, $cleanup);
925 else {
926 print $out $content or error("failed writing to $newfile: $!", $cleanup);
928 close $out || error("failed saving $newfile: $!", $cleanup);
929 rename($newfile, "$destdir/$file") ||
930 error("failed renaming $newfile to $destdir/$file: $!", $cleanup);
932 return 1;
935 my %cleared;
936 sub will_render ($$;$) {
937 my $page=shift;
938 my $dest=shift;
939 my $clear=shift;
941 # Important security check for independently created files.
942 if (-e "$config{destdir}/$dest" && ! $config{rebuild} &&
943 ! grep { $_ eq $dest } (@{$renderedfiles{$page}}, @{$oldrenderedfiles{$page}}, @{$wikistate{editpage}{previews}})) {
944 my $from_other_page=0;
945 # Expensive, but rarely runs.
946 foreach my $p (keys %renderedfiles, keys %oldrenderedfiles) {
947 if (grep {
948 $_ eq $dest ||
949 dirname($_) eq $dest
950 } @{$renderedfiles{$p}}, @{$oldrenderedfiles{$p}}) {
951 $from_other_page=1;
952 last;
956 error("$config{destdir}/$dest independently created, not overwriting with version from $page")
957 unless $from_other_page;
960 # If $dest exists as a directory, remove conflicting files in it
961 # rendered from other pages.
962 if (-d _) {
963 foreach my $p (keys %renderedfiles, keys %oldrenderedfiles) {
964 foreach my $f (@{$renderedfiles{$p}}, @{$oldrenderedfiles{$p}}) {
965 if (dirname($f) eq $dest) {
966 unlink("$config{destdir}/$f");
967 rmdir(dirname("$config{destdir}/$f"));
973 if (! $clear || $cleared{$page}) {
974 $renderedfiles{$page}=[$dest, grep { $_ ne $dest } @{$renderedfiles{$page}}];
976 else {
977 foreach my $old (@{$renderedfiles{$page}}) {
978 delete $destsources{$old};
980 $renderedfiles{$page}=[$dest];
981 $cleared{$page}=1;
983 $destsources{$dest}=$page;
985 return 1;
988 sub bestlink ($$) {
989 my $page=shift;
990 my $link=shift;
992 my $cwd=$page;
993 if ($link=~s/^\/+//) {
994 # absolute links
995 $cwd="";
997 $link=~s/\/$//;
999 do {
1000 my $l=$cwd;
1001 $l.="/" if length $l;
1002 $l.=$link;
1004 if (exists $pagesources{$l}) {
1005 return $l;
1007 elsif (exists $pagecase{lc $l}) {
1008 return $pagecase{lc $l};
1010 } while $cwd=~s{/?[^/]+$}{};
1012 if (length $config{userdir}) {
1013 my $l = "$config{userdir}/".lc($link);
1014 if (exists $pagesources{$l}) {
1015 return $l;
1017 elsif (exists $pagecase{lc $l}) {
1018 return $pagecase{lc $l};
1022 #print STDERR "warning: page $page, broken link: $link\n";
1023 return "";
1026 sub isinlinableimage ($) {
1027 my $file=shift;
1029 return $file =~ /\.(png|gif|jpg|jpeg)$/i;
1032 sub pagetitle ($;$) {
1033 my $page=shift;
1034 my $unescaped=shift;
1036 if ($unescaped) {
1037 $page=~s/(__(\d+)__|_)/$1 eq '_' ? ' ' : chr($2)/eg;
1039 else {
1040 $page=~s/(__(\d+)__|_)/$1 eq '_' ? ' ' : "&#$2;"/eg;
1043 return $page;
1046 sub titlepage ($) {
1047 my $title=shift;
1048 # support use w/o %config set
1049 my $chars = defined $config{wiki_file_chars} ? $config{wiki_file_chars} : "-[:alnum:]+/.:_";
1050 $title=~s/([^$chars]|_)/$1 eq ' ' ? '_' : "__".ord($1)."__"/eg;
1051 return $title;
1054 sub linkpage ($) {
1055 my $link=shift;
1056 my $chars = defined $config{wiki_file_chars} ? $config{wiki_file_chars} : "-[:alnum:]+/.:_";
1057 $link=~s/([^$chars])/$1 eq ' ' ? '_' : "__".ord($1)."__"/eg;
1058 return $link;
1061 sub cgiurl (@) {
1062 my %params=@_;
1064 my $cgiurl=$local_cgiurl;
1066 if (exists $params{cgiurl}) {
1067 $cgiurl=$params{cgiurl};
1068 delete $params{cgiurl};
1071 unless (%params) {
1072 return $cgiurl;
1075 return $cgiurl."?".
1076 join("&amp;", map $_."=".uri_escape_utf8($params{$_}), keys %params);
1079 sub baseurl (;$) {
1080 my $page=shift;
1082 return $local_url if ! defined $page;
1084 $page=htmlpage($page);
1085 $page=~s/[^\/]+$//;
1086 $page=~s/[^\/]+\//..\//g;
1087 return $page;
1090 sub urlabs ($$) {
1091 my $url=shift;
1092 my $urlbase=shift;
1094 return $url unless defined $urlbase && length $urlbase;
1096 eval q{use URI};
1097 URI->new_abs($url, $urlbase)->as_string;
1100 sub abs2rel ($$) {
1101 # Work around very innefficient behavior in File::Spec if abs2rel
1102 # is passed two relative paths. It's much faster if paths are
1103 # absolute! (Debian bug #376658; fixed in debian unstable now)
1104 my $path="/".shift;
1105 my $base="/".shift;
1107 require File::Spec;
1108 my $ret=File::Spec->abs2rel($path, $base);
1109 $ret=~s/^// if defined $ret;
1110 return $ret;
1113 sub displaytime ($;$$) {
1114 # Plugins can override this function to mark up the time to
1115 # display.
1116 my $time=formattime($_[0], $_[1]);
1117 if ($config{html5}) {
1118 return '<time datetime="'.date_3339($_[0]).'"'.
1119 ($_[2] ? ' pubdate="pubdate"' : '').
1120 '>'.$time.'</time>';
1122 else {
1123 return '<span class="date">'.$time.'</span>';
1127 sub formattime ($;$) {
1128 # Plugins can override this function to format the time.
1129 my $time=shift;
1130 my $format=shift;
1131 if (! defined $format) {
1132 $format=$config{timeformat};
1135 # strftime doesn't know about encodings, so make sure
1136 # its output is properly treated as utf8
1137 return decode_utf8(POSIX::strftime($format, localtime($time)));
1140 sub date_3339 ($) {
1141 my $time=shift;
1143 my $lc_time=POSIX::setlocale(&POSIX::LC_TIME);
1144 POSIX::setlocale(&POSIX::LC_TIME, "C");
1145 my $ret=POSIX::strftime("%Y-%m-%dT%H:%M:%SZ", gmtime($time));
1146 POSIX::setlocale(&POSIX::LC_TIME, $lc_time);
1147 return $ret;
1150 sub beautify_urlpath ($) {
1151 my $url=shift;
1153 # Ensure url is not an empty link, and if necessary,
1154 # add ./ to avoid colon confusion.
1155 if ($url !~ /^\// && $url !~ /^\.\.?\//) {
1156 $url="./$url";
1159 if ($config{usedirs}) {
1160 $url =~ s!/index.$config{htmlext}$!/!;
1163 return $url;
1166 sub urlto ($;$$) {
1167 my $to=shift;
1168 my $from=shift;
1169 my $absolute=shift;
1171 if (! length $to) {
1172 $to = 'index';
1175 if (! $destsources{$to}) {
1176 $to=htmlpage($to);
1179 if ($absolute) {
1180 return $config{url}.beautify_urlpath("/".$to);
1183 if (! defined $from) {
1184 my $u = $local_url || '';
1185 $u =~ s{/$}{};
1186 return $u.beautify_urlpath("/".$to);
1189 my $link = abs2rel($to, dirname(htmlpage($from)));
1191 return beautify_urlpath($link);
1194 sub isselflink ($$) {
1195 # Plugins can override this function to support special types
1196 # of selflinks.
1197 my $page=shift;
1198 my $link=shift;
1200 return $page eq $link;
1203 sub htmllink ($$$;@) {
1204 my $lpage=shift; # the page doing the linking
1205 my $page=shift; # the page that will contain the link (different for inline)
1206 my $link=shift;
1207 my %opts=@_;
1209 $link=~s/\/$//;
1211 my $bestlink;
1212 if (! $opts{forcesubpage}) {
1213 $bestlink=bestlink($lpage, $link);
1215 else {
1216 $bestlink="$lpage/".lc($link);
1219 my $linktext;
1220 if (defined $opts{linktext}) {
1221 $linktext=$opts{linktext};
1223 else {
1224 $linktext=pagetitle(basename($link));
1227 return "<span class=\"selflink\">$linktext</span>"
1228 if length $bestlink && isselflink($page, $bestlink) &&
1229 ! defined $opts{anchor};
1231 if (! $destsources{$bestlink}) {
1232 $bestlink=htmlpage($bestlink);
1234 if (! $destsources{$bestlink}) {
1235 my $cgilink = "";
1236 if (length $config{cgiurl}) {
1237 $cgilink = "<a href=\"".
1238 cgiurl(
1239 do => "create",
1240 page => lc($link),
1241 from => $lpage
1242 )."\" rel=\"nofollow\">?</a>";
1244 return "<span class=\"createlink\">$cgilink$linktext</span>"
1248 $bestlink=abs2rel($bestlink, dirname(htmlpage($page)));
1249 $bestlink=beautify_urlpath($bestlink);
1251 if (! $opts{noimageinline} && isinlinableimage($bestlink)) {
1252 return "<img src=\"$bestlink\" alt=\"$linktext\" />";
1255 if (defined $opts{anchor}) {
1256 $bestlink.="#".$opts{anchor};
1259 my @attrs;
1260 foreach my $attr (qw{rel class title}) {
1261 if (defined $opts{$attr}) {
1262 push @attrs, " $attr=\"$opts{$attr}\"";
1266 return "<a href=\"$bestlink\"@attrs>$linktext</a>";
1269 sub userpage ($) {
1270 my $user=shift;
1271 return length $config{userdir} ? "$config{userdir}/$user" : $user;
1274 sub openiduser ($) {
1275 my $user=shift;
1277 if (defined $user && $user =~ m!^https?://! &&
1278 eval q{use Net::OpenID::VerifiedIdentity; 1} && !$@) {
1279 my $display;
1281 if (Net::OpenID::VerifiedIdentity->can("DisplayOfURL")) {
1282 $display = Net::OpenID::VerifiedIdentity::DisplayOfURL($user);
1284 else {
1285 # backcompat with old version
1286 my $oid=Net::OpenID::VerifiedIdentity->new(identity => $user);
1287 $display=$oid->display;
1290 # Convert "user.somehost.com" to "user [somehost.com]"
1291 # (also "user.somehost.co.uk")
1292 if ($display !~ /\[/) {
1293 $display=~s/^([-a-zA-Z0-9]+?)\.([-.a-zA-Z0-9]+\.[a-z]+)$/$1 [$2]/;
1295 # Convert "http://somehost.com/user" to "user [somehost.com]".
1296 # (also "https://somehost.com/user/")
1297 if ($display !~ /\[/) {
1298 $display=~s/^https?:\/\/(.+)\/([^\/#?]+)\/?(?:[#?].*)?$/$2 [$1]/;
1300 $display=~s!^https?://!!; # make sure this is removed
1301 eval q{use CGI 'escapeHTML'};
1302 error($@) if $@;
1303 return escapeHTML($display);
1305 return;
1308 sub htmlize ($$$$) {
1309 my $page=shift;
1310 my $destpage=shift;
1311 my $type=shift;
1312 my $content=shift;
1314 my $oneline = $content !~ /\n/;
1316 if (exists $hooks{htmlize}{$type}) {
1317 $content=$hooks{htmlize}{$type}{call}->(
1318 page => $page,
1319 content => $content,
1322 else {
1323 error("htmlization of $type not supported");
1326 run_hooks(sanitize => sub {
1327 $content=shift->(
1328 page => $page,
1329 destpage => $destpage,
1330 content => $content,
1334 if ($oneline) {
1335 # hack to get rid of enclosing junk added by markdown
1336 # and other htmlizers/sanitizers
1337 $content=~s/^<p>//i;
1338 $content=~s/<\/p>\n*$//i;
1341 return $content;
1344 sub linkify ($$$) {
1345 my $page=shift;
1346 my $destpage=shift;
1347 my $content=shift;
1349 run_hooks(linkify => sub {
1350 $content=shift->(
1351 page => $page,
1352 destpage => $destpage,
1353 content => $content,
1357 return $content;
1360 our %preprocessing;
1361 our $preprocess_preview=0;
1362 sub preprocess ($$$;$$) {
1363 my $page=shift; # the page the data comes from
1364 my $destpage=shift; # the page the data will appear in (different for inline)
1365 my $content=shift;
1366 my $scan=shift;
1367 my $preview=shift;
1369 # Using local because it needs to be set within any nested calls
1370 # of this function.
1371 local $preprocess_preview=$preview if defined $preview;
1373 my $handle=sub {
1374 my $escape=shift;
1375 my $prefix=shift;
1376 my $command=shift;
1377 my $params=shift;
1378 $params="" if ! defined $params;
1380 if (length $escape) {
1381 return "[[$prefix$command $params]]";
1383 elsif (exists $hooks{preprocess}{$command}) {
1384 return "" if $scan && ! $hooks{preprocess}{$command}{scan};
1385 # Note: preserve order of params, some plugins may
1386 # consider it significant.
1387 my @params;
1388 while ($params =~ m{
1389 (?:([-\w]+)=)? # 1: named parameter key?
1391 """(.*?)""" # 2: triple-quoted value
1393 "([^"]*?)" # 3: single-quoted value
1395 (\S+) # 4: unquoted value
1397 (?:\s+|$) # delimiter to next param
1398 }sgx) {
1399 my $key=$1;
1400 my $val;
1401 if (defined $2) {
1402 $val=$2;
1403 $val=~s/\r\n/\n/mg;
1404 $val=~s/^\n+//g;
1405 $val=~s/\n+$//g;
1407 elsif (defined $3) {
1408 $val=$3;
1410 elsif (defined $4) {
1411 $val=$4;
1414 if (defined $key) {
1415 push @params, $key, $val;
1417 else {
1418 push @params, $val, '';
1421 if ($preprocessing{$page}++ > 3) {
1422 # Avoid loops of preprocessed pages preprocessing
1423 # other pages that preprocess them, etc.
1424 return "[[!$command <span class=\"error\">".
1425 sprintf(gettext("preprocessing loop detected on %s at depth %i"),
1426 $page, $preprocessing{$page}).
1427 "</span>]]";
1429 my $ret;
1430 if (! $scan) {
1431 $ret=eval {
1432 $hooks{preprocess}{$command}{call}->(
1433 @params,
1434 page => $page,
1435 destpage => $destpage,
1436 preview => $preprocess_preview,
1439 if ($@) {
1440 my $error=$@;
1441 chomp $error;
1442 $ret="[[!$command <span class=\"error\">".
1443 gettext("Error").": $error"."</span>]]";
1446 else {
1447 # use void context during scan pass
1448 eval {
1449 $hooks{preprocess}{$command}{call}->(
1450 @params,
1451 page => $page,
1452 destpage => $destpage,
1453 preview => $preprocess_preview,
1456 $ret="";
1458 $preprocessing{$page}--;
1459 return $ret;
1461 else {
1462 return "[[$prefix$command $params]]";
1466 my $regex;
1467 if ($config{prefix_directives}) {
1468 $regex = qr{
1469 (\\?) # 1: escape?
1470 \[\[(!) # directive open; 2: prefix
1471 ([-\w]+) # 3: command
1472 ( # 4: the parameters..
1473 \s+ # Must have space if parameters present
1475 (?:[-\w]+=)? # named parameter key?
1477 """.*?""" # triple-quoted value
1479 "[^"]*?" # single-quoted value
1481 [^"\s\]]+ # unquoted value
1483 \s* # whitespace or end
1484 # of directive
1486 *)? # 0 or more parameters
1487 \]\] # directive closed
1488 }sx;
1490 else {
1491 $regex = qr{
1492 (\\?) # 1: escape?
1493 \[\[(!?) # directive open; 2: optional prefix
1494 ([-\w]+) # 3: command
1496 ( # 4: the parameters..
1498 (?:[-\w]+=)? # named parameter key?
1500 """.*?""" # triple-quoted value
1502 "[^"]*?" # single-quoted value
1504 [^"\s\]]+ # unquoted value
1506 \s* # whitespace or end
1507 # of directive
1509 *) # 0 or more parameters
1510 \]\] # directive closed
1511 }sx;
1514 $content =~ s{$regex}{$handle->($1, $2, $3, $4)}eg;
1515 return $content;
1518 sub filter ($$$) {
1519 my $page=shift;
1520 my $destpage=shift;
1521 my $content=shift;
1523 run_hooks(filter => sub {
1524 $content=shift->(page => $page, destpage => $destpage,
1525 content => $content);
1528 return $content;
1531 sub check_canedit ($$$;$) {
1532 my $page=shift;
1533 my $q=shift;
1534 my $session=shift;
1535 my $nonfatal=shift;
1537 my $canedit;
1538 run_hooks(canedit => sub {
1539 return if defined $canedit;
1540 my $ret=shift->($page, $q, $session);
1541 if (defined $ret) {
1542 if ($ret eq "") {
1543 $canedit=1;
1545 elsif (ref $ret eq 'CODE') {
1546 $ret->() unless $nonfatal;
1547 $canedit=0;
1549 elsif (defined $ret) {
1550 error($ret) unless $nonfatal;
1551 $canedit=0;
1555 return defined $canedit ? $canedit : 1;
1558 sub check_content (@) {
1559 my %params=@_;
1561 return 1 if ! exists $hooks{checkcontent}; # optimisation
1563 if (exists $pagesources{$params{page}}) {
1564 my @diff;
1565 my %old=map { $_ => 1 }
1566 split("\n", readfile(srcfile($pagesources{$params{page}})));
1567 foreach my $line (split("\n", $params{content})) {
1568 push @diff, $line if ! exists $old{$line};
1570 $params{diff}=join("\n", @diff);
1573 my $ok;
1574 run_hooks(checkcontent => sub {
1575 return if defined $ok;
1576 my $ret=shift->(%params);
1577 if (defined $ret) {
1578 if ($ret eq "") {
1579 $ok=1;
1581 elsif (ref $ret eq 'CODE') {
1582 $ret->() unless $params{nonfatal};
1583 $ok=0;
1585 elsif (defined $ret) {
1586 error($ret) unless $params{nonfatal};
1587 $ok=0;
1592 return defined $ok ? $ok : 1;
1595 sub check_canchange (@) {
1596 my %params = @_;
1597 my $cgi = $params{cgi};
1598 my $session = $params{session};
1599 my @changes = @{$params{changes}};
1601 my %newfiles;
1602 foreach my $change (@changes) {
1603 # This untaint is safe because we check file_pruned and
1604 # wiki_file_regexp.
1605 my ($file)=$change->{file}=~/$config{wiki_file_regexp}/;
1606 $file=possibly_foolish_untaint($file);
1607 if (! defined $file || ! length $file ||
1608 file_pruned($file)) {
1609 error(gettext("bad file name %s"), $file);
1612 my $type=pagetype($file);
1613 my $page=pagename($file) if defined $type;
1615 if ($change->{action} eq 'add') {
1616 $newfiles{$file}=1;
1619 if ($change->{action} eq 'change' ||
1620 $change->{action} eq 'add') {
1621 if (defined $page) {
1622 check_canedit($page, $cgi, $session);
1623 next;
1625 else {
1626 if (IkiWiki::Plugin::attachment->can("check_canattach")) {
1627 IkiWiki::Plugin::attachment::check_canattach($session, $file, $change->{path});
1628 check_canedit($file, $cgi, $session);
1629 next;
1633 elsif ($change->{action} eq 'remove') {
1634 # check_canremove tests to see if the file is present
1635 # on disk. This will fail when a single commit adds a
1636 # file and then removes it again. Avoid the problem
1637 # by not testing the removal in such pairs of changes.
1638 # (The add is still tested, just to make sure that
1639 # no data is added to the repo that a web edit
1640 # could not add.)
1641 next if $newfiles{$file};
1643 if (IkiWiki::Plugin::remove->can("check_canremove")) {
1644 IkiWiki::Plugin::remove::check_canremove(defined $page ? $page : $file, $cgi, $session);
1645 check_canedit(defined $page ? $page : $file, $cgi, $session);
1646 next;
1649 else {
1650 error "unknown action ".$change->{action};
1653 error sprintf(gettext("you are not allowed to change %s"), $file);
1658 my $wikilock;
1660 sub lockwiki () {
1661 # Take an exclusive lock on the wiki to prevent multiple concurrent
1662 # run issues. The lock will be dropped on program exit.
1663 if (! -d $config{wikistatedir}) {
1664 mkdir($config{wikistatedir});
1666 open($wikilock, '>', "$config{wikistatedir}/lockfile") ||
1667 error ("cannot write to $config{wikistatedir}/lockfile: $!");
1668 if (! flock($wikilock, 2)) { # LOCK_EX
1669 error("failed to get lock");
1671 return 1;
1674 sub unlockwiki () {
1675 POSIX::close($ENV{IKIWIKI_CGILOCK_FD}) if exists $ENV{IKIWIKI_CGILOCK_FD};
1676 return close($wikilock) if $wikilock;
1677 return;
1680 my $commitlock;
1682 sub commit_hook_enabled () {
1683 open($commitlock, '+>', "$config{wikistatedir}/commitlock") ||
1684 error("cannot write to $config{wikistatedir}/commitlock: $!");
1685 if (! flock($commitlock, 1 | 4)) { # LOCK_SH | LOCK_NB to test
1686 close($commitlock) || error("failed closing commitlock: $!");
1687 return 0;
1689 close($commitlock) || error("failed closing commitlock: $!");
1690 return 1;
1693 sub disable_commit_hook () {
1694 open($commitlock, '>', "$config{wikistatedir}/commitlock") ||
1695 error("cannot write to $config{wikistatedir}/commitlock: $!");
1696 if (! flock($commitlock, 2)) { # LOCK_EX
1697 error("failed to get commit lock");
1699 return 1;
1702 sub enable_commit_hook () {
1703 return close($commitlock) if $commitlock;
1704 return;
1707 sub loadindex () {
1708 %oldrenderedfiles=%pagectime=();
1709 if (! $config{rebuild}) {
1710 %pagesources=%pagemtime=%oldlinks=%links=%depends=
1711 %destsources=%renderedfiles=%pagecase=%pagestate=
1712 %depends_simple=%typedlinks=%oldtypedlinks=();
1714 my $in;
1715 if (! open ($in, "<", "$config{wikistatedir}/indexdb")) {
1716 if (-e "$config{wikistatedir}/index") {
1717 system("ikiwiki-transition", "indexdb", $config{srcdir});
1718 open ($in, "<", "$config{wikistatedir}/indexdb") || return;
1720 else {
1721 $config{gettime}=1; # first build
1722 return;
1726 my $index=Storable::fd_retrieve($in);
1727 if (! defined $index) {
1728 return 0;
1731 my $pages;
1732 if (exists $index->{version} && ! ref $index->{version}) {
1733 $pages=$index->{page};
1734 %wikistate=%{$index->{state}};
1735 # Handle plugins that got disabled by loading a new setup.
1736 if (exists $config{setupfile}) {
1737 require IkiWiki::Setup;
1738 IkiWiki::Setup::disabled_plugins(
1739 grep { ! $loaded_plugins{$_} } keys %wikistate);
1742 else {
1743 $pages=$index;
1744 %wikistate=();
1747 foreach my $src (keys %$pages) {
1748 my $d=$pages->{$src};
1749 my $page=pagename($src);
1750 $pagectime{$page}=$d->{ctime};
1751 $pagesources{$page}=$src;
1752 if (! $config{rebuild}) {
1753 $pagemtime{$page}=$d->{mtime};
1754 $renderedfiles{$page}=$d->{dest};
1755 if (exists $d->{links} && ref $d->{links}) {
1756 $links{$page}=$d->{links};
1757 $oldlinks{$page}=[@{$d->{links}}];
1759 if (ref $d->{depends_simple} eq 'ARRAY') {
1760 # old format
1761 $depends_simple{$page}={
1762 map { $_ => 1 } @{$d->{depends_simple}}
1765 elsif (exists $d->{depends_simple}) {
1766 $depends_simple{$page}=$d->{depends_simple};
1768 if (exists $d->{dependslist}) {
1769 # old format
1770 $depends{$page}={
1771 map { $_ => $DEPEND_CONTENT }
1772 @{$d->{dependslist}}
1775 elsif (exists $d->{depends} && ! ref $d->{depends}) {
1776 # old format
1777 $depends{$page}={$d->{depends} => $DEPEND_CONTENT };
1779 elsif (exists $d->{depends}) {
1780 $depends{$page}=$d->{depends};
1782 if (exists $d->{state}) {
1783 $pagestate{$page}=$d->{state};
1785 if (exists $d->{typedlinks}) {
1786 $typedlinks{$page}=$d->{typedlinks};
1788 while (my ($type, $links) = each %{$typedlinks{$page}}) {
1789 next unless %$links;
1790 $oldtypedlinks{$page}{$type} = {%$links};
1794 $oldrenderedfiles{$page}=[@{$d->{dest}}];
1796 foreach my $page (keys %pagesources) {
1797 $pagecase{lc $page}=$page;
1799 foreach my $page (keys %renderedfiles) {
1800 $destsources{$_}=$page foreach @{$renderedfiles{$page}};
1802 return close($in);
1805 sub saveindex () {
1806 run_hooks(savestate => sub { shift->() });
1808 my @plugins=keys %loaded_plugins;
1810 if (! -d $config{wikistatedir}) {
1811 mkdir($config{wikistatedir});
1813 my $newfile="$config{wikistatedir}/indexdb.new";
1814 my $cleanup = sub { unlink($newfile) };
1815 open (my $out, '>', $newfile) || error("cannot write to $newfile: $!", $cleanup);
1817 my %index;
1818 foreach my $page (keys %pagemtime) {
1819 next unless $pagemtime{$page};
1820 my $src=$pagesources{$page};
1822 $index{page}{$src}={
1823 ctime => $pagectime{$page},
1824 mtime => $pagemtime{$page},
1825 dest => $renderedfiles{$page},
1826 links => $links{$page},
1829 if (exists $depends{$page}) {
1830 $index{page}{$src}{depends} = $depends{$page};
1833 if (exists $depends_simple{$page}) {
1834 $index{page}{$src}{depends_simple} = $depends_simple{$page};
1837 if (exists $typedlinks{$page} && %{$typedlinks{$page}}) {
1838 $index{page}{$src}{typedlinks} = $typedlinks{$page};
1841 if (exists $pagestate{$page}) {
1842 foreach my $id (@plugins) {
1843 foreach my $key (keys %{$pagestate{$page}{$id}}) {
1844 $index{page}{$src}{state}{$id}{$key}=$pagestate{$page}{$id}{$key};
1850 $index{state}={};
1851 foreach my $id (@plugins) {
1852 $index{state}{$id}={}; # used to detect disabled plugins
1853 foreach my $key (keys %{$wikistate{$id}}) {
1854 $index{state}{$id}{$key}=$wikistate{$id}{$key};
1858 $index{version}="3";
1859 my $ret=Storable::nstore_fd(\%index, $out);
1860 return if ! defined $ret || ! $ret;
1861 close $out || error("failed saving to $newfile: $!", $cleanup);
1862 rename($newfile, "$config{wikistatedir}/indexdb") ||
1863 error("failed renaming $newfile to $config{wikistatedir}/indexdb", $cleanup);
1865 return 1;
1868 sub template_file ($) {
1869 my $name=shift;
1871 my $tpage=($name =~ s/^\///) ? $name : "templates/$name";
1872 my $template;
1873 if ($name !~ /\.tmpl$/ && exists $pagesources{$tpage}) {
1874 $template=srcfile($pagesources{$tpage}, 1);
1875 $name.=".tmpl";
1877 else {
1878 $template=srcfile($tpage, 1);
1881 if (defined $template) {
1882 return $template, $tpage, 1 if wantarray;
1883 return $template;
1885 else {
1886 $name=~s:/::; # avoid path traversal
1887 foreach my $dir ($config{templatedir},
1888 "$installdir/share/ikiwiki/templates") {
1889 if (-e "$dir/$name") {
1890 $template="$dir/$name";
1891 last;
1894 if (defined $template) {
1895 return $template, $tpage if wantarray;
1896 return $template;
1900 return;
1903 sub template_depends ($$;@) {
1904 my $name=shift;
1905 my $page=shift;
1907 my ($filename, $tpage, $untrusted)=template_file($name);
1908 if (! defined $filename) {
1909 error(sprintf(gettext("template %s not found"), $name))
1912 if (defined $page && defined $tpage) {
1913 add_depends($page, $tpage);
1916 my @opts=(
1917 filter => sub {
1918 my $text_ref = shift;
1919 ${$text_ref} = decode_utf8(${$text_ref});
1921 loop_context_vars => 1,
1922 die_on_bad_params => 0,
1923 parent_global_vars => 1,
1924 filename => $filename,
1926 ($untrusted ? (no_includes => 1) : ()),
1928 return @opts if wantarray;
1930 require HTML::Template;
1931 return HTML::Template->new(@opts);
1934 sub template ($;@) {
1935 template_depends(shift, undef, @_);
1938 sub templateactions ($$) {
1939 my $template=shift;
1940 my $page=shift;
1942 my $have_actions=0;
1943 my @actions;
1944 run_hooks(pageactions => sub {
1945 push @actions, map { { action => $_ } }
1946 grep { defined } shift->(page => $page);
1948 $template->param(actions => \@actions);
1950 if ($config{cgiurl} && exists $hooks{auth}) {
1951 $template->param(prefsurl => cgiurl(do => "prefs"));
1952 $have_actions=1;
1955 if ($have_actions || @actions) {
1956 $template->param(have_actions => 1);
1960 sub hook (@) {
1961 my %param=@_;
1963 if (! exists $param{type} || ! ref $param{call} || ! exists $param{id}) {
1964 error 'hook requires type, call, and id parameters';
1967 return if $param{no_override} && exists $hooks{$param{type}}{$param{id}};
1969 $hooks{$param{type}}{$param{id}}=\%param;
1970 return 1;
1973 sub run_hooks ($$) {
1974 # Calls the given sub for each hook of the given type,
1975 # passing it the hook function to call.
1976 my $type=shift;
1977 my $sub=shift;
1979 if (exists $hooks{$type}) {
1980 my (@first, @middle, @last);
1981 foreach my $id (keys %{$hooks{$type}}) {
1982 if ($hooks{$type}{$id}{first}) {
1983 push @first, $id;
1985 elsif ($hooks{$type}{$id}{last}) {
1986 push @last, $id;
1988 else {
1989 push @middle, $id;
1992 foreach my $id (@first, @middle, @last) {
1993 $sub->($hooks{$type}{$id}{call});
1997 return 1;
2000 sub rcs_update () {
2001 $hooks{rcs}{rcs_update}{call}->(@_);
2004 sub rcs_prepedit ($) {
2005 $hooks{rcs}{rcs_prepedit}{call}->(@_);
2008 sub rcs_commit (@) {
2009 $hooks{rcs}{rcs_commit}{call}->(@_);
2012 sub rcs_commit_staged (@) {
2013 $hooks{rcs}{rcs_commit_staged}{call}->(@_);
2016 sub rcs_add ($) {
2017 $hooks{rcs}{rcs_add}{call}->(@_);
2020 sub rcs_remove ($) {
2021 $hooks{rcs}{rcs_remove}{call}->(@_);
2024 sub rcs_rename ($$) {
2025 $hooks{rcs}{rcs_rename}{call}->(@_);
2028 sub rcs_recentchanges ($) {
2029 $hooks{rcs}{rcs_recentchanges}{call}->(@_);
2032 sub rcs_diff ($;$) {
2033 $hooks{rcs}{rcs_diff}{call}->(@_);
2036 sub rcs_getctime ($) {
2037 $hooks{rcs}{rcs_getctime}{call}->(@_);
2040 sub rcs_getmtime ($) {
2041 $hooks{rcs}{rcs_getmtime}{call}->(@_);
2044 sub rcs_receive () {
2045 $hooks{rcs}{rcs_receive}{call}->();
2048 sub add_depends ($$;$) {
2049 my $page=shift;
2050 my $pagespec=shift;
2051 my $deptype=shift || $DEPEND_CONTENT;
2053 # Is the pagespec a simple page name?
2054 if ($pagespec =~ /$config{wiki_file_regexp}/ &&
2055 $pagespec !~ /[\s*?()!]/) {
2056 $depends_simple{$page}{lc $pagespec} |= $deptype;
2057 return 1;
2060 # Add explicit dependencies for influences.
2061 my $sub=pagespec_translate($pagespec);
2062 return unless defined $sub;
2063 foreach my $p (keys %pagesources) {
2064 my $r=$sub->($p, location => $page);
2065 my $i=$r->influences;
2066 my $static=$r->influences_static;
2067 foreach my $k (keys %$i) {
2068 next unless $r || $static || $k eq $page;
2069 $depends_simple{$page}{lc $k} |= $i->{$k};
2071 last if $static;
2074 $depends{$page}{$pagespec} |= $deptype;
2075 return 1;
2078 sub deptype (@) {
2079 my $deptype=0;
2080 foreach my $type (@_) {
2081 if ($type eq 'presence') {
2082 $deptype |= $DEPEND_PRESENCE;
2084 elsif ($type eq 'links') {
2085 $deptype |= $DEPEND_LINKS;
2087 elsif ($type eq 'content') {
2088 $deptype |= $DEPEND_CONTENT;
2091 return $deptype;
2094 my $file_prune_regexp;
2095 sub file_pruned ($) {
2096 my $file=shift;
2098 if (defined $config{include} && length $config{include}) {
2099 return 0 if $file =~ m/$config{include}/;
2102 if (! defined $file_prune_regexp) {
2103 $file_prune_regexp='('.join('|', @{$config{wiki_file_prune_regexps}}).')';
2104 $file_prune_regexp=qr/$file_prune_regexp/;
2106 return $file =~ m/$file_prune_regexp/;
2109 sub define_gettext () {
2110 # If translation is needed, redefine the gettext function to do it.
2111 # Otherwise, it becomes a quick no-op.
2112 my $gettext_obj;
2113 my $getobj;
2114 if ((exists $ENV{LANG} && length $ENV{LANG}) ||
2115 (exists $ENV{LC_ALL} && length $ENV{LC_ALL}) ||
2116 (exists $ENV{LC_MESSAGES} && length $ENV{LC_MESSAGES})) {
2117 $getobj=sub {
2118 $gettext_obj=eval q{
2119 use Locale::gettext q{textdomain};
2120 Locale::gettext->domain('ikiwiki')
2125 no warnings 'redefine';
2126 *gettext=sub {
2127 $getobj->() if $getobj;
2128 if ($gettext_obj) {
2129 $gettext_obj->get(shift);
2131 else {
2132 return shift;
2135 *ngettext=sub {
2136 $getobj->() if $getobj;
2137 if ($gettext_obj) {
2138 $gettext_obj->nget(@_);
2140 else {
2141 return ($_[2] == 1 ? $_[0] : $_[1])
2146 sub gettext {
2147 define_gettext();
2148 gettext(@_);
2151 sub ngettext {
2152 define_gettext();
2153 ngettext(@_);
2156 sub yesno ($) {
2157 my $val=shift;
2159 return (defined $val && (lc($val) eq gettext("yes") || lc($val) eq "yes" || $val eq "1"));
2162 sub inject {
2163 # Injects a new function into the symbol table to replace an
2164 # exported function.
2165 my %params=@_;
2167 # This is deep ugly perl foo, beware.
2168 no strict;
2169 no warnings;
2170 if (! defined $params{parent}) {
2171 $params{parent}='::';
2172 $params{old}=\&{$params{name}};
2173 $params{name}=~s/.*:://;
2175 my $parent=$params{parent};
2176 foreach my $ns (grep /^\w+::/, keys %{$parent}) {
2177 $ns = $params{parent} . $ns;
2178 inject(%params, parent => $ns) unless $ns eq '::main::';
2179 *{$ns . $params{name}} = $params{call}
2180 if exists ${$ns}{$params{name}} &&
2181 \&{${$ns}{$params{name}}} == $params{old};
2183 use strict;
2184 use warnings;
2187 sub add_link ($$;$) {
2188 my $page=shift;
2189 my $link=shift;
2190 my $type=shift;
2192 push @{$links{$page}}, $link
2193 unless grep { $_ eq $link } @{$links{$page}};
2195 if (defined $type) {
2196 $typedlinks{$page}{$type}{$link} = 1;
2200 sub add_autofile ($$$) {
2201 my $file=shift;
2202 my $plugin=shift;
2203 my $generator=shift;
2205 $autofiles{$file}{plugin}=$plugin;
2206 $autofiles{$file}{generator}=$generator;
2209 sub sortspec_translate ($$) {
2210 my $spec = shift;
2211 my $reverse = shift;
2213 my $code = "";
2214 my @data;
2215 while ($spec =~ m{
2217 (-?) # group 1: perhaps negated
2219 ( # group 2: a word
2220 \w+\([^\)]*\) # command(params)
2222 [^\s]+ # or anything else
2225 }gx) {
2226 my $negated = $1;
2227 my $word = $2;
2228 my $params = undef;
2230 if ($word =~ m/^(\w+)\((.*)\)$/) {
2231 # command with parameters
2232 $params = $2;
2233 $word = $1;
2235 elsif ($word !~ m/^\w+$/) {
2236 error(sprintf(gettext("invalid sort type %s"), $word));
2239 if (length $code) {
2240 $code .= " || ";
2243 if ($negated) {
2244 $code .= "-";
2247 if (exists $IkiWiki::SortSpec::{"cmp_$word"}) {
2248 if (defined $params) {
2249 push @data, $params;
2250 $code .= "IkiWiki::SortSpec::cmp_$word(\$data[$#data])";
2252 else {
2253 $code .= "IkiWiki::SortSpec::cmp_$word(undef)";
2256 else {
2257 error(sprintf(gettext("unknown sort type %s"), $word));
2261 if (! length $code) {
2262 # undefined sorting method... sort arbitrarily
2263 return sub { 0 };
2266 if ($reverse) {
2267 $code="-($code)";
2270 no warnings;
2271 return eval 'sub { '.$code.' }';
2274 sub pagespec_translate ($) {
2275 my $spec=shift;
2277 # Convert spec to perl code.
2278 my $code="";
2279 my @data;
2280 while ($spec=~m{
2281 \s* # ignore whitespace
2282 ( # 1: match a single word
2283 \! # !
2285 \( # (
2287 \) # )
2289 \w+\([^\)]*\) # command(params)
2291 [^\s()]+ # any other text
2293 \s* # ignore whitespace
2294 }gx) {
2295 my $word=$1;
2296 if (lc $word eq 'and') {
2297 $code.=' &';
2299 elsif (lc $word eq 'or') {
2300 $code.=' |';
2302 elsif ($word eq "(" || $word eq ")" || $word eq "!") {
2303 $code.=' '.$word;
2305 elsif ($word =~ /^(\w+)\((.*)\)$/) {
2306 if (exists $IkiWiki::PageSpec::{"match_$1"}) {
2307 push @data, $2;
2308 $code.="IkiWiki::PageSpec::match_$1(\$page, \$data[$#data], \@_)";
2310 else {
2311 push @data, qq{unknown function in pagespec "$word"};
2312 $code.="IkiWiki::ErrorReason->new(\$data[$#data])";
2315 else {
2316 push @data, $word;
2317 $code.=" IkiWiki::PageSpec::match_glob(\$page, \$data[$#data], \@_)";
2321 if (! length $code) {
2322 $code="IkiWiki::FailReason->new('empty pagespec')";
2325 no warnings;
2326 return eval 'sub { my $page=shift; '.$code.' }';
2329 sub pagespec_match ($$;@) {
2330 my $page=shift;
2331 my $spec=shift;
2332 my @params=@_;
2334 # Backwards compatability with old calling convention.
2335 if (@params == 1) {
2336 unshift @params, 'location';
2339 my $sub=pagespec_translate($spec);
2340 return IkiWiki::ErrorReason->new("syntax error in pagespec \"$spec\"")
2341 if ! defined $sub;
2342 return $sub->($page, @params);
2345 sub pagespec_match_list ($$;@) {
2346 my $page=shift;
2347 my $pagespec=shift;
2348 my %params=@_;
2350 # Backwards compatability with old calling convention.
2351 if (ref $page) {
2352 print STDERR "warning: a plugin (".caller().") is using pagespec_match_list in an obsolete way, and needs to be updated\n";
2353 $params{list}=$page;
2354 $page=$params{location}; # ugh!
2357 my $sub=pagespec_translate($pagespec);
2358 error "syntax error in pagespec \"$pagespec\""
2359 if ! defined $sub;
2360 my $sort=sortspec_translate($params{sort}, $params{reverse})
2361 if defined $params{sort};
2363 my @candidates;
2364 if (exists $params{list}) {
2365 @candidates=exists $params{filter}
2366 ? grep { ! $params{filter}->($_) } @{$params{list}}
2367 : @{$params{list}};
2369 else {
2370 @candidates=exists $params{filter}
2371 ? grep { ! $params{filter}->($_) } keys %pagesources
2372 : keys %pagesources;
2375 # clear params, remainder is passed to pagespec
2376 $depends{$page}{$pagespec} |= ($params{deptype} || $DEPEND_CONTENT);
2377 my $num=$params{num};
2378 delete @params{qw{num deptype reverse sort filter list}};
2380 # when only the top matches will be returned, it's efficient to
2381 # sort before matching to pagespec,
2382 if (defined $num && defined $sort) {
2383 @candidates=IkiWiki::SortSpec::sort_pages(
2384 $sort, @candidates);
2387 my @matches;
2388 my $firstfail;
2389 my $count=0;
2390 my $accum=IkiWiki::SuccessReason->new();
2391 foreach my $p (@candidates) {
2392 my $r=$sub->($p, %params, location => $page);
2393 error(sprintf(gettext("cannot match pages: %s"), $r))
2394 if $r->isa("IkiWiki::ErrorReason");
2395 unless ($r || $r->influences_static) {
2396 $r->remove_influence($p);
2398 $accum |= $r;
2399 if ($r) {
2400 push @matches, $p;
2401 last if defined $num && ++$count == $num;
2405 # Add simple dependencies for accumulated influences.
2406 my $i=$accum->influences;
2407 foreach my $k (keys %$i) {
2408 $depends_simple{$page}{lc $k} |= $i->{$k};
2411 # when all matches will be returned, it's efficient to
2412 # sort after matching
2413 if (! defined $num && defined $sort) {
2414 return IkiWiki::SortSpec::sort_pages(
2415 $sort, @matches);
2417 else {
2418 return @matches;
2422 sub pagespec_valid ($) {
2423 my $spec=shift;
2425 return defined pagespec_translate($spec);
2428 sub glob2re ($) {
2429 my $re=quotemeta(shift);
2430 $re=~s/\\\*/.*/g;
2431 $re=~s/\\\?/./g;
2432 return qr/^$re$/i;
2435 package IkiWiki::FailReason;
2437 use overload (
2438 '""' => sub { $_[0][0] },
2439 '0+' => sub { 0 },
2440 '!' => sub { bless $_[0], 'IkiWiki::SuccessReason'},
2441 '&' => sub { $_[0]->merge_influences($_[1], 1); $_[0] },
2442 '|' => sub { $_[1]->merge_influences($_[0]); $_[1] },
2443 fallback => 1,
2446 our @ISA = 'IkiWiki::SuccessReason';
2448 package IkiWiki::SuccessReason;
2450 use overload (
2451 '""' => sub { $_[0][0] },
2452 '0+' => sub { 1 },
2453 '!' => sub { bless $_[0], 'IkiWiki::FailReason'},
2454 '&' => sub { $_[1]->merge_influences($_[0], 1); $_[1] },
2455 '|' => sub { $_[0]->merge_influences($_[1]); $_[0] },
2456 fallback => 1,
2459 sub new {
2460 my $class = shift;
2461 my $value = shift;
2462 return bless [$value, {@_}], $class;
2465 sub influences {
2466 my $this=shift;
2467 $this->[1]={@_} if @_;
2468 my %i=%{$this->[1]};
2469 delete $i{""};
2470 return \%i;
2473 sub influences_static {
2474 return ! $_[0][1]->{""};
2477 sub merge_influences {
2478 my $this=shift;
2479 my $other=shift;
2480 my $anded=shift;
2482 if (! $anded || (($this || %{$this->[1]}) &&
2483 ($other || %{$other->[1]}))) {
2484 foreach my $influence (keys %{$other->[1]}) {
2485 $this->[1]{$influence} |= $other->[1]{$influence};
2488 else {
2489 # influence blocker
2490 $this->[1]={};
2494 sub remove_influence {
2495 my $this=shift;
2496 my $torm=shift;
2498 delete $this->[1]{$torm};
2501 package IkiWiki::ErrorReason;
2503 our @ISA = 'IkiWiki::FailReason';
2505 package IkiWiki::PageSpec;
2507 sub derel ($$) {
2508 my $path=shift;
2509 my $from=shift;
2511 if ($path =~ m!^\.(/|$)!) {
2512 if ($1) {
2513 $from=~s#/?[^/]+$## if defined $from;
2514 $path=~s#^\./##;
2515 $path="$from/$path" if defined $from && length $from;
2517 else {
2518 $path = $from;
2519 $path = "" unless defined $path;
2523 return $path;
2526 my %glob_cache;
2528 sub match_glob ($$;@) {
2529 my $page=shift;
2530 my $glob=shift;
2531 my %params=@_;
2533 $glob=derel($glob, $params{location});
2535 # Instead of converting the glob to a regex every time,
2536 # cache the compiled regex to save time.
2537 my $re=$glob_cache{$glob};
2538 unless (defined $re) {
2539 $glob_cache{$glob} = $re = IkiWiki::glob2re($glob);
2541 if ($page =~ $re) {
2542 if (! IkiWiki::isinternal($page) || $params{internal}) {
2543 return IkiWiki::SuccessReason->new("$glob matches $page");
2545 else {
2546 return IkiWiki::FailReason->new("$glob matches $page, but the page is an internal page");
2549 else {
2550 return IkiWiki::FailReason->new("$glob does not match $page");
2554 sub match_internal ($$;@) {
2555 return match_glob(shift, shift, @_, internal => 1)
2558 sub match_page ($$;@) {
2559 my $page=shift;
2560 my $match=match_glob($page, shift, @_);
2561 if ($match) {
2562 my $source=exists $IkiWiki::pagesources{$page} ?
2563 $IkiWiki::pagesources{$page} :
2564 $IkiWiki::delpagesources{$page};
2565 my $type=defined $source ? IkiWiki::pagetype($source) : undef;
2566 if (! defined $type) {
2567 return IkiWiki::FailReason->new("$page is not a page");
2570 return $match;
2573 sub match_link ($$;@) {
2574 my $page=shift;
2575 my $link=lc(shift);
2576 my %params=@_;
2578 $link=derel($link, $params{location});
2579 my $from=exists $params{location} ? $params{location} : '';
2580 my $linktype=$params{linktype};
2581 my $qualifier='';
2582 if (defined $linktype) {
2583 $qualifier=" with type $linktype";
2586 my $links = $IkiWiki::links{$page};
2587 return IkiWiki::FailReason->new("$page has no links", $page => $IkiWiki::DEPEND_LINKS, "" => 1)
2588 unless $links && @{$links};
2589 my $bestlink = IkiWiki::bestlink($from, $link);
2590 foreach my $p (@{$links}) {
2591 next unless (! defined $linktype || exists $IkiWiki::typedlinks{$page}{$linktype}{$p});
2593 if (length $bestlink) {
2594 if ($bestlink eq IkiWiki::bestlink($page, $p)) {
2595 return IkiWiki::SuccessReason->new("$page links to $link$qualifier", $page => $IkiWiki::DEPEND_LINKS, "" => 1)
2598 else {
2599 if (match_glob($p, $link, %params)) {
2600 return IkiWiki::SuccessReason->new("$page links to page $p$qualifier, matching $link", $page => $IkiWiki::DEPEND_LINKS, "" => 1)
2602 my ($p_rel)=$p=~/^\/?(.*)/;
2603 $link=~s/^\///;
2604 if (match_glob($p_rel, $link, %params)) {
2605 return IkiWiki::SuccessReason->new("$page links to page $p_rel$qualifier, matching $link", $page => $IkiWiki::DEPEND_LINKS, "" => 1)
2609 return IkiWiki::FailReason->new("$page does not link to $link$qualifier", $page => $IkiWiki::DEPEND_LINKS, "" => 1);
2612 sub match_backlink ($$;@) {
2613 my $ret=match_link($_[1], $_[0], @_);
2614 $ret->influences($_[1] => $IkiWiki::DEPEND_LINKS);
2615 return $ret;
2618 sub match_created_before ($$;@) {
2619 my $page=shift;
2620 my $testpage=shift;
2621 my %params=@_;
2623 $testpage=derel($testpage, $params{location});
2625 if (exists $IkiWiki::pagectime{$testpage}) {
2626 if ($IkiWiki::pagectime{$page} < $IkiWiki::pagectime{$testpage}) {
2627 return IkiWiki::SuccessReason->new("$page created before $testpage", $testpage => $IkiWiki::DEPEND_PRESENCE);
2629 else {
2630 return IkiWiki::FailReason->new("$page not created before $testpage", $testpage => $IkiWiki::DEPEND_PRESENCE);
2633 else {
2634 return IkiWiki::ErrorReason->new("$testpage does not exist", $testpage => $IkiWiki::DEPEND_PRESENCE);
2638 sub match_created_after ($$;@) {
2639 my $page=shift;
2640 my $testpage=shift;
2641 my %params=@_;
2643 $testpage=derel($testpage, $params{location});
2645 if (exists $IkiWiki::pagectime{$testpage}) {
2646 if ($IkiWiki::pagectime{$page} > $IkiWiki::pagectime{$testpage}) {
2647 return IkiWiki::SuccessReason->new("$page created after $testpage", $testpage => $IkiWiki::DEPEND_PRESENCE);
2649 else {
2650 return IkiWiki::FailReason->new("$page not created after $testpage", $testpage => $IkiWiki::DEPEND_PRESENCE);
2653 else {
2654 return IkiWiki::ErrorReason->new("$testpage does not exist", $testpage => $IkiWiki::DEPEND_PRESENCE);
2658 sub match_creation_day ($$;@) {
2659 my $page=shift;
2660 my $d=shift;
2661 if ($d !~ /^\d+$/) {
2662 return IkiWiki::ErrorReason->new("invalid day $d");
2664 if ((localtime($IkiWiki::pagectime{$page}))[3] == $d) {
2665 return IkiWiki::SuccessReason->new('creation_day matched');
2667 else {
2668 return IkiWiki::FailReason->new('creation_day did not match');
2672 sub match_creation_month ($$;@) {
2673 my $page=shift;
2674 my $m=shift;
2675 if ($m !~ /^\d+$/) {
2676 return IkiWiki::ErrorReason->new("invalid month $m");
2678 if ((localtime($IkiWiki::pagectime{$page}))[4] + 1 == $m) {
2679 return IkiWiki::SuccessReason->new('creation_month matched');
2681 else {
2682 return IkiWiki::FailReason->new('creation_month did not match');
2686 sub match_creation_year ($$;@) {
2687 my $page=shift;
2688 my $y=shift;
2689 if ($y !~ /^\d+$/) {
2690 return IkiWiki::ErrorReason->new("invalid year $y");
2692 if ((localtime($IkiWiki::pagectime{$page}))[5] + 1900 == $y) {
2693 return IkiWiki::SuccessReason->new('creation_year matched');
2695 else {
2696 return IkiWiki::FailReason->new('creation_year did not match');
2700 sub match_user ($$;@) {
2701 shift;
2702 my $user=shift;
2703 my %params=@_;
2705 my $regexp=IkiWiki::glob2re($user);
2707 if (! exists $params{user}) {
2708 return IkiWiki::ErrorReason->new("no user specified");
2711 if (defined $params{user} && $params{user}=~$regexp) {
2712 return IkiWiki::SuccessReason->new("user is $user");
2714 elsif (! defined $params{user}) {
2715 return IkiWiki::FailReason->new("not logged in");
2717 else {
2718 return IkiWiki::FailReason->new("user is $params{user}, not $user");
2722 sub match_admin ($$;@) {
2723 shift;
2724 shift;
2725 my %params=@_;
2727 if (! exists $params{user}) {
2728 return IkiWiki::ErrorReason->new("no user specified");
2731 if (defined $params{user} && IkiWiki::is_admin($params{user})) {
2732 return IkiWiki::SuccessReason->new("user is an admin");
2734 elsif (! defined $params{user}) {
2735 return IkiWiki::FailReason->new("not logged in");
2737 else {
2738 return IkiWiki::FailReason->new("user is not an admin");
2742 sub match_ip ($$;@) {
2743 shift;
2744 my $ip=shift;
2745 my %params=@_;
2747 if (! exists $params{ip}) {
2748 return IkiWiki::ErrorReason->new("no IP specified");
2751 if (defined $params{ip} && lc $params{ip} eq lc $ip) {
2752 return IkiWiki::SuccessReason->new("IP is $ip");
2754 else {
2755 return IkiWiki::FailReason->new("IP is $params{ip}, not $ip");
2759 package IkiWiki::SortSpec;
2761 # This is in the SortSpec namespace so that the $a and $b that sort() uses
2762 # are easily available in this namespace, for cmp functions to use them.
2763 sub sort_pages {
2764 my $f=shift;
2765 sort $f @_
2768 sub cmp_title {
2769 IkiWiki::pagetitle(IkiWiki::basename($a))
2771 IkiWiki::pagetitle(IkiWiki::basename($b))
2774 sub cmp_mtime { $IkiWiki::pagemtime{$b} <=> $IkiWiki::pagemtime{$a} }
2775 sub cmp_age { $IkiWiki::pagectime{$b} <=> $IkiWiki::pagectime{$a} }