Free locale software for linux

DateTime::Locale is a Perl module with localization support for DateTime.pm.

SYNOPSIS

use DateTime::Locale;

my $loc = DateTime::Locale->load(en_GB);

print $loc->native_locale_name, "n",
$loc->long_datetime_format, "n";

# but mostly just things like ...

my $dt = DateTime->now( locale => fr );
print "Aujourdhui le mois est " . $dt->month_name, "n":

DateTime::Locale is primarily a factory for the various locale subclasses. It also provides some functions for getting information on available locales.

If you want to know what methods are available for locale objects, then please read the DateTime::Locale::Base documentation.

Locale::Framework is a Perl module for internationalization.

SYNOPSIS

use Locale::Framework;
use Locale::Framework::SQL;

Locale::Framework::init(new Locale::Framework::SQL(
DSN => "dbi:Pg:dbname=zclass;host=localhost",
DBUSER => "test",
DBPASS => "testpass",
[TABLE => "testtrans"]));

print _T("This is a test");

Locale::Framework::language("nl_NL");

print _T("This is a test");
Alternative interface (using wxLocale backend as an example), which does exactly the same. There is no local object scope, theres only a global class (or program that is) scope. OO interface is only for conveniance.
use Locale::Framework;
use Locale::Framework::wxLocale;

my $LOC=new Locale::Framework;

$LOC->init(new Locale::Framework::wxLocale("./locale","test"));

print _T("This is a test");
$LOC->language("nl_NL");
print _T("This is a test");

ABSTRACT

This module provides simple string based internationalization support. It exports a _T function that can be used for all text that need displayed. It can work with different backends, e.g. SQL or file based backends. The backend defaults to Locale::Framework::Dumb, which doesnt translate at all.

Locale::TextDomain is a Perl Interface to Uniforum Message Translation.

SYNOPSIS

use Locale::TextDomain (my-package, @locale_dirs);

use Locale::TextDomain qw (my-package);

my $translated = __"Hello World!n";

my $alt = $__{"Hello World!n"};

my $alt2 = $__->{"Hello World!n"};

my @list = (N__"Hello", N__"World");

my @plurals = (N__ ("One world", "{num} worlds"),
N__ ("1 file", "%d files"));

my $question = __x ("Error reading file {file}: {err}",
file => $file, err => $!);

printf (__n ("one file read",
"%d files read",
$num_files),
$num_files);

print __nx ("one file read", "{num} files read", $num_files,
num => $num_files);

The module Locale::TextDomain(3pm) provides a high-level interface to Perl message translation.

Textdomains

When your request a translation for a given string, the system used in libintl-perl follows a standard strategy to find a suitable message catalog containing the translation: Unless you explicitely define a name for the message catalog, libintl-perl will assume that your catalog is called messages (unless you have changed the default value to something else via Locale::Messages(3pm), method textdomain()).
You might think that his default strategy leaves room for optimization and you are right. It would be a lot smarter if multiple software packages, all with their individual message catalogs, could be installed on one system, and it should also be possible that third-party components of your software (like Perl modules) can load their message catalogs, too, without interfering with yours.

The solution is clear, you have to assign a unique name to your message database, and you have to specify that name at run-time. That unique name is the so-called textdomain of your software package. The name is actually arbitrary but you should follow these best-practice guidelines to ensure maximum interoperability:

File System Safety

In practice, textdomains get mapped into file names, and you should therefore make sure that the textdomain you choose is a valid filename on every system that will run your software.

Case-sensitivity

Textdomains are always case-sensitive (i. e. Package and PACKAGE are not the same). However, since the message catalogs will be stored on file systems, that may or may not distinguish case when looking up file names, you should avoid potential conflicts here.

Textdomain Should Match CPAN Name

If your software is listed as a module on CPAN, you should simply choose the name on CPANS as your textdomain. The textdomain for libintl-perl is hence libintl-perl. But please replace all periods (.) in your package name with an underscore because ...

Internet Domain Names as a Fallback

... if your software is not a module listed on CPAN, as a last resort you should use the Java(tm) package scheme, i. e. choose an internet domain that you are owner of (or ask the owner of an internet domain) and concatenate your preferred textdomain with the reversed internet domain. Example: Your company runs the web-site www.foobar.org and is the owner of the domain foobar.org. The textdomain for your companys software barfoos should hence be org.foobar.barfoos.

If your software is likely to be installed in different versions on the same system, it is probably a good idea to append some version information to your textdomain.
Other systems are less strict with the naming scheme for textdomains but the phenomena known as Perl is actually a plethora of small, specialized modules and it is probably wisest to postulate some namespace model in order to avoid chaos.

Binding textdomains to directories

Once the system knows the textdomain of the message that you want to get translated into the users language, it still has to find the correct message catalog. By default, libintl-perl will look up the string in the translation database found in the directories /usr/share/locale and /usr/local/share/locale (in that order).

