[Summary view] [Print] [Text view]

   1  package Locale::Maketext;
   2  use strict;
   3  use vars qw( @ISA $VERSION $MATCH_SUPERS $USING_LANGUAGE_TAGS
   4  $USE_LITERALS $MATCH_SUPERS_TIGHTLY);
   5  use Carp ();
   6  use I18N::LangTags 0.30 ();
   7  
   8  #--------------------------------------------------------------------------
   9  
  10  BEGIN { unless(defined &DEBUG) { *DEBUG = sub () {0} } }
  11  # define the constant 'DEBUG' at compile-time
  12  
  13  $VERSION = '1.12';
  14  @ISA = ();
  15  
  16  $MATCH_SUPERS = 1;
  17  $MATCH_SUPERS_TIGHTLY = 1;
  18  $USING_LANGUAGE_TAGS  = 1;
  19  # Turning this off is somewhat of a security risk in that little or no
  20  # checking will be done on the legality of tokens passed to the
  21  # eval("use $module_name") in _try_use.  If you turn this off, you have
  22  # to do your own taint checking.
  23  
  24  $USE_LITERALS = 1 unless defined $USE_LITERALS;
  25  # a hint for compiling bracket-notation things.
  26  
  27  my %isa_scan = ();
  28  
  29  ###########################################################################
  30  
  31  sub quant {
  32      my($handle, $num, @forms) = @_;
  33  
  34      return $num if @forms == 0; # what should this mean?
  35      return $forms[2] if @forms > 2 and $num == 0; # special zeroth case
  36  
  37      # Normal case:
  38      # Note that the formatting of $num is preserved.
  39      return( $handle->numf($num) . ' ' . $handle->numerate($num, @forms) );
  40      # Most human languages put the number phrase before the qualified phrase.
  41  }
  42  
  43  
  44  sub numerate {
  45      # return this lexical item in a form appropriate to this number
  46      my($handle, $num, @forms) = @_;
  47      my $s = ($num == 1);
  48  
  49      return '' unless @forms;
  50      if(@forms == 1) { # only the headword form specified
  51          return $s ? $forms[0] : ($forms[0] . 's'); # very cheap hack.
  52      }
  53      else { # sing and plural were specified
  54          return $s ? $forms[0] : $forms[1];
  55      }
  56  }
  57  
  58  #--------------------------------------------------------------------------
  59  
  60  sub numf {
  61      my($handle, $num) = @_[0,1];
  62      if($num < 10_000_000_000 and $num > -10_000_000_000 and $num == int($num)) {
  63          $num += 0;  # Just use normal integer stringification.
  64          # Specifically, don't let %G turn ten million into 1E+007
  65      }
  66      else {
  67          $num = CORE::sprintf('%G', $num);
  68          # "CORE::" is there to avoid confusion with the above sub sprintf.
  69      }
  70      while( $num =~ s/^([-+]?\d+)(\d{3})/$1,$2/s ) {1}  # right from perlfaq5
  71      # The initial \d+ gobbles as many digits as it can, and then we
  72      #  backtrack so it un-eats the rightmost three, and then we
  73      #  insert the comma there.
  74  
  75      $num =~ tr<.,><,.> if ref($handle) and $handle->{'numf_comma'};
  76      # This is just a lame hack instead of using Number::Format
  77      return $num;
  78  }
  79  
  80  sub sprintf {
  81      no integer;
  82      my($handle, $format, @params) = @_;
  83      return CORE::sprintf($format, @params);
  84      # "CORE::" is there to avoid confusion with myself!
  85  }
  86  
  87  #=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#
  88  
  89  use integer; # vroom vroom... applies to the whole rest of the module
  90  
  91  sub language_tag {
  92      my $it = ref($_[0]) || $_[0];
  93      return undef unless $it =~ m/([^':]+)(?:::)?$/s;
  94      $it = lc($1);
  95      $it =~ tr<_><->;
  96      return $it;
  97  }
  98  
  99  sub encoding {
 100      my $it = $_[0];
 101      return(
 102          (ref($it) && $it->{'encoding'})
 103          || 'iso-8859-1'   # Latin-1
 104      );
 105  }
 106  
 107  #--------------------------------------------------------------------------
 108  
 109  sub fallback_languages { return('i-default', 'en', 'en-US') }
 110  
 111  sub fallback_language_classes { return () }
 112  
 113  #--------------------------------------------------------------------------
 114  
 115  sub fail_with { # an actual attribute method!
 116      my($handle, @params) = @_;
 117      return unless ref($handle);
 118      $handle->{'fail'} = $params[0] if @params;
 119      return $handle->{'fail'};
 120  }
 121  
 122  #--------------------------------------------------------------------------
 123  
 124  sub failure_handler_auto {
 125      # Meant to be used like:
 126      #  $handle->fail_with('failure_handler_auto')
 127  
 128      my $handle = shift;
 129      my $phrase = shift;
 130  
 131      $handle->{'failure_lex'} ||= {};
 132      my $lex = $handle->{'failure_lex'};
 133  
 134      my $value;
 135      $lex->{$phrase} ||= ($value = $handle->_compile($phrase));
 136  
 137      # Dumbly copied from sub maketext:
 138      return ${$value} if ref($value) eq 'SCALAR';
 139      return $value    if ref($value) ne 'CODE';
 140      {
 141          local $SIG{'__DIE__'};
 142          eval { $value = &$value($handle, @_) };
 143      }
 144      # If we make it here, there was an exception thrown in the
 145      #  call to $value, and so scream:
 146      if($@) {
 147          my $err = $@;
 148          # pretty up the error message
 149          $err =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?}
 150                   {\n in bracket code [compiled line $1],}s;
 151          #$err =~ s/\n?$/\n/s;
 152          Carp::croak "Error in maketexting \"$phrase\":\n$err as used";
 153          # Rather unexpected, but suppose that the sub tried calling
 154          # a method that didn't exist.
 155      }
 156      else {
 157          return $value;
 158      }
 159  }
 160  
 161  #==========================================================================
 162  
 163  sub new {
 164      # Nothing fancy!
 165      my $class = ref($_[0]) || $_[0];
 166      my $handle = bless {}, $class;
 167      $handle->init;
 168      return $handle;
 169  }
 170  
 171  sub init { return } # no-op
 172  
 173  ###########################################################################
 174  
 175  sub maketext {
 176      # Remember, this can fail.  Failure is controllable many ways.
 177      Carp::croak 'maketext requires at least one parameter' unless @_ > 1;
 178  
 179      my($handle, $phrase) = splice(@_,0,2);
 180      Carp::confess('No handle/phrase') unless (defined($handle) && defined($phrase));
 181  
 182  
 183      # Don't interefere with $@ in case that's being interpolated into the msg.
 184      local $@;
 185  
 186      # Look up the value:
 187  
 188      my $value;
 189      foreach my $h_r (
 190          @{  $isa_scan{ref($handle) || $handle} || $handle->_lex_refs  }
 191      ) {
 192          DEBUG and print "* Looking up \"$phrase\" in $h_r\n";
 193          if(exists $h_r->{$phrase}) {
 194              DEBUG and print "  Found \"$phrase\" in $h_r\n";
 195              unless(ref($value = $h_r->{$phrase})) {
 196                  # Nonref means it's not yet compiled.  Compile and replace.
 197                  $value = $h_r->{$phrase} = $handle->_compile($value);
 198              }
 199              last;
 200          }
 201          elsif($phrase !~ m/^_/s and $h_r->{'_AUTO'}) {
 202              # it's an auto lex, and this is an autoable key!
 203              DEBUG and print "  Automaking \"$phrase\" into $h_r\n";
 204  
 205              $value = $h_r->{$phrase} = $handle->_compile($phrase);
 206              last;
 207          }
 208          DEBUG>1 and print "  Not found in $h_r, nor automakable\n";
 209          # else keep looking
 210      }
 211  
 212      unless(defined($value)) {
 213          DEBUG and print "! Lookup of \"$phrase\" in/under ", ref($handle) || $handle, " fails.\n";
 214          if(ref($handle) and $handle->{'fail'}) {
 215              DEBUG and print "WARNING0: maketext fails looking for <$phrase>\n";
 216              my $fail;
 217              if(ref($fail = $handle->{'fail'}) eq 'CODE') { # it's a sub reference
 218                  return &{$fail}($handle, $phrase, @_);
 219                  # If it ever returns, it should return a good value.
 220              }
 221              else { # It's a method name
 222                  return $handle->$fail($phrase, @_);
 223                  # If it ever returns, it should return a good value.
 224              }
 225          }
 226          else {
 227              # All we know how to do is this;
 228              Carp::croak("maketext doesn't know how to say:\n$phrase\nas needed");
 229          }
 230      }
 231  
 232      return $$value if ref($value) eq 'SCALAR';
 233      return $value unless ref($value) eq 'CODE';
 234  
 235      {
 236          local $SIG{'__DIE__'};
 237          eval { $value = &$value($handle, @_) };
 238      }
 239      # If we make it here, there was an exception thrown in the
 240      #  call to $value, and so scream:
 241      if ($@) {
 242          my $err = $@;
 243          # pretty up the error message
 244          $err =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?}
 245                   {\n in bracket code [compiled line $1],}s;
 246          #$err =~ s/\n?$/\n/s;
 247          Carp::croak "Error in maketexting \"$phrase\":\n$err as used";
 248          # Rather unexpected, but suppose that the sub tried calling
 249          # a method that didn't exist.
 250      }
 251      else {
 252          return $value;
 253      }
 254  }
 255  
 256  ###########################################################################
 257  
 258  sub get_handle {  # This is a constructor and, yes, it CAN FAIL.
 259      # Its class argument has to be the base class for the current
 260      # application's l10n files.
 261  
 262      my($base_class, @languages) = @_;
 263      $base_class = ref($base_class) || $base_class;
 264      # Complain if they use __PACKAGE__ as a project base class?
 265  
 266      if( @languages ) {
 267          DEBUG and print 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 268          if($USING_LANGUAGE_TAGS) {   # An explicit language-list was given!
 269              @languages =
 270              map {; $_, I18N::LangTags::alternate_language_tags($_) }
 271              # Catch alternation
 272              map I18N::LangTags::locale2language_tag($_),
 273              # If it's a lg tag, fine, pass thru (untainted)
 274              # If it's a locale ID, try converting to a lg tag (untainted),
 275              # otherwise nix it.
 276              @languages;
 277              DEBUG and print 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 278          }
 279      }
 280      else {
 281          @languages = $base_class->_ambient_langprefs;
 282      }
 283  
 284      @languages = $base_class->_langtag_munging(@languages);
 285  
 286      my %seen;
 287      foreach my $module_name ( map { $base_class . '::' . $_ }  @languages ) {
 288          next unless length $module_name; # sanity
 289          next if $seen{$module_name}++        # Already been here, and it was no-go
 290          || !&_try_use($module_name); # Try to use() it, but can't it.
 291          return($module_name->new); # Make it!
 292      }
 293  
 294      return undef; # Fail!
 295  }
 296  
 297  ###########################################################################
 298  
 299  sub _langtag_munging {
 300      my($base_class, @languages) = @_;
 301  
 302      # We have all these DEBUG statements because otherwise it's hard as hell
 303      # to diagnose ifwhen something goes wrong.
 304  
 305      DEBUG and print 'Lgs1: ', map("<$_>", @languages), "\n";
 306  
 307      if($USING_LANGUAGE_TAGS) {
 308          DEBUG and print 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 309          @languages     = $base_class->_add_supers( @languages );
 310  
 311          push @languages, I18N::LangTags::panic_languages(@languages);
 312          DEBUG and print "After adding panic languages:\n",
 313          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 314  
 315          push @languages, $base_class->fallback_languages;
 316          # You are free to override fallback_languages to return empty-list!
 317          DEBUG and print 'Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 318  
 319          @languages =  # final bit of processing to turn them into classname things
 320          map {
 321              my $it = $_;  # copy
 322              $it =~ tr<-A-Z><_a-z>; # lc, and turn - to _
 323              $it =~ tr<_a-z0-9><>cd;  # remove all but a-z0-9_
 324              $it;
 325          } @languages
 326          ;
 327          DEBUG and print "Nearing end of munging:\n",
 328          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 329      }
 330      else {
 331          DEBUG and print "Bypassing language-tags.\n",
 332          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 333      }
 334  
 335      DEBUG and print "Before adding fallback classes:\n",
 336      ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 337  
 338      push @languages, $base_class->fallback_language_classes;
 339      # You are free to override that to return whatever.
 340  
 341      DEBUG and print "Finally:\n",
 342      ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 343  
 344      return @languages;
 345  }
 346  
 347  ###########################################################################
 348  
 349  sub _ambient_langprefs {
 350      require I18N::LangTags::Detect;
 351      return  I18N::LangTags::Detect::detect();
 352  }
 353  
 354  ###########################################################################
 355  
 356  sub _add_supers {
 357      my($base_class, @languages) = @_;
 358  
 359      if (!$MATCH_SUPERS) {
 360          # Nothing
 361          DEBUG and print "Bypassing any super-matching.\n",
 362          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 363  
 364      }
 365      elsif( $MATCH_SUPERS_TIGHTLY ) {
 366          DEBUG and print "Before adding new supers tightly:\n",
 367          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 368          @languages = I18N::LangTags::implicate_supers( @languages );
 369          DEBUG and print "After adding new supers tightly:\n",
 370          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 371  
 372      }
 373      else {
 374          DEBUG and print "Before adding supers to end:\n",
 375          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 376          @languages = I18N::LangTags::implicate_supers_strictly( @languages );
 377          DEBUG and print "After adding supers to end:\n",
 378          ' Lgs@', __LINE__, ': ', map("<$_>", @languages), "\n";
 379      }
 380  
 381      return @languages;
 382  }
 383  
 384  ###########################################################################
 385  #
 386  # This is where most people should stop reading.
 387  #
 388  ###########################################################################
 389  
 390  use Locale::Maketext::GutsLoader;
 391  
 392  ###########################################################################
 393  
 394  my %tried = ();
 395  # memoization of whether we've used this module, or found it unusable.
 396  
 397  sub _try_use {   # Basically a wrapper around "require Modulename"
 398      # "Many men have tried..."  "They tried and failed?"  "They tried and died."
 399      return $tried{$_[0]} if exists $tried{$_[0]};  # memoization
 400  
 401      my $module = $_[0];   # ASSUME sane module name!
 402      { no strict 'refs';
 403          return($tried{$module} = 1)
 404          if defined(%{$module . '::Lexicon'}) or defined(@{$module . '::ISA'});
 405          # weird case: we never use'd it, but there it is!
 406      }
 407  
 408      DEBUG and print " About to use $module ...\n";
 409      {
 410          local $SIG{'__DIE__'};
 411          eval "require $module"; # used to be "use $module", but no point in that.
 412      }
 413      if($@) {
 414          DEBUG and print "Error using $module \: $@\n";
 415          return $tried{$module} = 0;
 416      }
 417      else {
 418          DEBUG and print " OK, $module is used\n";
 419          return $tried{$module} = 1;
 420      }
 421  }
 422  
 423  #--------------------------------------------------------------------------
 424  
 425  sub _lex_refs {  # report the lexicon references for this handle's class
 426      # returns an arrayREF!
 427      no strict 'refs';
 428      no warnings 'once';
 429      my $class = ref($_[0]) || $_[0];
 430      DEBUG and print "Lex refs lookup on $class\n";
 431      return $isa_scan{$class} if exists $isa_scan{$class};  # memoization!
 432  
 433      my @lex_refs;
 434      my $seen_r = ref($_[1]) ? $_[1] : {};
 435  
 436      if( defined( *{$class . '::Lexicon'}{'HASH'} )) {
 437          push @lex_refs, *{$class . '::Lexicon'}{'HASH'};
 438          DEBUG and print '%' . $class . '::Lexicon contains ',
 439              scalar(keys %{$class . '::Lexicon'}), " entries\n";
 440      }
 441  
 442      # Implements depth(height?)-first recursive searching of superclasses.
 443      # In hindsight, I suppose I could have just used Class::ISA!
 444      foreach my $superclass (@{$class . '::ISA'}) {
 445          DEBUG and print " Super-class search into $superclass\n";
 446          next if $seen_r->{$superclass}++;
 447          push @lex_refs, @{&_lex_refs($superclass, $seen_r)};  # call myself
 448      }
 449  
 450      $isa_scan{$class} = \@lex_refs; # save for next time
 451      return \@lex_refs;
 452  }
 453  
 454  sub clear_isa_scan { %isa_scan = (); return; } # end on a note of simplicity!
 455  
 456  1;