summaryrefslogtreecommitdiff
path: root/perl/Locale/Po4a/Text.pm
blob: 8f703c894d17d335f9d3318775cebb030a9fc196 (plain)
  1. #!/usr/bin/perl -w
  2. # Po4a::Text.pm
  3. # extract and translate translatable strings from a text documents
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc.,
  18. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19. #
  20. ########################################################################
  21. =encoding UTF-8
  22. =head1 NAME
  23. Locale::Po4a::Text - convert text documents from/to PO files
  24. =head1 DESCRIPTION
  25. The po4a (PO for anything) project goal is to ease translations (and more
  26. interestingly, the maintenance of translations) using gettext tools on
  27. areas where they were not expected like documentation.
  28. Locale::Po4a::Text is a module to help the translation of text documents into
  29. other [human] languages.
  30. Paragraphs are split on empty lines (or lines containing only spaces or
  31. tabulations).
  32. If a paragraph contains a line starting by a space (or tabulation), this
  33. paragraph won't be rewrapped.
  34. =cut
  35. package Locale::Po4a::Text;
  36. use 5.006;
  37. use strict;
  38. use warnings;
  39. require Exporter;
  40. use vars qw(@ISA @EXPORT);
  41. @ISA = qw(Locale::Po4a::TransTractor);
  42. @EXPORT qw();
  43. use Locale::Po4a::TransTractor;
  44. use Locale::Po4a::Common;
  45. =head1 OPTIONS ACCEPTED BY THIS MODULE
  46. These are this module's particular options:
  47. =over
  48. =item B<nobullets>
  49. Deactivate detection of bullets.
  50. By default, when a bullet is detected, the bullet paragraph is not considered
  51. as a verbatim paragraph (with the no-wrap flag in the PO file), but the module
  52. rewrap this paragraph in the generated PO file and in the translation.
  53. =cut
  54. my $bullets 1;
  55. =item B<tabs>=I<mode>
  56. Specify how tabulations shall be handled. The I<mode> can be any of:
  57. =over
  58. =item B<split>
  59. Lines with tabulations introduce breaks in the current paragraph.
  60. =item B<verbatim>
  61. Paragraph containing tabulations will not be re-wrapped.
  62. =back
  63. By default, tabulations are considered as spaces.
  64. =cut
  65. my $tabs "";
  66. =item B<breaks>=I<regex>
  67. A regular expression matching lines which introduce breaks.
  68. The regular expression will be anchored so that the whole line must match.
  69. =cut
  70. my $breaks;
  71. =item B<debianchangelog>
  72. Handle the header and footer of
  73. released versions, which only contain non translatable informations.
  74. =cut
  75. my $debianchangelog 0;
  76. =item B<fortunes>
  77. Handle the fortunes format, which separate fortunes with a line which
  78. consists in '%' or '%%', and use '%%' as the beginning of a comment.
  79. =cut
  80. my $fortunes 0;
  81. =item B<markdown>
  82. Handle some special markup in Markdown-formatted texts.
  83. =cut
  84. my $markdown 0;
  85. =item B<asciidoc>
  86. Handle documents in the asciidoc format.
  87. =cut
  88. my $asciidoc 0;
  89. =back
  90. =cut
  91. sub initialize {
  92.     my $self shift;
  93.     my %options @_;
  94.     $self->{options}{'asciidoc'} = 1;
  95.     $self->{options}{'breaks'} = 1;
  96.     $self->{options}{'debianchangelog'} = 1;
  97.     $self->{options}{'debug'} = 1;
  98.     $self->{options}{'fortunes'} = 1;
  99.     $self->{options}{'markdown'} = 1;
  100.     $self->{options}{'nobullets'} = 1;
  101.     $self->{options}{'tabs'} = 1;
  102.     $self->{options}{'verbose'} = 1;
  103.     foreach my $opt (keys %options) {
  104.         die wrap_mod("po4a::text",
  105.                      dgettext("po4a""Unknown option: %s"), $opt)
  106.             unless exists $self->{options}{$opt};
  107.         $self->{options}{$opt} = $options{$opt};
  108.     }
  109.     if (defined $options{'nobullets'}) {
  110.         $bullets 0;
  111.     }
  112.     if (defined $options{'tabs'}) {
  113.         $tabs $options{'tabs'};
  114.     }
  115.     if (defined $options{'breaks'}) {
  116.         $breaks $options{'breaks'};
  117.     }
  118.     if (defined $options{'debianchangelog'}) {
  119.         $debianchangelog=1;
  120.     }
  121.     if (defined $options{'fortunes'}) {
  122.         $fortunes=1;
  123.     }
  124.     if (defined $options{'markdown'}) {
  125.         $markdown=1;
  126.     }
  127.     $asciidoc=if (defined $options{'asciidoc'});
  128. }
  129. sub parse {
  130.     my $self shift;
  131.     my ($line,$ref);
  132.     my $paragraph="";
  133.     my $wrapped_mode 1;
  134.     my $expect_header 1;
  135.     my $end_of_paragraph 0;
  136.     ($line,$ref)=$self->shiftline();
  137.     my $file $ref;
  138.     $file =~ s/:[0-9]+$// if defined($line);
  139.     while (defined($line)) {
  140.         $ref =~ m/^(.*):[0-9]+$/;
  141.         if ($1 ne $file) {
  142.             $file $1;
  143.             do_paragraph($self,$paragraph,$wrapped_mode);
  144.             $paragraph="";
  145.             $wrapped_mode 1;
  146.             $expect_header 1;
  147.         }
  148.         chomp($line);
  149.         $self->{ref}="$ref";
  150.         if ($debianchangelog and
  151.             $expect_header and
  152.             $line =~ /^(\w[-+0-9a-z.]*)\ \(([^\(\\t]+)\# src, version
  153.                        \s+([-+0-9a-z.]+);                 # distribution
  154.                        \s*urgency\s*\=\s*(.*\S)\s*$/ix) { #
  155.             do_paragraph($self,$paragraph,$wrapped_mode);
  156.             $paragraph="";
  157.             $self->pushline("$line\n");
  158.             $expect_header=0;
  159.         elsif ($debianchangelog and
  160.                  $line =~ m/^ \-\- (.*) <(.*)> ((\w+\,\s*)?\d{1,2}\s+\w+\s+\d{4}\s+\d{1,2}:\d\d:\d\d\s+[-+]\d{4}(\s+\([^\\\(\)]\))?)$/) {
  161.             # Found trailer
  162.             do_paragraph($self,$paragraph,$wrapped_mode);
  163.             $paragraph="";
  164.             $self->pushline("$line\n");
  165.             $expect_header=1;
  166.         elsif ($fortunes and
  167.                  $line =~ m/^%%?\s*$/) {
  168.             # Found end of fortune
  169.             do_paragraph($self,$paragraph,$wrapped_mode);
  170.             $self->pushline("\n"unless (   $wrapped_mode == 0
  171.                                           or $paragraph eq "");
  172.             $paragraph="";
  173.             $wrapped_mode 1;
  174.             $self->pushline("$line\n");
  175.         elsif (    (defined $self->{verbatim})
  176.                  and ($self->{verbatim} == 2)) {
  177.             # Untranslated blocks
  178.             $self->pushline($line."\n");
  179.             if ($asciidoc and
  180.                 ($line =~ m/^(\/{4,}|~{4,})$/)) {
  181.                 undef $self->{verbatim};
  182.                 undef $self->{type};
  183.                 $wrapped_mode 1;
  184.             }
  185.         elsif (   ($line =~ /^\s*$/)
  186.                  or (    defined $breaks
  187.                      and $line =~ m/^$breaks$/)) {
  188.             # Break paragraphs on lines containing only spaces
  189.             do_paragraph($self,$paragraph,$wrapped_mode);
  190.             $paragraph="";
  191.             $wrapped_mode unless defined($self->{verbatim});
  192.             $self->pushline($line."\n");
  193.         elsif ($asciidoc and (not defined($self->{verbatim})) and
  194.                  ($line =~ m/^(\+|--)$/)) {
  195.             # List Item Continuation or List Block
  196.             do_paragraph($self,$paragraph,$wrapped_mode);
  197.             $paragraph="";
  198.             $self->pushline($line."\n");
  199.         elsif ($asciidoc and (not defined($self->{verbatim})) and
  200.                  ($line =~ m/^(={4,}|-{4,}|~{4,}|\^{4,}|\+{4,})$/and
  201.                  (defined($paragraph) )and
  202.                  ($paragraph =~ m/^[^\n]*\n$/sand
  203.                  (length($paragraph) == (length($line)+1))) {
  204.             # Found title
  205.             $wrapped_mode 0;
  206.             my $level $line;
  207.             $level =~ s/^(.).*$/$1/;
  208.             my $t $self->translate($paragraph,
  209.                                      $self->{ref},
  210.                                      "Title $level",
  211.                                      "wrap" => 0);
  212.             $self->pushline($t);
  213.             $paragraph="";
  214.             $wrapped_mode 1;
  215.             $self->pushline(($level (length($t)-1))."\n");
  216.         elsif ($asciidoc and
  217.                  ($line =~ m/^(={1,5})( +)(.*?)( +\1)?$/)) {
  218.             my $titlelevel1 $1;
  219.             my $titlespaces $2;
  220.             my $title $3;
  221.             my $titlelevel2 $4||"";
  222.             # Found one line title
  223.             do_paragraph($self,$paragraph,$wrapped_mode);
  224.             $wrapped_mode 0;
  225.             $paragraph="";
  226.             my $t $self->translate($title,
  227.                                      $self->{ref},
  228.                                      "Title $titlelevel1",
  229.                                      "wrap" => 0);
  230.             $self->pushline($titlelevel1.$titlespaces.$t.$titlelevel2."\n");
  231.             $wrapped_mode 1;
  232.         elsif ($asciidoc and
  233.                  ($line =~ m/^(\/{4,}|\+{4,}|-{4,}|\.{4,}|\*{4,}|_{4,}|={4,}|~{4,})$/)) {
  234.             # Found one delimited block
  235.             my $t $line;
  236.             $t =~ s/^(.).*$/$1/;
  237.             my $type "delimited block $t";
  238.             if (defined $self->{verbatimand ($self->{typene $type)) {
  239.                 $paragraph .= "$line\n";
  240.             else {
  241.             do_paragraph($self,$paragraph,$wrapped_mode);
  242.             if (    (defined $self->{type})
  243.                 and ($self->{type