]> sipb.mit.edu Git - ikiwiki.git/blob - IkiWiki/Plugin/po.pm
po: better rootpage logic for inline's post form
[ikiwiki.git] / IkiWiki / Plugin / po.pm
1 #!/usr/bin/perl
2 # .po as a wiki page type
3 # Licensed under GPL v2 or greater
4 # Copyright (C) 2008-2009 intrigeri <intrigeri@boum.org>
5 # inspired by the GPL'd po4a-translate,
6 # which is Copyright 2002, 2003, 2004 by Martin Quinson (mquinson#debian.org)
7 package IkiWiki::Plugin::po;
8
9 use warnings;
10 use strict;
11 use IkiWiki 3.00;
12 use Encode;
13 eval q{use Locale::Po4a::Common qw(nowrapi18n !/.*/)};
14 if ($@) {
15         print STDERR gettext("warning: Old po4a detected! Recommend upgrade to 0.35.")."\n";
16         eval q{use Locale::Po4a::Common qw(!/.*/)};
17         die $@ if $@;
18 }
19 use Locale::Po4a::Chooser;
20 use Locale::Po4a::Po;
21 use File::Basename;
22 use File::Copy;
23 use File::Spec;
24 use File::Temp;
25 use Memoize;
26 use UNIVERSAL;
27
28 my %translations;
29 my @origneedsbuild;
30 my %origsubs;
31
32 memoize("istranslatable");
33 memoize("_istranslation");
34 memoize("percenttranslated");
35
36 sub import {
37         hook(type => "getsetup", id => "po", call => \&getsetup);
38         hook(type => "checkconfig", id => "po", call => \&checkconfig);
39         hook(type => "needsbuild", id => "po", call => \&needsbuild);
40         hook(type => "scan", id => "po", call => \&scan, last => 1);
41         hook(type => "filter", id => "po", call => \&filter);
42         hook(type => "htmlize", id => "po", call => \&htmlize);
43         hook(type => "pagetemplate", id => "po", call => \&pagetemplate, last => 1);
44         hook(type => "rename", id => "po", call => \&renamepages, first => 1);
45         hook(type => "delete", id => "po", call => \&mydelete);
46         hook(type => "change", id => "po", call => \&change);
47         hook(type => "checkcontent", id => "po", call => \&checkcontent);
48         hook(type => "canremove", id => "po", call => \&canremove);
49         hook(type => "canrename", id => "po", call => \&canrename);
50         hook(type => "editcontent", id => "po", call => \&editcontent);
51         hook(type => "formbuilder_setup", id => "po", call => \&formbuilder_setup, last => 1);
52         hook(type => "formbuilder", id => "po", call => \&formbuilder);
53
54         $origsubs{'beautify_urlpath'}=\&IkiWiki::beautify_urlpath;
55         inject(name => "IkiWiki::beautify_urlpath", call => \&mybeautify_urlpath);
56         $origsubs{'targetpage'}=\&IkiWiki::targetpage;
57         inject(name => "IkiWiki::targetpage", call => \&mytargetpage);
58         $origsubs{'urlto'}=\&IkiWiki::urlto;
59         inject(name => "IkiWiki::urlto", call => \&myurlto);
60         $origsubs{'cgiurl'}=\&IkiWiki::cgiurl;
61         inject(name => "IkiWiki::cgiurl", call => \&mycgiurl);
62         $origsubs{'rootpage'}=\&IkiWiki::rootpage;
63         inject(name => "IkiWiki::rootpage", call => \&myrootpage);
64 }
65
66
67 # ,----
68 # | Table of contents
69 # `----
70
71 # 1. Hooks
72 # 2. Injected functions
73 # 3. Blackboxes for private data
74 # 4. Helper functions
75 # 5. PageSpecs
76
77
78 # ,----
79 # | Hooks
80 # `----
81
82 sub getsetup () {
83         return
84                 plugin => {
85                         safe => 0,
86                         rebuild => 1,
87                 },
88                 po_master_language => {
89                         type => "string",
90                         example => {
91                                 'code' => 'en',
92                                 'name' => 'English'
93                         },
94                         description => "master language (non-PO files)",
95                         safe => 1,
96                         rebuild => 1,
97                 },
98                 po_slave_languages => {
99                         type => "string",
100                         example => {
101                                 'fr' => 'Français',
102                                 'es' => 'Español',
103                                 'de' => 'Deutsch'
104                         },
105                         description => "slave languages (PO files)",
106                         safe => 1,
107                         rebuild => 1,
108                 },
109                 po_translatable_pages => {
110                         type => "pagespec",
111                         example => "* and !*/Discussion",
112                         description => "PageSpec controlling which pages are translatable",
113                         link => "ikiwiki/PageSpec",
114                         safe => 1,
115                         rebuild => 1,
116                 },
117                 po_link_to => {
118                         type => "string",
119                         example => "current",
120                         description => "internal linking behavior (default/current/negotiated)",
121                         safe => 1,
122                         rebuild => 1,
123                 },
124 }
125
126 sub checkconfig () {
127         foreach my $field (qw{po_master_language}) {
128                 if (! exists $config{$field} || ! defined $config{$field}) {
129                         error(sprintf(gettext("Must specify %s when using the %s plugin"),
130                                       $field, 'po'));
131                 }
132         }
133
134         map {
135                 islanguagecode($_)
136                         or error(sprintf(gettext("%s is not a valid language code"), $_));
137         } ($config{po_master_language}{code}, keys %{$config{po_slave_languages}});
138
139         if (! exists $config{po_translatable_pages} ||
140             ! defined $config{po_translatable_pages}) {
141                 $config{po_translatable_pages}="";
142         }
143         if (! exists $config{po_link_to} ||
144             ! defined $config{po_link_to}) {
145                 $config{po_link_to}='default';
146         }
147         elsif ($config{po_link_to} !~ /^(default|current|negotiated)$/) {
148                 warn(sprintf(gettext('%s is not a valid value for po_link_to, falling back to po_link_to=default'),
149                              $config{po_link_to}));
150                 $config{po_link_to}='default';
151         }
152         elsif ($config{po_link_to} eq "negotiated" && ! $config{usedirs}) {
153                 warn(gettext('po_link_to=negotiated requires usedirs to be enabled, falling back to po_link_to=default'));
154                 $config{po_link_to}='default';
155         }
156         unless ($config{po_link_to} eq 'default') {
157                 $origsubs{'bestlink'}=\&IkiWiki::bestlink;
158                 inject(name => "IkiWiki::bestlink", call => \&mybestlink);
159         }
160
161         push @{$config{wiki_file_prune_regexps}}, qr/\.pot$/;
162
163         # Translated versions of the underlays are added if available.
164         foreach my $underlay ("basewiki",
165                               map { m/^\Q$config{underlaydirbase}\E\/*(.*)/ }
166                                   reverse @{$config{underlaydirs}}) {
167                 next if $underlay=~/^locale\//;
168
169                 # Underlays containing the po files for slave languages.
170                 foreach my $ll (keys %{$config{po_slave_languages}}) {
171                         add_underlay("po/$ll/$underlay")
172                                 if -d "$config{underlaydirbase}/po/$ll/$underlay";
173                 }
174         
175                 if ($config{po_master_language}{code} ne 'en') {
176                         # Add underlay containing translated source files
177                         # for the master language.
178                         add_underlay("locale/$config{po_master_language}{code}/$underlay");
179                 }
180         }
181 }
182
183 sub needsbuild () {
184         my $needsbuild=shift;
185
186         # backup @needsbuild content so that change() can know whether
187         # a given master page was rendered because its source file was changed
188         @origneedsbuild=(@$needsbuild);
189
190         flushmemoizecache();
191         buildtranslationscache();
192
193         # make existing translations depend on the corresponding master page
194         foreach my $master (keys %translations) {
195                 map add_depends($_, $master), values %{otherlanguages($master)};
196         }
197 }
198
199 # Massage the recorded state of internal links so that:
200 # - it matches the actually generated links, rather than the links as written
201 #   in the pages' source
202 # - backlinks are consistent in all cases
203 sub scan (@) {
204         my %params=@_;
205         my $page=$params{page};
206         my $content=$params{content};
207
208         if (istranslation($page)) {
209                 foreach my $destpage (@{$links{$page}}) {
210                         if (istranslatable($destpage)) {
211                                 # replace the occurence of $destpage in $links{$page}
212                                 for (my $i=0; $i<@{$links{$page}}; $i++) {
213                                         if (@{$links{$page}}[$i] eq $destpage) {
214                                                 @{$links{$page}}[$i] = $destpage . '.' . lang($page);
215                                                 last;
216                                         }
217                                 }
218                         }
219                 }
220         }
221         elsif (! istranslatable($page) && ! istranslation($page)) {
222                 foreach my $destpage (@{$links{$page}}) {
223                         if (istranslatable($destpage)) {
224                                 # make sure any destpage's translations has
225                                 # $page in its backlinks
226                                 push @{$links{$page}},
227                                         values %{otherlanguages($destpage)};
228                         }
229                 }
230         }
231 }
232
233 # We use filter to convert PO to the master page's format,
234 # since the rest of ikiwiki should not work on PO files.
235 sub filter (@) {
236         my %params = @_;
237
238         my $page = $params{page};
239         my $destpage = $params{destpage};
240         my $content = $params{content};
241         if (istranslation($page) && ! alreadyfiltered($page, $destpage)) {
242                 $content = po_to_markup($page, $content);
243                 setalreadyfiltered($page, $destpage);
244         }
245         return $content;
246 }
247
248 sub htmlize (@) {
249         my %params=@_;
250
251         my $page = $params{page};
252         my $content = $params{content};
253
254         # ignore PO files this plugin did not create
255         return $content unless istranslation($page);
256
257         # force content to be htmlize'd as if it was the same type as the master page
258         return IkiWiki::htmlize($page, $page,
259                 pagetype(srcfile($pagesources{masterpage($page)})),
260                 $content);
261 }
262
263 sub pagetemplate (@) {
264         my %params=@_;
265         my $page=$params{page};
266         my $destpage=$params{destpage};
267         my $template=$params{template};
268
269         my ($masterpage, $lang) = istranslation($page);
270
271         if (istranslation($page) && $template->query(name => "percenttranslated")) {
272                 $template->param(percenttranslated => percenttranslated($page));
273         }
274         if ($template->query(name => "istranslation")) {
275                 $template->param(istranslation => scalar istranslation($page));
276         }
277         if ($template->query(name => "istranslatable")) {
278                 $template->param(istranslatable => istranslatable($page));
279         }
280         if ($template->query(name => "HOMEPAGEURL")) {
281                 $template->param(homepageurl => homepageurl($page));
282         }
283         if ($template->query(name => "otherlanguages")) {
284                 $template->param(otherlanguages => [otherlanguagesloop($page)]);
285                 map add_depends($page, $_), (values %{otherlanguages($page)});
286         }
287         if ($config{discussion} && istranslation($page)) {
288                 if ($page !~ /.*\/\Q$config{discussionpage}\E$/i &&
289                    (length $config{cgiurl} ||
290                     exists $links{$masterpage."/".lc($config{discussionpage})})) {
291                         $template->param('discussionlink' => htmllink(
292                                 $page,
293                                 $destpage,
294                                 $masterpage . '/' . $config{discussionpage},
295                                 noimageinline => 1,
296                                 forcesubpage => 0,
297                                 linktext => $config{discussionpage},
298                 ));
299                 }
300         }
301         # Remove broken parentlink to ./index.html on home page's translations.
302         # It works because this hook has the "last" parameter set, to ensure it
303         # runs after parentlinks' own pagetemplate hook.
304         if ($template->param('parentlinks')
305             && istranslation($page)
306             && $masterpage eq "index") {
307                 $template->param('parentlinks' => []);
308         }
309         if (ishomepage($page) && $template->query(name => "title")) {
310                 $template->param(title => $config{wikiname});
311         }
312 } # }}}
313
314 # Add the renamed page translations to the list of to-be-renamed pages.
315 sub renamepages (@) {
316         my %params = @_;
317
318         my %torename = %{$params{torename}};
319         my $session = $params{session};
320
321         # Save the page(s) the user asked to rename, so that our
322         # canrename hook can tell the difference between:
323         #  - a translation being renamed as a consequence of its master page
324         #    being renamed
325         #  - a user trying to directly rename a translation
326         # This is why this hook has to be run first, before the list of pages
327         # to rename is modified by other plugins.
328         my @orig_torename;
329         @orig_torename=@{$session->param("po_orig_torename")}
330                 if defined $session->param("po_orig_torename");
331         push @orig_torename, $torename{src};
332         $session->param(po_orig_torename => \@orig_torename);
333         IkiWiki::cgi_savesession($session);
334
335         return () unless istranslatable($torename{src});
336
337         my @ret;
338         my %otherpages=%{otherlanguages($torename{src})};
339         while (my ($lang, $otherpage) = each %otherpages) {
340                 push @ret, {
341                         src => $otherpage,
342                         srcfile => $pagesources{$otherpage},
343                         dest => otherlanguage($torename{dest}, $lang),
344                         destfile => $torename{dest}.".".$lang.".po",
345                         required => 0,
346                 };
347         }
348         return @ret;
349 }
350
351 sub mydelete (@) {
352         my @deleted=@_;
353
354         map { deletetranslations($_) } grep istranslatablefile($_), @deleted;
355 }
356
357 sub change (@) {
358         my @rendered=@_;
359
360         # All meta titles are first extracted at scan time, i.e. before we turn
361         # PO files back into translated markdown; escaping of double-quotes in
362         # PO files breaks the meta plugin's parsing enough to save ugly titles
363         # to %pagestate at this time.
364         #
365         # Then, at render time, every page passes in turn through the Great
366         # Rendering Chain (filter->preprocess->linkify->htmlize), and the meta
367         # plugin's preprocess hook is this time in a position to correctly
368         # extract the titles from slave pages.
369         #
370         # This is, unfortunately, too late: if the page A, linking to the page
371         # B, is rendered before B, it will display the wrongly-extracted meta
372         # title as the link text to B.
373         #
374         # On the one hand, such a corner case only happens on rebuild: on
375         # refresh, every rendered page is fixed to contain correct meta titles.
376         # On the other hand, it can take some time to get every page fixed.
377         # We therefore re-render every rendered page after a rebuild to fix them
378         # at once. As this more or less doubles the time needed to rebuild the
379         # wiki, we do so only when really needed.
380
381         if (@rendered
382             && exists $config{rebuild} && defined $config{rebuild} && $config{rebuild}
383             && UNIVERSAL::can("IkiWiki::Plugin::meta", "getsetup")
384             && exists $config{meta_overrides_page_title}
385             && defined $config{meta_overrides_page_title}
386             && $config{meta_overrides_page_title}) {
387                 debug(sprintf(gettext("rebuilding all pages to fix meta titles")));
388                 resetalreadyfiltered();
389                 require IkiWiki::Render;
390                 foreach my $file (@rendered) {
391                         debug(sprintf(gettext("building %s"), $file));
392                         IkiWiki::render($file);
393                 }
394         }
395
396         my $updated_po_files=0;
397
398         # Refresh/create POT and PO files as needed.
399         # (But avoid doing so if they are in an underlay directory.)
400         foreach my $file (grep {istranslatablefile($_)} @rendered) {
401                 my $masterfile=srcfile($file);
402                 my $page=pagename($file);
403                 my $updated_pot_file=0;
404                 # Only refresh POT file if it does not exist, or if
405                 # $pagesources{$page} was changed: don't if only the HTML was
406                 # refreshed, e.g. because of a dependency.
407                 if ($masterfile eq "$config{srcdir}/$file" &&
408                    ((grep { $_ eq $pagesources{$page} } @origneedsbuild)
409                     || ! -e potfile($masterfile))) {
410                         refreshpot($masterfile);
411                         $updated_pot_file=1;
412                 }
413                 my @pofiles;
414                 foreach my $po (pofiles($masterfile)) {
415                         next if ! $updated_pot_file && ! -e $po;
416                         next if grep { $po=~/\Q$_\E/ } @{$config{underlaydirs}};
417                         push @pofiles, $po;
418                 }
419                 if (@pofiles) {
420                         refreshpofiles($masterfile, @pofiles);
421                         map { s/^\Q$config{srcdir}\E\/*//; IkiWiki::rcs_add($_) } @pofiles if $config{rcs};
422                         $updated_po_files=1;
423                 }
424         }
425
426         if ($updated_po_files) {
427                 commit_and_refresh(
428                         gettext("updated PO files"),
429                         "IkiWiki::Plugin::po::change");
430         }
431 }
432
433 sub checkcontent (@) {
434         my %params=@_;
435
436         if (istranslation($params{page})) {
437                 my $res = isvalidpo($params{content});
438                 if ($res) {
439                         return undef;
440                 }
441                 else {
442                         return "$res";
443                 }
444         }
445         return undef;
446 }
447
448 sub canremove (@) {
449         my %params = @_;
450
451         if (istranslation($params{page})) {
452                 return gettext("Can not remove a translation. If the master page is removed, ".
453                                "however, its translations will be removed as well.");
454         }
455         return undef;
456 }
457
458 sub canrename (@) {
459         my %params = @_;
460         my $session = $params{session};
461
462         if (istranslation($params{src})) {
463                 my $masterpage = masterpage($params{src});
464                 # Tell the difference between:
465                 #  - a translation being renamed as a consequence of its master page
466                 #    being renamed, which is allowed
467                 #  - a user trying to directly rename a translation, which is forbidden
468                 # by looking for the master page in the list of to-be-renamed pages we
469                 # saved early in the renaming process.
470                 my $orig_torename = $session->param("po_orig_torename");
471                 unless (grep { $_ eq $masterpage } @{$orig_torename}) {
472                         return gettext("Can not rename a translation. If the master page is renamed, ".
473                                        "however, its translations will be renamed as well.");
474                 }
475         }
476         return undef;
477 }
478
479 # As we're previewing or saving a page, the content may have
480 # changed, so tell the next filter() invocation it must not be lazy.
481 sub editcontent () {
482         my %params=@_;
483
484         unsetalreadyfiltered($params{page}, $params{page});
485         return $params{content};
486 }
487
488 sub formbuilder_setup (@) {
489         my %params=@_;
490         my $form=$params{form};
491         my $q=$params{cgi};
492
493         return unless defined $form->field("do");
494
495         if ($form->field("do") eq "create") {
496                 # Warn the user: new pages must be written in master language.
497                 my $template=template("pocreatepage.tmpl");
498                 $template->param(LANG => $config{po_master_language}{name});
499                 $form->tmpl_param(message => $template->output);
500         }
501         elsif ($form->field("do") eq "edit") {
502                 # Remove the rename/remove buttons on slave pages.
503                 # This has to be done after the rename/remove plugins have added
504                 # their buttons, which is why this hook must be run last.
505                 # The canrename/canremove hooks already ensure this is forbidden
506                 # at the backend level, so this is only UI sugar.
507                 if (istranslation($form->field("page"))) {
508                         map {
509                                 for (my $i = 0; $i < @{$params{buttons}}; $i++) {
510                                         if (@{$params{buttons}}[$i] eq $_) {
511                                                 delete  @{$params{buttons}}[$i];
512                                                 last;
513                                         }
514                                 }
515                         } qw(Rename Remove);
516                 }
517         }
518 }
519
520 sub formbuilder (@) {
521         my %params=@_;
522         my $form=$params{form};
523         my $q=$params{cgi};
524
525         return unless defined $form->field("do");
526
527         # Do not allow to create pages of type po: they are automatically created.
528         # The main reason to do so is to bypass the "favor the type of linking page
529         # on page creation" logic, which is unsuitable when a broken link is clicked
530         # on a slave (PO) page.
531         # This cannot be done in the formbuilder_setup hook as the list of types is
532         # computed later.
533         if ($form->field("do") eq "create") {
534                 foreach my $field ($form->field) {
535                         next unless "$field" eq "type";
536                         next unless $field->type eq 'select';
537                         my $orig_value = $field->value;
538                         # remove po from the list of types
539                         my @types = grep { $_->[0] ne 'po' } $field->options;
540                         $field->options(\@types) if @types;
541                         # favor the type of linking page's masterpage
542                         if ($orig_value eq 'po') {
543                                 my ($from, $type);
544                                 if (defined $form->field('from')) {
545                                         ($from)=$form->field('from')=~/$config{wiki_file_regexp}/;
546                                         $from = masterpage($from);
547                                 }
548                                 if (defined $from && exists $pagesources{$from}) {
549                                         $type=pagetype($pagesources{$from});
550                                 }
551                                 $type=$config{default_pageext} unless defined $type;
552                                 $field->value($type) ;
553                         }
554                 }
555         }
556 }
557
558 # ,----
559 # | Injected functions
560 # `----
561
562 # Implement po_link_to 'current' and 'negotiated' settings.
563 # Not injected otherwise.
564 sub mybestlink ($$) {
565         my $page=shift;
566         my $link=shift;
567
568         my $res=$origsubs{'bestlink'}->(masterpage($page), $link);
569         if (length $res
570             && istranslatable($res)
571             && istranslation($page)) {
572                 return $res . "." . lang($page);
573         }
574         return $res;
575 }
576
577 sub mybeautify_urlpath ($) {
578         my $url=shift;
579
580         my $res=$origsubs{'beautify_urlpath'}->($url);
581         if ($config{po_link_to} eq "negotiated") {
582                 $res =~ s!/\Qindex.$config{po_master_language}{code}.$config{htmlext}\E$!/!;
583                 $res =~ s!/\Qindex.$config{htmlext}\E$!/!;
584                 map {
585                         $res =~ s!/\Qindex.$_.$config{htmlext}\E$!/!;
586                 } (keys %{$config{po_slave_languages}});
587         }
588         return $res;
589 }
590
591 sub mytargetpage ($$) {
592         my $page=shift;
593         my $ext=shift;
594
595         if (istranslation($page) || istranslatable($page)) {
596                 my ($masterpage, $lang) = (masterpage($page), lang($page));
597                 if (! $config{usedirs} || $masterpage eq 'index') {
598                         return $masterpage . "." . $lang . "." . $ext;
599                 }
600                 else {
601                         return $masterpage . "/index." . $lang . "." . $ext;
602                 }
603         }
604         return $origsubs{'targetpage'}->($page, $ext);
605 }
606
607 sub myurlto ($$;$) {
608         my $to=shift;
609         my $from=shift;
610         my $absolute=shift;
611
612         # workaround hard-coded /index.$config{htmlext} in IkiWiki::urlto()
613         if (! length $to
614             && $config{po_link_to} eq "current"
615             && istranslatable('index')) {
616                 return IkiWiki::beautify_urlpath(IkiWiki::baseurl($from) . "index." . lang($from) . ".$config{htmlext}");
617         }
618         # avoid using our injected beautify_urlpath if run by cgi_editpage,
619         # so that one is redirected to the just-edited page rather than to the
620         # negociated translation; to prevent unnecessary fiddling with caller/inject,
621         # we only do so when our beautify_urlpath would actually do what we want to
622         # avoid, i.e. when po_link_to = negotiated.
623         # also avoid doing so when run by cgi_goto, so that the links on recentchanges
624         # page actually lead to the exact page they pretend to.
625         if ($config{po_link_to} eq "negotiated") {
626                 my @caller = caller(1);
627                 my $use_orig = 0;
628                 $use_orig = 1 if (exists $caller[3] && defined $caller[3]
629                                  && ($caller[3] eq "IkiWiki::cgi_editpage" ||
630                                      $caller[3] eq "IkiWiki::Plugin::goto::cgi_goto")
631                                  );
632                 inject(name => "IkiWiki::beautify_urlpath", call => $origsubs{'beautify_urlpath'})
633                         if $use_orig;
634                 my $res = $origsubs{'urlto'}->($to,$from,$absolute);
635                 inject(name => "IkiWiki::beautify_urlpath", call => \&mybeautify_urlpath)
636                         if $use_orig;
637                 return $res;
638         }
639         else {
640                 return $origsubs{'urlto'}->($to,$from,$absolute)
641         }
642 }
643
644 sub mycgiurl (@) {
645         my %params=@_;
646
647         # slave pages have no subpages
648         if (istranslation($params{'from'})) {
649                 $params{'from'} = masterpage($params{'from'});
650         }
651         return $origsubs{'cgiurl'}->(%params);
652 }
653
654 sub myrootpage (@) {
655         my %params=@_;
656
657         my $rootpage;
658         if (exists $params{rootpage}) {
659                 $rootpage=$origsubs{'bestlink'}->($params{page}, $params{rootpage});
660                 if (!length $rootpage) {
661                         $rootpage=$params{rootpage};
662                 }
663         }
664         else {
665                 $rootpage=masterpage($params{page});
666         }
667         return $rootpage;
668 }
669
670 # ,----
671 # | Blackboxes for private data
672 # `----
673
674 {
675         my %filtered;
676
677         sub alreadyfiltered($$) {
678                 my $page=shift;
679                 my $destpage=shift;
680
681                 return exists $filtered{$page}{$destpage}
682                          && $filtered{$page}{$destpage} eq 1;
683         }
684
685         sub setalreadyfiltered($$) {
686                 my $page=shift;
687                 my $destpage=shift;
688
689                 $filtered{$page}{$destpage}=1;
690         }
691
692         sub unsetalreadyfiltered($$) {
693                 my $page=shift;
694                 my $destpage=shift;
695
696                 if (exists $filtered{$page}{$destpage}) {
697                         delete $filtered{$page}{$destpage};
698                 }
699         }
700
701         sub resetalreadyfiltered() {
702                 undef %filtered;
703         }
704 }
705
706 # ,----
707 # | Helper functions
708 # `----
709
710 sub maybe_add_leading_slash ($;$) {
711         my $str=shift;
712         my $add=shift;
713         $add=1 unless defined $add;
714         return '/' . $str if $add;
715         return $str;
716 }
717
718 sub istranslatablefile ($) {
719         my $file=shift;
720
721         return 0 unless defined $file;
722         my $type=pagetype($file);
723         return 0 if ! defined $type || $type eq 'po';
724         return 0 if $file =~ /\.pot$/;
725         return 1 if pagespec_match(pagename($file), $config{po_translatable_pages});
726         return;
727 }
728
729 sub istranslatable ($) {
730         my $page=shift;
731
732         $page=~s#^/##;
733         return 1 if istranslatablefile($pagesources{$page});
734         return;
735 }
736
737 sub _istranslation ($) {
738         my $page=shift;
739
740         $page='' unless defined $page && length $page;
741         my $hasleadingslash = ($page=~s#^/##);
742         my $file=$pagesources{$page};
743         return 0 unless defined $file
744                          && defined pagetype($file)
745                          && pagetype($file) eq 'po';
746         return 0 if $file =~ /\.pot$/;
747
748         my ($masterpage, $lang) = ($page =~ /(.*)[.]([a-z]{2})$/);
749         return 0 unless defined $masterpage && defined $lang
750                          && length $masterpage && length $lang
751                          && defined $pagesources{$masterpage}
752                          && defined $config{po_slave_languages}{$lang};
753
754         return (maybe_add_leading_slash($masterpage, $hasleadingslash), $lang)
755                 if istranslatable($masterpage);
756 }
757
758 sub istranslation ($) {
759         my $page=shift;
760
761         if (1 < (my ($masterpage, $lang) = _istranslation($page))) {
762                 my $hasleadingslash = ($masterpage=~s#^/##);
763                 $translations{$masterpage}{$lang}=$page unless exists $translations{$masterpage}{$lang};
764                 return (maybe_add_leading_slash($masterpage, $hasleadingslash), $lang);
765         }
766         return "";
767 }
768
769 sub masterpage ($) {
770         my $page=shift;
771
772         if ( 1 < (my ($masterpage, $lang) = _istranslation($page))) {
773                 return $masterpage;
774         }
775         return $page;
776 }
777
778 sub lang ($) {
779         my $page=shift;
780
781         if (1 < (my ($masterpage, $lang) = _istranslation($page))) {
782                 return $lang;
783         }
784         return $config{po_master_language}{code};
785 }
786
787 sub islanguagecode ($) {
788         my $code=shift;
789
790         return $code =~ /^[a-z]{2}$/;
791 }
792
793 sub otherlanguage ($$) {
794         my $page=shift;
795         my $code=shift;
796
797         return masterpage($page) if $code eq $config{po_master_language}{code};
798         return masterpage($page) . '.' . $code;
799 }
800
801 sub otherlanguages ($) {
802         my $page=shift;
803
804         my %ret;
805         return \%ret unless istranslation($page) || istranslatable($page);
806         my $curlang=lang($page);
807         foreach my $lang
808                 ($config{po_master_language}{code}, keys %{$config{po_slave_languages}}) {
809                 next if $lang eq $curlang;
810                 $ret{$lang}=otherlanguage($page, $lang);
811         }
812         return \%ret;
813 }
814
815 sub potfile ($) {
816         my $masterfile=shift;
817
818         (my $name, my $dir, my $suffix) = fileparse($masterfile, qr/\.[^.]*/);
819         $dir='' if $dir eq './';
820         return File::Spec->catpath('', $dir, $name . ".pot");
821 }
822
823 sub pofile ($$) {
824         my $masterfile=shift;
825         my $lang=shift;
826
827         (my $name, my $dir, my $suffix) = fileparse($masterfile, qr/\.[^.]*/);
828         $dir='' if $dir eq './';
829         return File::Spec->catpath('', $dir, $name . "." . $lang . ".po");
830 }
831
832 sub pofiles ($) {
833         my $masterfile=shift;
834
835         return map pofile($masterfile, $_), (keys %{$config{po_slave_languages}});
836 }
837
838 sub refreshpot ($) {
839         my $masterfile=shift;
840
841         my $potfile=potfile($masterfile);
842         my %options = ("markdown" => (pagetype($masterfile) eq 'mdwn') ? 1 : 0);
843         my $doc=Locale::Po4a::Chooser::new('text',%options);
844         $doc->{TT}{utf_mode} = 1;
845         $doc->{TT}{file_in_charset} = 'utf-8';
846         $doc->{TT}{file_out_charset} = 'utf-8';
847         $doc->read($masterfile);
848         # let's cheat a bit to force porefs option to be passed to
849         # Locale::Po4a::Po; this is undocument use of internal
850         # Locale::Po4a::TransTractor's data, compulsory since this module
851         # prevents us from using the porefs option.
852         $doc->{TT}{po_out}=Locale::Po4a::Po->new({ 'porefs' => 'none' });
853         $doc->{TT}{po_out}->set_charset('utf-8');
854         # do the actual work
855         $doc->parse;
856         IkiWiki::prep_writefile(basename($potfile),dirname($potfile));
857         $doc->writepo($potfile);
858 }
859
860 sub refreshpofiles ($@) {
861         my $masterfile=shift;
862         my @pofiles=@_;
863
864         my $potfile=potfile($masterfile);
865         if (! -e $potfile) {
866                 error("po(refreshpofiles) ".sprintf(gettext("POT file (%s) does not exist"), $potfile));
867         }
868
869         foreach my $pofile (@pofiles) {
870                 IkiWiki::prep_writefile(basename($pofile),dirname($pofile));
871
872                 if (! -e $pofile) {
873                         # If the po file exists in an underlay, copy it
874                         # from there.
875                         my ($pobase)=$pofile=~/^\Q$config{srcdir}\E\/?(.*)$/;
876                         foreach my $dir (@{$config{underlaydirs}}) {
877                                 if (-e "$dir/$pobase") {
878                                         File::Copy::syscopy("$dir/$pobase",$pofile)
879                                                 or error("po(refreshpofiles) ".
880                                                          sprintf(gettext("failed to copy underlay PO file to %s"),
881                                                                  $pofile));
882                                 }
883                         }
884                 }
885
886                 if (-e $pofile) {
887                         system("msgmerge", "--previous", "-q", "-U", "--backup=none", $pofile, $potfile) == 0
888                                 or error("po(refreshpofiles) ".
889                                          sprintf(gettext("failed to update %s"),
890                                                  $pofile));
891                 }
892                 else {
893                         File::Copy::syscopy($potfile,$pofile)
894                                 or error("po(refreshpofiles) ".
895                                          sprintf(gettext("failed to copy the POT file to %s"),
896                                                  $pofile));
897                 }
898         }
899 }
900
901 sub buildtranslationscache() {
902         # use istranslation's side-effect
903         map istranslation($_), (keys %pagesources);
904 }
905
906 sub resettranslationscache() {
907         undef %translations;
908 }
909
910 sub flushmemoizecache() {
911         Memoize::flush_cache("istranslatable");
912         Memoize::flush_cache("_istranslation");
913         Memoize::flush_cache("percenttranslated");
914 }
915
916 sub urlto_with_orig_beautiful_urlpath($$) {
917         my $to=shift;
918         my $from=shift;
919
920         inject(name => "IkiWiki::beautify_urlpath", call => $origsubs{'beautify_urlpath'});
921         my $res=urlto($to, $from);
922         inject(name => "IkiWiki::beautify_urlpath", call => \&mybeautify_urlpath);
923
924         return $res;
925 }
926
927 sub percenttranslated ($) {
928         my $page=shift;
929
930         $page=~s/^\///;
931         return gettext("N/A") unless istranslation($page);
932         my $file=srcfile($pagesources{$page});
933         my $masterfile = srcfile($pagesources{masterpage($page)});
934         my %options = (
935                 "markdown" => (pagetype($masterfile) eq 'mdwn') ? 1 : 0,
936         );
937         my $doc=Locale::Po4a::Chooser::new('text',%options);
938         $doc->process(
939                 'po_in_name'    => [ $file ],
940                 'file_in_name'  => [ $masterfile ],
941                 'file_in_charset'  => 'utf-8',
942                 'file_out_charset' => 'utf-8',
943         ) or error("po(percenttranslated) ".
944                    sprintf(gettext("failed to translate %s"), $page));
945         my ($percent,$hit,$queries) = $doc->stats();
946         $percent =~ s/\.[0-9]+$//;
947         return $percent;
948 }
949
950 sub languagename ($) {
951         my $code=shift;
952
953         return $config{po_master_language}{name}
954                 if $code eq $config{po_master_language}{code};
955         return $config{po_slave_languages}{$code}
956                 if defined $config{po_slave_languages}{$code};
957         return;
958 }
959
960 sub otherlanguagesloop ($) {
961         my $page=shift;
962
963         my @ret;
964         my %otherpages=%{otherlanguages($page)};
965         while (my ($lang, $otherpage) = each %otherpages) {
966                 if (istranslation($page) && masterpage($page) eq $otherpage) {
967                         push @ret, {
968                                 url => urlto_with_orig_beautiful_urlpath($otherpage, $page),
969                                 code => $lang,
970                                 language => languagename($lang),
971                                 master => 1,
972                         };
973                 }
974                 elsif (istranslation($otherpage)) {
975                         push @ret, {
976                                 url => urlto_with_orig_beautiful_urlpath($otherpage, $page),
977                                 code => $lang,
978                                 language => languagename($lang),
979                                 percent => percenttranslated($otherpage),
980                         }
981                 }
982         }
983         return sort {
984                 return -1 if $a->{code} eq $config{po_master_language}{code};
985                 return 1 if $b->{code} eq $config{po_master_language}{code};
986                 return $a->{language} cmp $b->{language};
987         } @ret;
988 }
989
990 sub homepageurl (;$) {
991         my $page=shift;
992
993         return urlto('', $page);
994 }
995
996 sub ishomepage ($) {
997         my $page = shift;
998
999         return 1 if $page eq 'index';
1000         map { return 1 if $page eq 'index.'.$_ } keys %{$config{po_slave_languages}};
1001         return undef;
1002 }
1003
1004 sub deletetranslations ($) {
1005         my $deletedmasterfile=shift;
1006
1007         my $deletedmasterpage=pagename($deletedmasterfile);
1008         my @todelete;
1009         map {
1010                 my $file = newpagefile($deletedmasterpage.'.'.$_, 'po');
1011                 my $absfile = "$config{srcdir}/$file";
1012                 if (-e $absfile && ! -l $absfile && ! -d $absfile) {
1013                         push @todelete, $file;
1014                 }
1015         } keys %{$config{po_slave_languages}};
1016
1017         map {
1018                 if ($config{rcs}) {
1019                         IkiWiki::rcs_remove($_);
1020                 }
1021                 else {
1022                         IkiWiki::prune("$config{srcdir}/$_");
1023                 }
1024         } @todelete;
1025
1026         if (@todelete) {
1027                 commit_and_refresh(
1028                         gettext("removed obsolete PO files"),
1029                         "IkiWiki::Plugin::po::deletetranslations");
1030         }
1031 }
1032
1033 sub commit_and_refresh ($$) {
1034         my ($msg, $author) = (shift, shift);
1035
1036         if ($config{rcs}) {
1037                 IkiWiki::disable_commit_hook();
1038                 IkiWiki::rcs_commit_staged($msg, $author, "127.0.0.1");
1039                 IkiWiki::enable_commit_hook();
1040                 IkiWiki::rcs_update();
1041         }
1042         # Reinitialize module's private variables.
1043         resetalreadyfiltered();
1044         resettranslationscache();
1045         flushmemoizecache();
1046         # Trigger a wiki refresh.
1047         require IkiWiki::Render;
1048         # without preliminary saveindex/loadindex, refresh()
1049         # complains about a lot of uninitialized variables
1050         IkiWiki::saveindex();
1051         IkiWiki::loadindex();
1052         IkiWiki::refresh();
1053         IkiWiki::saveindex();
1054 }
1055
1056 # on success, returns the filtered content.
1057 # on error, if $nonfatal, warn and return undef; else, error out.
1058 sub po_to_markup ($$;$) {
1059         my ($page, $content) = (shift, shift);
1060         my $nonfatal = shift;
1061
1062         $content = '' unless defined $content;
1063         $content = decode_utf8(encode_utf8($content));
1064         # CRLF line terminators make poor Locale::Po4a feel bad
1065         $content=~s/\r\n/\n/g;
1066
1067         # There are incompatibilities between some File::Temp versions
1068         # (including 0.18, bundled with Lenny's perl-modules package)
1069         # and others (e.g. 0.20, previously present in the archive as
1070         # a standalone package): under certain circumstances, some
1071         # return a relative filename, whereas others return an absolute one;
1072         # we here use this module in a way that is at least compatible
1073         # with 0.18 and 0.20. Beware, hit'n'run refactorers!
1074         my $infile = new File::Temp(TEMPLATE => "ikiwiki-po-filter-in.XXXXXXXXXX",
1075                                     DIR => File::Spec->tmpdir,
1076                                     UNLINK => 1)->filename;
1077         my $outfile = new File::Temp(TEMPLATE => "ikiwiki-po-filter-out.XXXXXXXXXX",
1078                                      DIR => File::Spec->tmpdir,
1079                                      UNLINK => 1)->filename;
1080
1081         my $fail = sub ($) {
1082                 my $msg = "po(po_to_markup) - $page : " . shift;
1083                 if ($nonfatal) {
1084                         warn $msg;
1085                         return undef;
1086                 }
1087                 error($msg, sub { unlink $infile, $outfile});
1088         };
1089
1090         writefile(basename($infile), File::Spec->tmpdir, $content)
1091                 or return $fail->(sprintf(gettext("failed to write %s"), $infile));
1092
1093         my $masterfile = srcfile($pagesources{masterpage($page)});
1094         my %options = (
1095                 "markdown" => (pagetype($masterfile) eq 'mdwn') ? 1 : 0,
1096         );
1097         my $doc=Locale::Po4a::Chooser::new('text',%options);
1098         $doc->process(
1099                 'po_in_name'    => [ $infile ],
1100                 'file_in_name'  => [ $masterfile ],
1101                 'file_in_charset'  => 'utf-8',
1102                 'file_out_charset' => 'utf-8',
1103         ) or return $fail->(gettext("failed to translate"));
1104         $doc->write($outfile)
1105                 or return $fail->(sprintf(gettext("failed to write %s"), $outfile));
1106
1107         $content = readfile($outfile)
1108                 or return $fail->(sprintf(gettext("failed to read %s"), $outfile));
1109
1110         # Unlinking should happen automatically, thanks to File::Temp,
1111         # but it does not work here, probably because of the way writefile()
1112         # and Locale::Po4a::write() work.
1113         unlink $infile, $outfile;
1114
1115         return $content;
1116 }
1117
1118 # returns a SuccessReason or FailReason object
1119 sub isvalidpo ($) {
1120         my $content = shift;
1121
1122         # NB: we don't use po_to_markup here, since Po4a parser does
1123         # not mind invalid PO content
1124         $content = '' unless defined $content;
1125         $content = decode_utf8(encode_utf8($content));
1126
1127         # There are incompatibilities between some File::Temp versions
1128         # (including 0.18, bundled with Lenny's perl-modules package)
1129         # and others (e.g. 0.20, previously present in the archive as
1130         # a standalone package): under certain circumstances, some
1131         # return a relative filename, whereas others return an absolute one;
1132         # we here use this module in a way that is at least compatible
1133         # with 0.18 and 0.20. Beware, hit'n'run refactorers!
1134         my $infile = new File::Temp(TEMPLATE => "ikiwiki-po-isvalidpo.XXXXXXXXXX",
1135                                     DIR => File::Spec->tmpdir,
1136                                     UNLINK => 1)->filename;
1137
1138         my $fail = sub ($) {
1139                 my $msg = '[po/isvalidpo] ' . shift;
1140                 unlink $infile;
1141                 return IkiWiki::FailReason->new("$msg");
1142         };
1143
1144         writefile(basename($infile), File::Spec->tmpdir, $content)
1145                 or return $fail->(sprintf(gettext("failed to write %s"), $infile));
1146
1147         my $res = (system("msgfmt", "--check", $infile, "-o", "/dev/null") == 0);
1148
1149         # Unlinking should happen automatically, thanks to File::Temp,
1150         # but it does not work here, probably because of the way writefile()
1151         # and Locale::Po4a::write() work.
1152         unlink $infile;
1153
1154         if ($res) {
1155             return IkiWiki::SuccessReason->new("valid gettext data");
1156         }
1157         return IkiWiki::FailReason->new(gettext("invalid gettext data, go back ".
1158                                         "to previous page to continue edit"));
1159 }
1160
1161 # ,----
1162 # | PageSpecs
1163 # `----
1164
1165 package IkiWiki::PageSpec;
1166
1167 sub match_istranslation ($;@) {
1168         my $page=shift;
1169
1170         if (IkiWiki::Plugin::po::istranslation($page)) {
1171                 return IkiWiki::SuccessReason->new("is a translation page");
1172         }
1173         else {
1174                 return IkiWiki::FailReason->new("is not a translation page");
1175         }
1176 }
1177
1178 sub match_istranslatable ($;@) {
1179         my $page=shift;
1180
1181         if (IkiWiki::Plugin::po::istranslatable($page)) {
1182                 return IkiWiki::SuccessReason->new("is set as translatable in po_translatable_pages");
1183         }
1184         else {
1185                 return IkiWiki::FailReason->new("is not set as translatable in po_translatable_pages");
1186         }
1187 }
1188
1189 sub match_lang ($$;@) {
1190         my $page=shift;
1191         my $wanted=shift;
1192
1193         my $regexp=IkiWiki::glob2re($wanted);
1194         my $lang=IkiWiki::Plugin::po::lang($page);
1195         if ($lang !~ /^$regexp$/i) {
1196                 return IkiWiki::FailReason->new("file language is $lang, not $wanted");
1197         }
1198         else {
1199                 return IkiWiki::SuccessReason->new("file language is $wanted");
1200         }
1201 }
1202
1203 sub match_currentlang ($$;@) {
1204         my $page=shift;
1205         shift;
1206         my %params=@_;
1207
1208         return IkiWiki::FailReason->new("no location provided") unless exists $params{location};
1209
1210         my $currentlang=IkiWiki::Plugin::po::lang($params{location});
1211         my $lang=IkiWiki::Plugin::po::lang($page);
1212
1213         if ($lang eq $currentlang) {
1214                 return IkiWiki::SuccessReason->new("file language is the same as current one, i.e. $currentlang");
1215         }
1216         else {
1217                 return IkiWiki::FailReason->new("file language is $lang, whereas current language is $currentlang");
1218         }
1219 }
1220
1221 1