Astro-App-Satpass2
view release on metacpan or search on metacpan
for the tests that exposed this.
0.038 2019-03-13 T. R. Wyant
The 'model' setting is no longer ignored. It is now actually applied
to the TLE objects when loading them, and a change in value causes
all loaded TLEs to be modified as well.
Make ::TLE::Iridium optional.
0.037 2018-10-28 T. R. Wyant
Fix test failure in t/locale.t. I hope. Some of the CPAN testers
get errors like
do "t/locale/fu_BAR.pm" failed, '.' is no longer in @INC; did you
mean do "./t/locale/fu_BAR.pm"? at ...
gglib/Astro/App/Satpass2/Locale.pm line 210.
but I can't duplicate this, even under Perls that manifestly do not
have '.' or any facimile thereof in @INC.
0.036 2018-10-17 T. R. Wyant
Support alternate Sun and Moon classes, and other bodies that
contain built-in models (e.g. Astro::Coord::ECI::VSOP87D::*).
Add sky() settings to the output of save().
attribute.
0.027 2015-07-11 T. R. Wyant
This release should be functionally identical to 0.026, but was made
because I wanted a production release that superseded 0.026_01,
which was made due to a bad patch I developed for Date::Manip.
0.026 2015-06-26 T. R. Wyant
Change localization of equinoxes and solstices to take advantage of
the Astro::Coord::ECI southern hemisphere functionality. This
includes not only the default C locale but eg/es.pm.
Specify encoding UTF-8 for source files. This was always intended, but
never actually done.
Skip t/parse_time_date_manip_6.t if Date::Manip and DateTimeTimeZone
come up with different zones. This is because Date::Manip may not
default to the right zone under at least some BSD variants,
resulting in failing tests.
0.025 2015-03-29 T. R. Wyant
'gmt' (any case) into 'UT'.
0.024 2015-01-10 T. R. Wyant
Remove TomTom support.
As of January 5 2015, Geo::Coder::TomTom requires an API key. Since
I have not been supporting geocoders that require registration,
TomTom has been dropped. It has not worked since November 2014
anyway.
0.023 2014-11-17 T. R. Wyant
Address CPAN Testers failures in t/locale.t under the combination of
Perl 5.20.1 and MSWin32.
0.022 2014-11-08 T. R. Wyant
Remove all reference to the 'lit' attribute. This has been removed in
favor of 'edge_of_earths_shadow'.
Suspend support for geocoding via TomTom. It appears that TomTom has
retracted the undelying web service. Support in this package will be
retracted May 1 2015 unless the situation is resolved favorably
before then. If the situation is resolved unfavorably before then,
Remove subroutine Astro::App::Satpass2::Utils::fold_case(). This is
documented as private, but since is _was_ documented I decided to
put it through an abbreviated deprecation cycle.
Add add() method to Astro::App::Satpass2. This validates and adds TLE
objects.
Remove ::Format::Template::Provider from t/basic.t
Fix test failures in t/locale.t
Force stringification of Template::Exception.
Have the tle_verbose template ignore non-TLE data.
Fix bug in -choose foo,bar which caused only 'foo' to be chosen.
Add real localization support. This addresses almost all text seen by
the user, though I have not done a lot on error messages other than
put in the calls. A very rough Spanish localization is provided in
t/format.t
t/format_dump.t
t/format_template.t
t/format_time.t
t/format_time_datetime_cldr.t
t/format_time_datetime_strftime.t
t/format_time_posix_strftime.t
t/format_value.t
t/geocode_osm.t
t/list.tt2
t/locale.t
t/locale/fu_BAR.pm
t/macro_code.t
t/parse_time_code.t
t/parse_time_date_manip_5.t
t/parse_time_date_manip_6.t
t/parse_time_epoch.t
t/parse_time_iso8601.t
t/printenv.pl
t/read_file.t
t/rewrite.t
t/rewrite_macros
},
type => {
title => 'Tipo',
},
};
__END__
=head1 NAME
es - Define the es locale for Astro::App::Satpass2, user-specific.
=head1 SYNOPSIS
my $es_locale = do 'locale/es.pm';
=head1 DESCRIPTION
This chunk of Perl code defines the C<es> locale. It is intended to go
in the user's configuration directory. If it had a proper package
declaration and were in the right directory, it would work as a global
es locale.
All you do with this is load it. On a successful load it returns the
locale hash.
=head1 SUBROUTINES
None.
=head1 SEE ALSO
L<Astro::App::Satpass2::Locale|Astro::App::Satpass2::Locale>
=head1 SUPPORT
lib/Astro/App/Satpass2.pm view on Meta::CPAN
Any time string not beginning with '+' or '-' is assumed to be an
absolute time, and is fed to one of the
L<Astro::App::Satpass2::ParseTime|Astro::App::Satpass2::ParseTime>
modules for parsing. What is legal here depends on which parser is in
use. If you have L<Date::Manip|Date::Manip>, you will get a parser based
on that module, with all the functionality that implies. If
L<Date::Manip|Date::Manip> is not installed, you get
L<Astro::App::Satpass2::ParseTime::ISO8601|Astro::App::Satpass2::ParseTime::ISO8601>,
which parses a subset of the ISO 8601 times, as a fall-back.
L<Date::Manip|Date::Manip> has at least some support for locales, so
check the L<Date::Manip|Date::Manip> documentation before you assume you
must enter dates in English. The ISO 8601 format is all-numeric.
=head2 Epoch time
Epoch time can be specified directly, bypassing the time parser. There
are two ways to do this:
* Prefix the string C<'epoch '> to the epoch time;
lib/Astro/App/Satpass2/Format/Template.pm view on Meta::CPAN
our $VERSION = '0.057';
use constant FORMAT_VALUE => 'Astro::App::Satpass2::FormatValue';
sub new {
my ($class, @args) = @_;
my $self = $class->SUPER::new( @args );
# As of 0.020_002 the template definitions are in the
# locale system. The attribute simply holds modifications.
$self->{canned_template} = {};
$self->_new_tt( $self->permissive() );
$self->{default} = {};
$self->{formatter_method} = {};
return $self;
}
lib/Astro/App/Satpass2/Format/Template.pm view on Meta::CPAN
=item localize
This is a code reference to localization code. It takes two arguments:
the string to localize, and an optional default if the string can not be
localized for some reason. The second argument defaults to the first. A
typical use would be something like
[% localize( 'Location' ) %]
The localization comes from the locale system, specifically from key
C<{"-$template"}{string}{$string}>, where C<$template> is the name of
the main template being used, and C<$string> is the string to localize.
=item provider
This is simply the value returned by
L<provider()|Astro::App::Satpass2::Format/provider>.
=item time
lib/Astro/App/Satpass2/FormatTime/DateTime.pm view on Meta::CPAN
$time = $self->__round_time_value( $time );
if ( has_method( $time, $self->METHOD_USED() ) ) {
return $self->__format_datetime( $time, $tplt );
} else {
ref $time
and $self->wail( 'Unsupported time specification' );
my ( $class, $dt_arg ) = $self->_dt_class_and_args();
my $dt = $class->from_epoch(
epoch => $time,
time_zone => $self->_get_zone( $gmt ),
locale => scalar __preferred(),
@{ $dt_arg },
);
return $self->__format_datetime( $dt, $tplt );
}
}
sub init {
my ( $self, %arg ) = @_;
exists $arg{back_end}
or $arg{back_end} = undef;
lib/Astro/App/Satpass2/FormatTime/DateTime.pm view on Meta::CPAN
sub __format_datetime_width_adjust_object {
my ( $self, $obj, $name, $val, $gmt ) = @_;
if ( $obj ) {
$obj->set( $name => $val );
} else {
my ( $class, $dt_arg ) = $self->_dt_class_and_args();
$obj = $class->new(
time_zone => $self->_get_zone( $gmt ),
locale => scalar __preferred(),
$name => $val,
( 'year' eq $name ? () : ( year => 2020 ) ),
@{ $dt_arg },
);
}
return $obj;
}
# my $mod_fmt = $self->__preprocess_strftime_format( $dt_obj, $fmt )
lib/Astro/App/Satpass2/FormatValue.pm view on Meta::CPAN
# overriding the default units.
#
# {fetch} - A code reference which returns the value to be
# formatted. It will be passed arguments ( $self, $name, $arg
# ), where $self is the invocant, $name is the name of the
# formatter method, and $arg is a refernce to the arguments
# hash, which has already had _apply_defaults() called on it.
# This code is _not_ called if the invocant was initialized
# with title => 1.
#
# {locale} - A hash specifying last-ditch localization
# information. The keys are locale, the formatter name
# (yes, this is a duplicate) and the item name.
my %formatter_data = ( # For generating formatters
almanac => {
default => {
width => 40,
},
dimension => {
dimension => 'almanac_pseudo_units',
lib/Astro/App/Satpass2/FormatValue.pm view on Meta::CPAN
defined $arg->{width}
or $self->{fixed_width}
or $arg->{width} = '';
if ( defined $arg->{format} && ! defined $arg->{width} ) {
$arg->{width} = $self->{time_formatter}->
format_datetime_width( $arg->{format} );
}
# TODO maybe apply locale here? But see also _do_title.
APPLY_DEFAULT_LOOP:
foreach my $key ( keys %{ $dflt }, @always ) {
defined $arg->{$key} and next;
foreach my $source ( qw{ default internal } ) {
defined( $arg->{$key} = $self->_get( $source, $fmtr_name,
$key ) )
and next APPLY_DEFAULT_LOOP;
}
defined( $arg->{$key} = __localize(
text => [ $fmtr_name, $key ],
locale => $fmtr->{locale},
) )
and next;
my $default = $dflt->{$key};
$arg->{$key} = CODE_REF eq ref $default ?
$default->( $self, $fmtr_name, $arg ) : $default
}
defined $arg->{width}
lib/Astro/App/Satpass2/FormatValue.pm view on Meta::CPAN
and $arg->{width} = '';
if ( $self->{report} ) {
my $report = "-$self->{report}";
foreach my $key ( qw{ literal missing title } ) {
defined $arg->{$key}
or next;
$arg->{$key} = __localize(
text => [ $report, 'string', $arg->{$key} ],
default => $arg->{$key},
locale => $fmtr->{locale},
);
}
}
return;
}
}
lib/Astro/App/Satpass2/FormatValue.pm view on Meta::CPAN
defined $unit->{gmt}
and not defined $arg->{gmt}
and $arg->{gmt} = $unit->{gmt};
$arg->{units} = $unit_name;
$value = __localize(
text => [ $fmtr_name, 'localize_value', $value ],
default => $value,
locale => $fmtr->{locale},
);
defined( my $formatter = _dor( $unit->{formatter},
$fmtr->{dimension}{formatter},
$dim->{formatter},
) )
or $self->weep( "No formatter for $dim_name $unit_name" );
return $self->$formatter( $value, $arg, $fmtr );
}
lib/Astro/App/Satpass2/FormatValue.pm view on Meta::CPAN
my $table;
foreach my $source ( qw{ default } ) {
$table = $self->_get( $source => bearing => 'table' )
and last;
}
$table ||= __localize(
text => [ bearing => 'table' ],
default => [],
locale => $fmtr->{locale},
);
$arg->{bearing}
or $arg->{bearing} = ( $arg->{width} || 2 );
$arg->{width}
and $arg->{bearing} > $arg->{width}
and $arg->{bearing} = $arg->{width};
my $inx = min( $arg->{bearing} || 2, scalar @{ $table } ) - 1;
my $tags = $table->[$inx];
lib/Astro/App/Satpass2/FormatValue.pm view on Meta::CPAN
my $angle = rad2deg( $value );
my $table;
foreach my $source ( qw{ default } ) {
$table = $self->_get( $source => phase => 'table' )
and last;
}
$table ||= __localize(
text => [ phase => 'table' ],
default => [],
locale => $fmtr->{locale},
);
foreach my $entry ( @{ $table } ) {
$entry->[0] > $angle or next;
return $self->_format_string( $entry->[1], $arg, $fmtr );
}
return $self->_format_string( $table->[0][1], $arg, $fmtr );
}
# Called as $self->$method()
sub _format_right_ascension { ## no critic (ProhibitUnusedPrivateSubroutines)
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
};
use Exporter qw{ import };
use I18N::LangTags ();
use I18N::LangTags::Detect ();
our $VERSION = '0.057';
our @EXPORT_OK = qw{ __localize __message __preferred };
my @lang;
my $locale;
{
my %deref = (
ARRAY_REF() => sub {
my ( $data, $inx ) = @_;
defined $inx
and exists $data->[$inx]
and return $data->[$inx];
return;
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
return;
},
);
sub __localize {
# Keys used:
# {argument} = argument for code reference
# {default} = the default value
# {text} = the text to localize, as scalar or array ref. REQUIRED.
# {locale} = fallback locales, as hash ref or ref to array of hash refs.
my %arg = @_;
unless ( $arg{text} ) {
require Carp;
Carp::confess( q<Argument 'text' is required> );
}
ref $arg{text}
or $arg{text} = [ $arg{text} ];
$arg{locale} ||= [];
HASH_REF eq ref $arg{locale}
and $arg{locale} = [ $arg{locale} ];
$locale ||= _load();
my @rslt;
foreach my $lc ( @lang ) {
SOURCE_LOOP:
foreach my $source ( @{ $locale }, @{ $arg{locale} } ) {
unless ( HASH_REF eq ref $source ) {
require Carp;
Carp::confess( "\$source is '$source'" );
}
my $data = $source->{$lc}
or next;
foreach my $key ( @{ $arg{text} } ) {
my $code = $deref{ ref $data }
or do {
require Carp;
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
and return $ex;
$_ = join ' ', $_, @arg;
m/ [.?|] \z /smx
or $_ .= '.';
$_ .= "\n";
my $class = ref $ex;
return $class->new( $ex->type(), $_ );
}
sub __preferred {
$locale ||= _load();
return wantarray ? @lang : $lang[0];
}
sub _load {
# Pick up the languages from the environment
@lang = I18N::LangTags::implicate_supers(
I18N::LangTags::Detect::detect() );
# Normalize the language names.
foreach ( @lang ) {
s/ ( [^_-]+ ) [_-] (.* ) /\L$1_\U$2/smx
or $_ = lc $_;
'c' eq $_
and $_ = uc $_;
}
# Append the default locale name.
grep { 'C' eq $_ } @lang
or push @lang, 'C';
# Accumulator for locale data.
my @locales;
# Put all the user's data in a hash.
push @locales, {};
foreach my $lc ( @lang ) {
eval { ## no critic (ErrorHandling::RequireCheckingReturnValueOfEval)
defined( my $path = expand_tilde( "~~/locale/$lc.pm" ) )
or return;
my $data;
$data = do $path
and HASH_REF eq ref $data
and $locales[-1]{$lc} = $data;
};
}
# Put the system-wide data in a hash.
push @locales, {};
foreach my $lc ( @lang ) {
my $mod_name = __PACKAGE__ . "::$lc";
my $data;
$data = eval "require $mod_name"
and HASH_REF eq ref $data
and $locales[-1]{$lc} = $data;
}
# Return a reference to the names of locales.
return \@locales;
}
1;
__END__
=head1 NAME
Astro::App::Satpass2::Locale - Handle locale-dependant data.
=head1 SYNOPSIS
use Astro::App::Satpass2::Locale qw{ __localize };
# The best localization
say scalar __localize(
text => [ 'foo', 'bar' ],
default => 'default text',
);
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
# All localizations, in decreasing order of goodness
for ( __localize(
text => [ 'foo', 'bar' ],
default => 'default text',
) ) {
say;
}
=head1 DESCRIPTION
This Perl module implements the locale system for
L<Astro::App::Satpass2|Astro::App::Satpass2>.
The locale data can be thought of as a two-level hash, with the first
level corresponding to the section of a Microsoft-style configuration
file and the second level to the items in the section.
The locale data are stored in C<.pm> files, which return the required
hash when they are loaded. These are named after the locale, in the form
F<lc_CC.pm> or F<lc.pm>, where the C<lc> is the language code (lower
case) and the C<CC> is a country code (upper case).
The files are considered in the following order:
=over
=item The user's F<lc_CC.pm>
=item The global F<lc_CC.pm>
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
=item The user's F<C.pm>
=item The global F<C.pm>.
=back
The global files are installed as Perl modules, named
C<Astro::App::Satpass2::Locale::whatever>, and are loaded via
C<require()>. The user's files are stored
in the F<locale/> directory of the user's configuration, and are loaded
via C<do()>.
=head1 SUBROUTINES
This class supports the following exportable public subroutines:
=head2 __localize
# The best localization
say scalar __localize(
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
The arguments are name/value pairs, with the following names being the
only ones supported.
=over
=item text
This argument is required, and passes the text to be localized. This can
be either a scalar, or a reference to an array of keys (or indices) used
to traverse the locale data structure.
=item default
This argument specifies the default value to be returned if no
localization is available. If it is not specified, C<undef> is returned
if no localization is available.
=item locale
This argument specifies either a hash reference that is consulted for
locale information if all other available locales provide no
localization, or a reference to an array of such hashes. The default is
C<[]>.
=item argument
This argument specifies the value of the second argument passed to a
code reference which is being used for localization. See
L<Astro::App::Satpass2::Locale::C|Astro::App::Satpass2::Locale::C> for
an example of how this can be used.
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
representation what will happen if you specify them, and makes no
commitment that whatever you observe to happen will not change without
notice.
If this subroutine is called in scalar context, the best available
localization is returned. If it is called in list context, all available
localizations will be returned, with the best first and the worst (which
will be the default) last.
To extend the above example, assuming neither the system-wide or
locale-specific locale information defines the keys C<{fu}{bar}>,
say scalar __localize(
text => [ foo => 'bar' ],
default => 'Greeble',
locale => {
C => {
foo => {
bar => 'Gronk!',
},
},
fr => {
foo => {
bar => 'Gronkez!',
},
},
},
);
will print C<'Gronkez!'> in a French locale, and C<'Gronk!'> in any
other locale (since the C<'C'> locale is always consulted). If
C<'Greeble'> is printed, it indicates that the locale system is buggy.
=head2 __message
say __message( 'Fee fi foe foo!' ); # Fee fi foe foo
say __message( 'A', 'B', 'C' ); # A B C
say __message( 'Hello [% arg.0 %]!', 'sailor' );
# Hello sailor!
This subroutine is a wrapper for C<__localize()> designed to make
message localization easier.
lib/Astro/App/Satpass2/Locale.pm view on Meta::CPAN
If the localization of the first argument does not contain any
C<Template-Toolkit> interpolations, it is simply joined to the
arguments, with single space characters in between, and the result of
the join is returned.
=head2 __preferred
say __preferred()
This subroutine returns the user's preferred locale in scalar mode, or
all acceptable locales in descending order of preference in list mode.
=head1 SEE ALSO
L<Astro::App::Satpass2::FormatValue|Astro::App::Satpass2::FormatValue>
=head1 SUPPORT
Support is by the author. Please file bug reports at
L<https://rt.cpan.org/Public/Dist/Display.html?Name=Astro-App-Satpass2>,
L<https://github.com/trwyant/perl-Astro-App-Satpass2/issues>, or in
lib/Astro/App/Satpass2/Locale/C.pm view on Meta::CPAN
package Astro::App::Satpass2::Locale::C;
use 5.008;
use strict;
use warnings;
use utf8; # Not actually needed for C locale, but maybe for others
use Astro::Coord::ECI::TLE 0.059 qw{ :constants };
use Astro::App::Satpass2::Utils qw{ @CARP_NOT };
use Scalar::Util ();
our $VERSION = '0.057';
my @event_names;
$event_names[PASS_EVENT_NONE] = '';
$event_names[PASS_EVENT_SHADOWED] = 'shdw';
lib/Astro/App/Satpass2/Locale/C.pm view on Meta::CPAN
},
type => {
title => 'Type',
},
};
__END__
=head1 NAME
Astro::App::Satpass2::Locale::C - Define the C locale for Astro::App::Satpass2
=head1 SYNOPSIS
my $c_locale = require Astro::App::Satpass2::Locale::C;
=head1 DESCRIPTION
This Perl module defines the C locale (which is the default locale )for
L<Astro::App::Satpass2|Astro::App::Satpass2>.
All you do with this is load it. On a successful load it returns the
locale hash.
=head1 SUBROUTINES
None.
=head1 THE LOCALE DATA
The locale data are stored in a hash. The top-level key is always locale
code. This is either a two-character language code, lower-case (e.g.
C<'en'>, a language code and upper-case country code delimited by an
underscore (e.g. C<'en_US'>, or C<'C'> for the default locale.
The data for each locale key are a reference to a hash. The keys of this
hash are the names of
L<Astro::App::Satpass2::FormatValue|Astro::App::Satpass2::FormatValue>
formats (e.g. C<{azimuth}>), the names of top-level reporting templates
preceded by a dash (e.g. C<{'-flare'}>, or the special keys
C<'{+message}'> (error messages) or C<'{+template}'> (templates).
The content of these second level hashes varies with its type, as
follows:
=head2 Format Effectors (e.g. C<{azimuth}>)
These are hashes containing data relevant to that format effector. The
C<{title}> key contains the title for that format effector. Other keys
relevant to the specific formatter may also appear, such as the
C<{table}> key in C<{phase}>, which defines the names of phases in terms
of phase angle. These extra keys are pretty much ad-hoc as required by
the individual format effector. In general they are cascades of C<HASH>
and/or C<ARRAY> references, though the last can be a C<CODE> reference.
The C<HASH> and C<ARRAY> references are resolved one at a time using
successive C<__localize()> arguments. A C<CODE> reference is resolved by
calling it passing the current C<__locale()> argument, and the original
C<__locale()> call's invocant argument (or C<undef> if none). See the
C<almanac> definition above for an example.
=head2 Top-level reporting (e.g. C<{'-flare'}>
The only key defined at the moment is C<{string}>, whose content is a
hash reference. This hash is keyed by text appearing as the values in
L<Astro::App::Satpass2::FormatValue|Astro::App::Satpass2::FormatValue>
C<literal>, C<missing>, and C<title> arguments, and the corresponding
values are the translations of that text into the relevant locale.
For example, a Spanish localization for C<{'-flare'}> might be something
like
{
es => {
string => {
night => 'noche',
...
}
}
}
=head2 C<{'+message'}>
The value of this key is a hash whose keys are message text as coded in
this program, and whose values are the message text as it should appear
in the relevant locale. These are typically to be consumed by the locale
system's C<__message()> subroutine.
=head2 C<{'+template'}>
The value of this key is a hash whose keys are template names used by
L<Astro::App::Satpass2::Format::Template|Astro::App::Satpass2::Format::Template>,
and whose values are the templates themselves in the relevant locale.
=head1 SEE ALSO
L<Astro::App::Satpass2::Locale|Astro::App::Satpass2::Locale>
=head1 SUPPORT
Support is by the author. Please file bug reports at
L<https://rt.cpan.org/Public/Dist/Display.html?Name=Astro-App-Satpass2>,
L<https://github.com/trwyant/perl-Astro-App-Satpass2/issues>, or in
text => [ almanac => 'title' ],
default => 'name',
), 'Almanac', q{almanac => 'title'};
ok ! defined scalar __localize(
text => [ fu => 'bar' ],
), q{fu => 'bar' returns nothing};
is scalar __localize(
text => [ fu => 'bar' ],
locale => {
fu_BAR => {
fu => {
bar => 'bazzle',
},
},
},
default => 'whee',
), 'bazzle', q{fu => 'bar' works with manual data};
is scalar __localize(
text => [ altitude => 'title' ],
default => 'Robin'
), 'Batman', q{altitude => 'title' from user-specific locale file};
is [ __localize(
text => [ altitude => 'title' ],
default => 'Robin',
) ],
[ 'Batman', 'Altitude', 'Robin' ],
q{altitude => 'title' in list context};
is scalar __localize(
text => [ bearing => 'table' ],
[ 83.9 => 'waxing crescent' ],
[ 96.1 => 'first quarter' ],
[ 173.9 => 'waxing gibbous' ],
[ 186.1 => 'full' ],
[ 263.9 => 'waning gibbous' ],
[ 276.1 => 'last quarter' ],
[ 353.9 => 'waning crescent' ],
],
q{phase => 'table' returns the correct array reference};
is scalar __preferred(), 'fu_BAR', 'Preferred locale';
note <<'EOD';
It appears from CPAN Testers results that under Perl 5.20 and MSWin32
the array returned by __preferred() in list context is ( 'fu_BAR', 'C').
This seems wrong to me, but since I have no way to trouble shoot it I
will simply have to live with it.
EOD
my @pref = __preferred();
is $pref[0], 'fu_BAR', q<First preferred locale is 'fu_BAR'>;
@pref > 2
and is $pref[1], 'fu', q<Second preferred locale is 'fu'>;
is $pref[-1], 'C', q<Last preferred locale is 'C'>;
}
done_testing;
1;
# ex: set textwidth=72 :
t/locale/fu_BAR.pm view on Meta::CPAN
},
event => {
table => [ qw{ Larry Moe Shemp Curley } ],
},
};
__END__
=head1 NAME
fu_BAR - Define fictional locale fu_BAR.
=head1 SYNOPSIS
No user servicable parts inside.
=head1 DESCRIPTION
This Perl module is part of the
L<Astro::App::Satpass2|Astro::App::Satpass2> locale system, used for
testing. It is private to this distribution, and can be changed or
removed without notice.
=head1 SUBROUTINES
None.
=head1 SEE ALSO
L<Astro::App::Satpass2::Locale|Astro::App::Satpass2::Locale>
( run in 1.763 second using v1.01-cache-2.11-cpan-ceb78f64989 )