It is neither guaranteed that these directories exist on the target machine, nor can you be sure that the installation routine has write access to these locations. You can therefore instruct libintl-perl to search other directories prior to the default directories. Specifying a differnt search directory is called binding a textdomain to a directory.

Locale::TextDomain extends the default strategy by a Perl specific approach. Unless told otherwise, it will look for a directory LocaleData in every component found in the standard include path @INC and check for a database containing the message for your textdomain there. Example: If the path /usr/lib/perl/5.8.0/site_perl is in your @INC, you can install your translation files in /usr/lib/perl/5.8.0/site_perl/LocaleData, and they will be found at run-time.

Locale::Maketext::Fuzzy is a Perl module for Maketext from already interpolated strings.

SYNOPSIS

package MyApp::L10N;
use base Locale::Maketext::Fuzzy; # instead of Locale::Maketext

package MyApp::L10N::de;
use base MyApp::L10N;
our %Lexicon = (
# Exact match should always be preferred if possible
"0 camels were released."
=> "Exact match",

# Fuzzy match candidate
"[quant,_1,camel was,camels were] released."
=> "[quant,_1,Kamel wurde,Kamele wurden] freigegeben.",

# This could also match fuzzily, but is less preferred
"[_2] released[_1]"
=> "[_1][_2] ist frei[_1]",
);

package main;
my $lh = MyApp::L10N->get_handle(de);

# All ->maketext calls below will become ->maketext_fuzzy instead
$lh->override_maketext(1);

# This prints "Exact match"
print $lh->maketext(0 camels were released.);

# "1 Kamel wurde freigegeben." -- quant() gets 1
print $lh->maketext(1 camel was released.);

# "2 Kamele wurden freigegeben." -- quant() gets 2
print $lh->maketext(2 camels were released.);

# "3 Kamele wurden freigegeben." -- parameters are ignored
print $lh->maketext(3 released.);

# "4 Kamele wurden freigegeben." -- normal usage
print $lh->maketext([*,_1,camel was,camels were] released., 4);

# "!Perl ist frei!" -- matches the broader one
# Note that the sequence ([_2] before [_1]) is preserved
print $lh->maketext(Perl released!);

Locale::Maketext::Extract::Run is a Perl module interface to xgettext.pl.

SYNOPSIS

use Locale::Maketext::Extract::Run xgettext;
xgettext(@ARGV);

Locale::RecodeData::IBM918 are conversion routines for IBM918.

SYNOPSIS

This module is internal to libintl. Do not use directly!

This module is generated and contains the conversion tables and routines for IBM918.

COMMENTS

The following comments have been extracted from the original charmap:

version: 1.0
source: IBM NLS RM Vol2 SE09-8002-01, March 1990
alias CP918
alias EBCDIC-CP-AR2

Please note that aliases listed above are not necessarily valid!

Locale::Object::Language Perl module contains language information objects.

Locale::Object::Language allows you to create objects containing information about languages such as their ISO codes, the countries theyre used in and so on.

SYNOPSIS

use Locale::Object::Language;

my $eng = Locale::Object::Language->new( code_alpha3 => eng );

my $name = $eng->name;
my $code_alpha2 = $eng->code_alpha2;
my $code_alpha3 = $eng->code_alpha3;

my @countries = $eng->countries;

my $gb = Locale::Object::Country->new( code_alpha2 => gb );

print $eng->official($gb);

METHODS

new()

my $eng = Locale::Object::Language->new( code_alpha3 => eng );

The new method creates an object. It takes a single-item hash as an argument - valid options to pass are ISO 3166 values - code_alpha2, code_alpha3 and name (see Locale::Object::DB::Schemata for details on these).
The objects created are singletons; if you try and create a currency object when one matching your specification already exists, new() will return the original one.

name(), code_alpha2(), code_alpha3()

my $name = $country->name;

These methods retrieve the values of the attributes in the object whose name they share.

countries()

my @countries = $eng->countries;

Returns an array (in array context, otherwise a reference) of Locale::Object::Country objects with their ISO 3166 alpha2 codes as keys (see Locale::Object::DB::Schemata for more details on those) for all countries using this currency in array context, or a reference in scalar context. The objects have their own attribute methods, so you can do things like this for example:

foreach my $place (@countries)
{
print $place->name, "n";
}

Which will list you all the countries that use in that currency. See the documentation for Locale::Object::Country for a listing of country attributes. Note that you can chain methods as well.

foreach my $place (@countries)
{
print $place->continent->name, "n";
}
official()
my $gb = Locale::Object::Country->new( code_alpha2 => gb );

print $eng->official($gb); # prints true

Give this method a Locale::Object::Country object, and it will return a true or false value for whether the country the object represents has the language represented by your Locale::Object::Language object as an official language. See database.pod for a note about languages in the database.