ikiwiki

   1 #!/usr/bin/perl -T
   2
   3 use warnings;
   4 use strict;
   5 use File::Find;
   6 use Memoize;
   7 use File::Spec;
   8
   9 BEGIN {
  10         $blosxom::version="is a proper perl module too much to ask?";
  11         do "/usr/bin/markdown";
  12 }
  13
  14 memoize('pagename');
  15 memoize('bestlink');
  16
  17 my ($srcdir)= shift =~ /(.*)/; # untaint
  18 my ($destdir)= shift =~ /(.*)/; # untaint
  19 my $link=qr/\[\[([^\s]+)\]\]/;
  20 my $verbose=1;
  21 my $wikiname="wiki";
  22
  23 my %links;
  24 my %oldpagemtime;
  25 my %renderedfiles;
  26
  27 sub error ($) {
  28         die @_;
  29 }
  30
  31 sub debug ($) {
  32         print "@_\n" if $verbose;
  33 }
  34
  35 sub mtime ($) {
  36         my $page=shift;
  37
  38         return (stat($page))[9];
  39 }
  40
  41 sub basename {
  42         my $file=shift;
  43
  44         $file=~s!.*/!!;
  45         return $file;
  46 }
  47
  48 sub dirname {
  49         my $file=shift;
  50
  51         $file=~s!/?[^/]+$!!;
  52         return $file;
  53 }
  54
  55 sub pagetype ($) {
  56         my $page=shift;
  57
  58         if ($page =~ /\.mdwn$/) {
  59                 return ".mdwn";
  60         }
  61         else {
  62                 return "unknown";
  63         }
  64 }
  65
  66 sub pagename ($) {
  67         my $file=shift;
  68
  69         my $type=pagetype($file);
  70         my $page=$file;
  71         $page=~s/\Q$type\E*$// unless $type eq 'unknown';
  72         return $page;
  73 }
  74
  75 sub htmlpage ($) {
  76         my $page=shift;
  77
  78         return $page.".html";
  79 }
  80
  81 sub readpage ($) {
  82         my $page=shift;
  83
  84         local $/=undef;
  85         open (PAGE, "$srcdir/$page") || error("failed to read $page: $!");
  86         my $ret=<PAGE>;
  87         close PAGE;
  88         return $ret;
  89 }
  90
  91 sub writepage ($$) {
  92         my $page=shift;
  93         my $content=shift;
  94
  95         my $dir=dirname("$destdir/$page");
  96         if (! -d $dir) {
  97                 my $d="";
  98                 foreach my $s (split(m!/+!, $dir)) {
  99                         $d.="$s/";
 100                         if (! -d $d) {
 101                                 mkdir($d) || error("failed to create directory $d: $!");
 102                         }
 103                 }
 104         }
 105
 106         open (PAGE, ">$destdir/$page") || error("failed to write $page: $!");
 107         print PAGE $content;
 108         close PAGE;
 109 }
 110
 111 sub findlinks {
 112         my $content=shift;
 113
 114         my @links;
 115         while ($content =~ /$link/g) {
 116                 push @links, lc($1);
 117         }
 118         return @links;
 119 }
 120
 121 # Given a page and the text of a link on the page, determine which existing
 122 # page that link best points to. Prefers pages under a subdirectory with
 123 # the same name as the source page, failing that goes down the directory tree
 124 # to the base looking for matching pages.
 125 sub bestlink ($$) {
 126         my $page=shift;
 127         my $link=lc(shift);
 128
 129         my $cwd=$page;
 130         do {
 131                 my $l=$cwd;
 132                 $l.="/" if length $l;
 133                 $l.=$link;
 134
 135                 if (exists $links{$l}) {
 136                         #debug("for $page, \"$link\", use $l");
 137                         return $l;
 138                 }
 139         } while $cwd=~s!/?[^/]+$!!;
 140
 141         print STDERR "warning: page $page, broken link: $link\n";
 142         return "";
 143 }
 144
 145 sub isinlinableimage ($) {
 146         my $file=shift;
 147
 148         $file=~/\.(png|gif|jpg|jpeg)$/;
 149 }
 150
 151 sub htmllink ($$) {
 152         my $page=shift;
 153         my $link=shift;
 154
 155         my $bestlink=bestlink($page, $link);
 156
 157         return $link if $page eq $bestlink;
 158
 159         if (! grep { $_ eq $bestlink } values %renderedfiles) {
 160                 $bestlink=htmlpage($bestlink);
 161         }
 162         if (! grep { $_ eq $bestlink } values %renderedfiles) {
 163                 return "<a href=\"?\">?</a>$link"
 164         }
 165
 166         $bestlink=File::Spec->abs2rel($bestlink, dirname($page));
 167
 168         if (isinlinableimage($bestlink)) {
 169                 return "<img src=\"$bestlink\">";
 170         }
 171         return "<a href=\"$bestlink\">$link</a>";
 172 }
 173
 174 sub linkify ($$) {
 175         my $content=shift;
 176         my $file=shift;
 177
 178         $content =~ s/$link/htmllink(pagename($file), $1)/eg;
 179
 180         return $content;
 181 }
 182
 183 sub htmlize ($$) {
 184         my $type=shift;
 185         my $content=shift;
 186
 187         if ($type eq '.mdwn') {
 188                 return Markdown::Markdown($content);
 189         }
 190         else {
 191                 error("htmlization of $type not supported");
 192         }
 193 }
 194
 195 sub finalize ($$) {
 196         my $content=shift;
 197         my $page=shift;
 198
 199         my $title=basename($page);
 200         $title=~s/_/ /g;
 201
 202         my $pagelink="";
 203         my $path="";
 204         foreach my $dir (reverse split("/", $page)) {
 205                 if (length($pagelink)) {
 206                         $pagelink="<a href=\"$path$dir.html\">$dir/</a> $pagelink";
 207                 }
 208                 else {
 209                         $pagelink=$dir;
 210                 }
 211                 $path.="../";
 212         }
 213         $path=~s/\.\.\///;
 214         $pagelink="<a href=\"$path\">$wikiname/</a> $pagelink";
 215
 216         $content="<html>\n<head><title>$title</title></head>\n<body>\n".
 217                   "<h1>$pagelink</h1>\n".
 218                   $content.
 219                   "</body>\n</html>\n";
 220
 221         return $content;
 222 }
 223
 224 sub render ($) {
 225         my $file=shift;
 226
 227         my $type=pagetype($file);
 228         my $content=readpage($file);
 229         if ($type ne 'unknown') {
 230                 my $page=pagename($file);
 231                 $links{$page}=[findlinks($content)];
 232
 233                 $content=linkify($content, $file);
 234                 $content=htmlize($type, $content);
 235                 $content=finalize($content, $page);
 236
 237                 writepage(htmlpage($page), $content);
 238                 $oldpagemtime{$page}=time;
 239                 $renderedfiles{$page}=htmlpage($page);
 240         }
 241         else {
 242                 $links{$file}=[];
 243                 writepage($file, $content);
 244                 $oldpagemtime{$file}=time;
 245                 $renderedfiles{$file}=$file;
 246         }
 247 }
 248
 249 sub loadindex () {
 250         open (IN, "$srcdir/.index") || return;
 251         while (<IN>) {
 252                 chomp;
 253                 my ($mtime, $page, $rendered, @links)=split(' ', $_);
 254                 $oldpagemtime{$page}=$mtime;
 255                 $links{$page}=\@links;
 256                 ($renderedfiles{$page})=$rendered=~m/(.*)/; # untaint
 257         }
 258         close IN;
 259 }
 260
 261 sub saveindex () {
 262         open (OUT, ">$srcdir/.index") || error("cannot write to .index: $!");
 263         foreach my $page (keys %oldpagemtime) {
 264         print OUT "$oldpagemtime{$page} $page $renderedfiles{$page} ".
 265                   join(" ", @{$links{$page}})."\n"
 266                         if $oldpagemtime{$page};
 267         }
 268         close OUT;
 269 }
 270
 271 sub prune ($) {
 272         my $file=shift;
 273
 274         unlink($file);
 275         my $dir=dirname($file);
 276         while (rmdir($dir)) {
 277                 $dir=dirname($dir);
 278         }
 279 }
 280
 281 sub refresh () {
 282         # Find existing pages.
 283         my %exists;
 284         my @files;
 285         find({
 286                 no_chdir => 1,
 287                 wanted => sub {
 288                         if (/\/\.svn\//) {
 289                                 $File::Find::prune=1;
 290                         }
 291                         elsif (! -d $_ && ! /\.html$/ && ! /\/\./) {
 292                                 my ($f)=/(^[-A-Za-z0-9_.:\/+]+$)/; # untaint
 293                                 if (! defined $f) {
 294                                         warn("skipping bad filename $_\n");
 295                                 }
 296                                 else {
 297                                         $f=~s/^\Q$srcdir\E\/?//;
 298                                         push @files, $f;
 299                                         $exists{pagename($f)}=1;
 300                                 }
 301                         }
 302                 },
 303         }, $srcdir);
 304
 305         # check for added or removed pages
 306         my @adddel;
 307         foreach my $file (@files) {
 308                 my $page=pagename($file);
 309                 if (! $oldpagemtime{$page}) {
 310                         debug("new page $page");
 311                         push @adddel, $page;
 312                         $links{$page}=[];
 313                 }
 314         }
 315         foreach my $page (keys %oldpagemtime) {
 316                 if (! $exists{$page}) {
 317                         debug("removing old page $page");
 318                         prune($destdir."/".$renderedfiles{$page});
 319                         delete $renderedfiles{$page};
 320                         $oldpagemtime{$page}=0;
 321                         push @adddel, $page;
 322                 }
 323         }
 324
 325         # render any updated files
 326         foreach my $file (@files) {
 327                 my $page=pagename($file);
 328
 329                 if (! exists $oldpagemtime{$page} ||
 330                     mtime("$srcdir/$file") > $oldpagemtime{$page}) {
 331                         debug("rendering changed file $file");
 332                         render($file);
 333                 }
 334         }
 335
 336         # if any files were added or removed, check to see if each page
 337         # needs an update due to linking to them
 338         if (@adddel) {
 339 FILE:           foreach my $file (@files) {
 340                         my $page=pagename($file);
 341                         foreach my $p (@adddel) {
 342                                 foreach my $link (@{$links{$page}}) {
 343                                         if (bestlink($page, $link) eq $p) {
 344                                                 debug("rendering $file, which links to $p");
 345                                                 render($file);
 346                                                 next FILE;
 347                                         }
 348                                 }
 349                         }
 350                 }
 351         }
 352 }
 353
 354 loadindex();
 355 refresh();
 356 saveindex();