Weitere Verbesserungen am asynchronen Import.
[kivitendo-erp.git] / scripts / locales.pl
1 #!/usr/bin/perl
2
3 # -n do not include custom_ scripts
4 # -v verbose mode, shows progress stuff
5
6 # this version of locles processes not only all required .pl files
7 # but also all parse_html_templated files.
8
9 use utf8;
10 use strict;
11
12 use Carp;
13 use Data::Dumper;
14 use English;
15 use File::Slurp qw(slurp);
16 use FileHandle;
17 use Getopt::Long;
18 use IO::Dir;
19 use List::Util qw(first);
20 use POSIX;
21 use Pod::Usage;
22
23 $OUTPUT_AUTOFLUSH = 1;
24
25 my $opt_v  = 0;
26 my $opt_n  = 0;
27 my $opt_c  = 0;
28 my $debug  = 0;
29
30 parse_args();
31
32 my $basedir      = "../..";
33 my $locales_dir  = ".";
34 my $bindir       = "$basedir/bin/mozilla";
35 my @progdirs     = ( "$basedir/SL" );
36 my $dbupdir      = "$basedir/sql/Pg-upgrade";
37 my $dbupdir2     = "$basedir/sql/Pg-upgrade2";
38 my $menufile     = "menu.ini";
39 my $submitsearch = qr/type\s*=\s*[\"\']?submit/i;
40 our $self        = {};
41 our $missing     = {};
42 our @lost        = ();
43
44 my (%referenced_html_files, %locale, %htmllocale, %alllocales, %cached, %submit);
45 my ($ALL_HEADER, $MISSING_HEADER, $LOST_HEADER);
46
47 init();
48
49 sub find_files {
50   my ($top_dir_name) = @_;
51
52   my (@files, $finder);
53
54   $finder = sub {
55     my ($dir_name) = @_;
56
57     tie my %dir_h, 'IO::Dir', $dir_name;
58
59     push @files,   grep { -f } map { "${dir_name}/${_}" }                       keys %dir_h;
60     my @sub_dirs = grep { -d } map { "${dir_name}/${_}" } grep { ! m/^\.\.?$/ } keys %dir_h;
61
62     $finder->($_) for @sub_dirs;
63   };
64
65   $finder->($top_dir_name);
66
67   return @files;
68 }
69
70 sub merge_texts {
71 # overwrite existing entries with the ones from 'missing'
72   $self->{texts}->{$_} = $missing->{$_} for grep { $missing->{$_} } keys %alllocales;
73
74   # try to set missing entries from lost ones
75   my %lost_by_text = map { ($_->{text} => $_->{translation}) } @lost;
76   $self->{texts}->{$_} = $lost_by_text{$_} for grep { !$self->{texts}{$_} } keys %alllocales;
77 }
78
79 my @bindir_files = find_files($bindir);
80 my @progfiles    = map { m:^(.+)/([^/]+)$:; [ $2, $1 ]  } grep { /\.pl$/ && !/_custom/ } @bindir_files;
81 my @customfiles  = grep /_custom/, @bindir_files;
82
83 push @progfiles, map { m:^(.+)/([^/]+)$:; [ $2, $1 ] } grep { /\.pm$/ } map { find_files($_) } @progdirs;
84
85 # put customized files into @customfiles
86 my (@menufiles, %dir_h);
87
88 if ($opt_n) {
89   @customfiles = ();
90   @menufiles   = ($menufile);
91 } else {
92   tie %dir_h, 'IO::Dir', $basedir;
93   @menufiles = map { "$basedir/$_" } grep { /.*?_$menufile$/ } keys %dir_h;
94   unshift @menufiles, "$basedir/$menufile";
95 }
96
97 tie %dir_h, 'IO::Dir', $dbupdir;
98 my @dbplfiles = grep { /\.pl$/ } keys %dir_h;
99
100 tie %dir_h, 'IO::Dir', $dbupdir2;
101 my @dbplfiles2 = grep { /\.pl$/ } keys %dir_h;
102
103 # slurp the translations in
104 if (-f "$locales_dir/all") {
105   require "$locales_dir/all";
106 }
107 if (-f "$locales_dir/missing") {
108   require "$locales_dir/missing" ;
109   unlink "$locales_dir/missing";
110 }
111 if (-f "$locales_dir/lost") {
112   require "$locales_dir/lost";
113   unlink "$locales_dir/lost";
114 }
115
116 my $charset = slurp("$locales_dir/charset") || 'utf-8';
117 chomp $charset;
118
119 my %old_texts = %{ $self->{texts} || {} };
120
121 handle_file(@{ $_ })       for @progfiles;
122 handle_file($_, $dbupdir)  for @dbplfiles;
123 handle_file($_, $dbupdir2) for @dbplfiles2;
124 scanmenu($_)               for @menufiles;
125
126 # merge entries to translate with entries from files 'missing' and 'lost'
127 merge_texts();
128
129 # generate all
130 generate_file(
131   file      => "$locales_dir/all",
132   header    => $ALL_HEADER,
133   data_name => '$self->{texts}',
134   data_sub  => sub { _print_line($_, $self->{texts}{$_}, @_) for sort keys %alllocales },
135 );
136
137   foreach my $text (keys %$missing) {
138     if ($locale{$text} || $htmllocale{$text}) {
139       unless ($self->{texts}{$text}) {
140         $self->{texts}{$text} = $missing->{$text};
141       }
142     }
143   }
144
145
146 # calc and generate missing
147 my @new_missing = grep { !$self->{texts}{$_} } sort keys %alllocales;
148
149 if (@new_missing) {
150   generate_file(
151     file      => "$locales_dir/missing",
152     header    => $MISSING_HEADER,
153     data_name => '$missing',
154     data_sub  => sub { _print_line($_, '', @_) for @new_missing },
155   );
156 }
157
158 # calc and generate lost
159 while (my ($text, $translation) = each %old_texts) {
160   next if ($alllocales{$text});
161   push @lost, { 'text' => $text, 'translation' => $translation };
162 }
163
164 if (scalar @lost) {
165   splice @lost, 0, (scalar @lost - 50) if (scalar @lost > 50);
166   generate_file(
167     file      => "$locales_dir/lost",
168     header    => $LOST_HEADER,
169     delim     => '()',
170     data_name => '@lost',
171     data_sub  => sub {
172       _print_line($_->{text}, $_->{translation}, @_, template => "  { 'text' => %s, 'translation' => %s },\n") for @lost;
173     },
174   );
175 }
176
177 my $trlanguage = slurp("$locales_dir/LANGUAGE");
178 chomp $trlanguage;
179
180 search_unused_htmlfiles() if $opt_c;
181
182 my $count  = scalar keys %alllocales;
183 my $notext = scalar @new_missing;
184 my $per    = sprintf("%.1f", ($count - $notext) / $count * 100);
185 print "\n$trlanguage - ${per}%";
186 print " - $notext/$count missing" if $notext;
187 print "\n";
188
189 exit;
190
191 # eom
192
193 sub init {
194   $ALL_HEADER = <<EOL;
195 # These are all the texts to build the translations files.
196 # The file has the form of 'english text'  => 'foreign text',
197 # you can add the translation in this file or in the 'missing' file
198 # run locales.pl from this directory to rebuild the translation files
199 EOL
200   $MISSING_HEADER = <<EOL;
201 # add the missing texts and run locales.pl to rebuild
202 EOL
203   $LOST_HEADER  = <<EOL;
204 # The last 50 text strings, that have been removed.
205 # This file has been auto-generated by locales.pl. Please don't edit!
206 EOL
207 }
208
209 sub parse_args {
210   my ($help, $man);
211
212   GetOptions(
213     'no-custom-files' => \$opt_n,
214     'check-files'     => \$opt_c,
215     'verbose'         => \$opt_v,
216     'help'            => \$help,
217     'man'             => \$man,
218     'debug'           => \$debug,
219   );
220
221   if ($help) {
222     pod2usage(1);
223     exit 0;
224   }
225
226   if ($man) {
227     pod2usage(-exitstatus => 0, -verbose => 2);
228     exit 0;
229   }
230
231   if (@ARGV) {
232     my $arg = shift @ARGV;
233     my $ok  = 0;
234     foreach my $dir ("../locale/$arg", "locale/$arg", "../$arg", $arg) {
235       next unless -d $dir && -f "$dir/all" && -f "$dir/LANGUAGE";
236       $ok = chdir $dir;
237       last;
238     }
239
240     if (!$ok) {
241       print "The locale directory '$arg' could not be found.\n";
242       exit 1;
243     }
244
245   } elsif (!-f 'all' || !-f 'LANGUAGE') {
246     print "locales.pl was not called from a locale/* subdirectory,\n"
247       .   "and no locale directory name was given.\n";
248     exit 1;
249   }
250 }
251
252 sub handle_file {
253   my ($file, $dir) = @_;
254   print "\n$file" if $opt_v;
255   %locale = ();
256   %submit = ();
257
258   &scanfile("$dir/$file");
259
260   # scan custom_{module}.pl or {login}_{module}.pl files
261   foreach my $customfile (@customfiles) {
262     if ($customfile =~ /_$file/) {
263       if (-f "$dir/$customfile") {
264         &scanfile("$dir/$customfile");
265       }
266     }
267   }
268
269   $file =~ s/\.pl//;
270 }
271
272 sub extract_text_between_parenthesis {
273   my ($fh, $line) = @_;
274   my ($inside_string, $pos, $text, $quote_next) = (undef, 0, "", 0);
275
276   while (1) {
277     if (length($line) <= $pos) {
278       $line = <$fh>;
279       return ($text, "") unless ($line);
280       $pos = 0;
281     }
282
283     my $cur_char = substr($line, $pos, 1);
284
285     if (!$inside_string) {
286       if ((length($line) >= ($pos + 3)) && (substr($line, $pos, 2)) eq "qq") {
287         $inside_string = substr($line, $pos + 2, 1);
288         $pos += 2;
289
290       } elsif ((length($line) >= ($pos + 2)) &&
291                (substr($line, $pos, 1) eq "q")) {
292         $inside_string = substr($line, $pos + 1, 1);
293         $pos++;
294
295       } elsif (($cur_char eq '"') || ($cur_char eq '\'')) {
296         $inside_string = $cur_char;
297
298       } elsif (($cur_char eq ")") || ($cur_char eq ',')) {
299         return ($text, substr($line, $pos + 1));
300       }
301
302     } else {
303       if ($quote_next) {
304         $text .= '\\' unless $cur_char eq "'";
305         $text .= $cur_char;
306         $quote_next = 0;
307
308       } elsif ($cur_char eq '\\') {
309         $quote_next = 1;
310
311       } elsif ($cur_char eq $inside_string) {
312         undef($inside_string);
313
314       } else {
315         $text .= $cur_char;
316
317       }
318     }
319     $pos++;
320   }
321 }
322
323 sub scanfile {
324   my $file = shift;
325   my $dont_include_subs = shift;
326   my $scanned_files = shift;
327
328   # sanitize file
329   $file =~ s=/+=/=g;
330
331   $scanned_files = {} unless ($scanned_files);
332   return if ($scanned_files->{$file});
333   $scanned_files->{$file} = 1;
334
335   if (!defined $cached{$file}) {
336
337     return unless (-f "$file");
338
339     my $fh = new FileHandle;
340     open $fh, "$file" or die "$! : $file";
341
342     my ($is_submit, $line_no, $sub_line_no) = (0, 0, 0);
343
344     while (<$fh>) {
345       last if /^\s*__END__/;
346
347       $line_no++;
348
349       # is this another file
350       if (/require\s+\W.*\.pl/) {
351         my $newfile = $&;
352         $newfile =~ s/require\s+\W//;
353         $newfile =~ s|bin/mozilla||;
354          $cached{$file}{scan}{"$bindir/$newfile"} = 1;
355       } elsif (/use\s+SL::([\w:]*)/) {
356         my $module =  $1;
357         $module    =~ s|::|/|g;
358         $cached{$file}{scannosubs}{"../../SL/${module}.pm"} = 1;
359       }
360
361       # is this a template call?
362       if (/(?:parse_html_template2?|render)\s*\(\s*[\"\']([\w\/]+)\s*[\"\']/) {
363         my $newfile = "$basedir/templates/webpages/$1.html";
364         if (/parse_html_template2/) {
365           print "E: " . strip_base($file) . " is still using 'parse_html_template2' for " . strip_base($newfile) . ".\n";
366         }
367         if (-f $newfile) {
368            $cached{$file}{scanh}{$newfile} = 1;
369           print "." if $opt_v;
370         } elsif ($opt_c) {
371           print "W: missing HTML template: " . strip_base($newfile) . " (referenced from " . strip_base($file) . ")\n";
372         }
373       }
374
375       my $rc = 1;
376
377       while ($rc) {
378         if (/Locale/) {
379           unless (/^use /) {
380             my ($null, $country) = split /,/;
381             $country =~ s/^ +[\"\']//;
382             $country =~ s/[\"\'].*//;
383           }
384         }
385
386         my $postmatch = "";
387
388         # is it a submit button before $locale->
389         if (/$submitsearch/) {
390           $postmatch = "$'";
391           if ($` !~ /locale->text/) {
392             $is_submit   = 1;
393             $sub_line_no = $line_no;
394           }
395         }
396
397         my ($found) = / (?: locale->text | \b t8 ) \b .*? \(/x;
398         $postmatch = "$'";
399
400         if ($found) {
401           my $string;
402           ($string, $_) = extract_text_between_parenthesis($fh, $postmatch);
403           $postmatch = $_;
404
405           # if there is no $ in the string record it
406           unless (($string =~ /\$\D.*/) || ("" eq $string)) {
407
408             # this guarantees one instance of string
409             $cached{$file}{locale}{$string} = 1;
410
411             # this one is for all the locales
412             $cached{$file}{all}{$string} = 1;
413
414             # is it a submit button before $locale->
415             if ($is_submit) {
416               $cached{$file}{submit}{$string} = 1;
417             }
418           }
419         } elsif ($postmatch =~ />/) {
420           $is_submit = 0;
421         }
422
423         # exit loop if there are no more locales on this line
424         ($rc) = ($postmatch =~ /locale->text/);
425
426         if (   ($postmatch =~ />/)
427             || (!$found && ($sub_line_no != $line_no) && />/)) {
428           $is_submit = 0;
429         }
430       }
431     }
432
433     close($fh);
434
435   }
436
437   $alllocales{$_} = 1             for keys %{$cached{$file}{all}};
438   $locale{$_}     = 1             for keys %{$cached{$file}{locale}};
439   $submit{$_}     = 1             for keys %{$cached{$file}{submit}};
440
441   scanfile($_, 0, $scanned_files) for keys %{$cached{$file}{scan}};
442   scanfile($_, 1, $scanned_files) for keys %{$cached{$file}{scannosubs}};
443   scanhtmlfile($_)                for keys %{$cached{$file}{scanh}};
444
445   $referenced_html_files{$_} = 1  for keys %{$cached{$file}{scanh}};
446 }
447
448 sub scanmenu {
449   my $file = shift;
450
451   my $fh = new FileHandle;
452   open $fh, "$file" or die "$! : $file";
453
454   my @a = grep m/^\[/, <$fh>;
455   close($fh);
456
457   # strip []
458   grep { s/(\[|\])//g } @a;
459
460   foreach my $item (@a) {
461     my @b = split /--/, $item;
462     foreach my $string (@b) {
463       chomp $string;
464       $locale{$string}     = 1;
465       $alllocales{$string} = 1;
466     }
467   }
468
469 }
470
471 sub unescape_template_string {
472   my $in =  "$_[0]";
473   $in    =~ s/\\(.)/$1/g;
474   return $in;
475 }
476
477 sub scanhtmlfile {
478   local *IN;
479
480   my $file = shift;
481
482   if (!defined $cached{$file}) {
483     my %plugins = ( 'loaded' => { }, 'needed' => { } );
484
485     open(IN, $file) || die $file;
486
487     my $copying  = 0;
488     my $issubmit = 0;
489     my $text     = "";
490     while (my $line = <IN>) {
491       chomp($line);
492
493       while ($line =~ m/\[\%[^\w]*use[^\w]+(\w+)[^\w]*?\%\]/gi) {
494         $plugins{loaded}->{$1} = 1;
495       }
496
497       while ($line =~ m/\[\%[^\w]*(\w+)\.\w+\(/g) {
498         my $plugin = $1;
499         $plugins{needed}->{$plugin} = 1 if (first { $_ eq $plugin } qw(HTML LxERP JavaScript MultiColumnIterator L));
500       }
501
502       while ($line =~ m/(?:             # Start von Variante 1: LxERP.t8('...'); ohne darumliegende [% ... %]-Tags
503                           (LxERP\.t8)\( #   LxERP.t8(                             ::Parameter $1::
504                           ([\'\"])      #   Anfang des zu übersetzenden Strings   ::Parameter $2::
505                           (.*?)         #   Der zu übersetzende String            ::Parameter $3::
506                           (?<!\\)\2     #   Ende des zu übersetzenden Strings
507                         |               # Start von Variante 2: [% '...' | $T8 %]
508                           \[\%          #   Template-Start-Tag
509                           [\-~#]?       #   Whitespace-Unterdrückung
510                           \s*           #   Optional beliebig viele Whitespace
511                           ([\'\"])      #   Anfang des zu übersetzenden Strings   ::Parameter $4::
512                           (.*?)         #   Der zu übersetzende String            ::Parameter $5::
513                           (?<!\\)\4     #   Ende des zu übersetzenden Strings
514                           \s*\|\s*      #   Pipe-Zeichen mit optionalen Whitespace davor und danach
515                           (\$T8)        #   Filteraufruf                          ::Parameter $6::
516                           .*?           #   Optionale Argumente für den Filter
517                           \s*           #   Whitespaces
518                           [\-~#]?       #   Whitespace-Unterdrückung
519                           \%\]          #   Template-Ende-Tag
520                         )
521                        /ix) {
522         my $module = $1 || $6;
523         my $string = $3 || $5;
524         print "Found filter >>>$string<<<\n" if $debug;
525         substr $line, $LAST_MATCH_START[1], $LAST_MATCH_END[0] - $LAST_MATCH_START[0], '';
526
527         $string                         = unescape_template_string($string);
528         $cached{$file}{all}{$string}    = 1;
529         $cached{$file}{html}{$string}   = 1;
530         $cached{$file}{submit}{$string} = 1 if $PREMATCH =~ /$submitsearch/;
531         $plugins{needed}->{T8}          = 1 if $module eq '$T8';
532         $plugins{needed}->{LxERP}       = 1 if $module eq 'LxERP.t8';
533       }
534
535       while ($line =~ m/\[\%          # Template-Start-Tag
536                         [\-~#]?       # Whitespace-Unterdrückung
537                         \s*           # Optional beliebig viele Whitespace
538                         (?:           # Die erkannten Template-Direktiven
539                           PROCESS
540                         |
541                           INCLUDE
542                         )
543                         \s+           # Mindestens ein Whitespace
544                         [\'\"]?       # Anfang des Dateinamens
545                         ([^\s]+)      # Beliebig viele Nicht-Whitespaces -- Dateiname
546                         \.html        # Endung ".html", ansonsten kann es der Name eines Blocks sein
547                        /ix) {
548         my $new_file_name = "$basedir/templates/webpages/$1.html";
549         $cached{$file}{scanh}{$new_file_name} = 1;
550         substr $line, $LAST_MATCH_START[1], $LAST_MATCH_END[0] - $LAST_MATCH_START[0], '';
551       }
552     }
553
554     close(IN);
555
556     foreach my $plugin (keys %{ $plugins{needed} }) {
557       next if ($plugins{loaded}->{$plugin});
558       print "E: " . strip_base($file) . " requires the Template plugin '$plugin', but is not loaded with '[\% USE $plugin \%]'.\n";
559     }
560   }
561
562   # copy back into global arrays
563   $alllocales{$_} = 1            for keys %{$cached{$file}{all}};
564   $locale{$_}     = 1            for keys %{$cached{$file}{html}};
565   $submit{$_}     = 1            for keys %{$cached{$file}{submit}};
566
567   scanhtmlfile($_)               for keys %{$cached{$file}{scanh}};
568
569   $referenced_html_files{$_} = 1 for keys %{$cached{$file}{scanh}};
570 }
571
572 sub search_unused_htmlfiles {
573   my @unscanned_dirs = ('../../templates/webpages');
574
575   while (scalar @unscanned_dirs) {
576     my $dir = shift @unscanned_dirs;
577
578     foreach my $entry (<$dir/*>) {
579       if (-d $entry) {
580         push @unscanned_dirs, $entry;
581
582       } elsif (($entry =~ /_master.html$/) && -f $entry && !$referenced_html_files{$entry}) {
583         print "W: unused HTML template: " . strip_base($entry) . "\n";
584
585       }
586     }
587   }
588 }
589
590 sub strip_base {
591   my $s =  "$_[0]";             # Create a copy of the string.
592
593   $s    =~ s|^../../||;
594   $s    =~ s|templates/webpages/||;
595
596   return $s;
597 }
598
599 sub _single_quote {
600   my $val = shift;
601   $val =~ s/(\'|\\$)/\\$1/g;
602   return  "'" . $val .  "'";
603 }
604
605 sub _print_line {
606   my $key      = _single_quote(shift);
607   my $text     = _single_quote(shift);
608   my %params   = @_;
609   my $template = $params{template} || qq|  %-29s => %s,\n|;
610   my $fh       = $params{fh}       || croak 'need filehandle in _print_line';
611
612   print $fh sprintf $template, $key, $text;
613 }
614
615 sub generate_file {
616   my %params = @_;
617
618   my $file      = $params{file}   || croak 'need filename in generate_file';
619   my $header    = $params{header};
620   my $lines     = $params{data_sub};
621   my $data_name = $params{data_name};
622   my @delim     = split //, ($params{delim} || '{}');
623
624   open my $fh, '>:encoding(utf8)', $file or die "$! : $file";
625
626   $charset =~ s/\r?\n//g;
627   my $emacs_charset = lc $charset;
628
629   print $fh "#!/usr/bin/perl\n# -*- coding: $emacs_charset; -*-\n# vim: fenc=$charset\n\nuse utf8;\n\n";
630   print $fh $header, "\n" if $header;
631   print $fh "$data_name = $delim[0]\n" if $data_name;
632
633   $lines->(fh => $fh);
634
635   print $fh qq|$delim[1];\n\n1;\n|;
636   close $fh;
637 }
638
639 sub slurp {
640   my $file = shift;
641   do { local ( @ARGV, $/ ) = $file; <> }
642 }
643
644 __END__
645
646 =head1 NAME
647
648 locales.pl - Collect strings for translation in kivitendo
649
650 =head1 SYNOPSIS
651
652 locales.pl [options] lang_code
653
654  Options:
655   -n, --no-custom-files  Do not process files whose name contains "_"
656   -c, --check-files      Run extended checks on HTML files
657   -v, --verbose          Be more verbose
658   -h, --help             Show this help
659
660 =head1 OPTIONS
661
662 =over 8
663
664 =item B<-n>, B<--no-custom-files>
665
666 Do not process files whose name contains "_", e.g. "custom_io.pl".
667
668 =item B<-c>, B<--check-files>
669
670 Run extended checks on the usage of templates. This can be used to
671 discover HTML templates that are never used as well as the usage of
672 non-existing HTML templates.
673
674 =item B<-v>, B<--verbose>
675
676 Be more verbose.
677
678 =back
679
680 =head1 DESCRIPTION
681
682 This script collects strings from Perl files, the menu.ini file and
683 HTML templates and puts them into the file "all" for translation.
684
685 =cut