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