App-DateUtils
view release on metacpan or search on metacpan
0.123 2020-01-31 Released-By: PERLANCAR; Urgency: medium
[dateconv]
- Add conversion target iso8601, ALL.
- [ux] Add option -a as shortcut to --to=ALL.
- Avoid the use of From_str::alami date coercion for now as
DateTime::Format::Alami is flaky.
0.122 2019-11-29 Released-By: PERLANCAR; Urgency: medium
- Update coerce rule names in Sah schemas (Data::Sah::Coerce
0.034+).
0.121 2019-06-19 Released-By: PERLANCAR
0.10 2016-07-10 Released-By: PERLANCAR
- parse-date, parse-duration: Add option --all-modules (-a) to parse
dates/durations with all installed modules.
0.09 2016-06-29 Released-By: PERLANCAR
- Add utility: parse-date-using-df-flexible.
- Show error message from DateTime::Format::Natural on parsing
failure.
- Mention dateparse.
- Add more examples.
0.08 2016-06-29 Released-By: PERLANCAR
- Add examples.
- Add utility: parse-duration-using-df-natural.
0.07 2016-06-29 Released-By: PERLANCAR
- [Removed] Remove parse-duration-using-df-duration because parsing
duration with DateTime::Format::Duration requires predefining format
string.
- Add utilities parse-duration-using-df-alami-{en,id}.
- [Bugfix] Typo caused parsing date with DateTime::Format::Natural
always considered failed.
0.06 2016-06-28 Released-By: PERLANCAR
- parse-date-using-df-alami-*: Show matched pattern.
0.05 2016-06-19 Released-By: PERLANCAR
"Data::Sah::Coerce::perl::To_duration::From_str::hms" : "0",
"Data::Sah::Coerce::perl::To_duration::From_str::human" : "0",
"Data::Sah::Coerce::perl::To_duration::From_str::iso8601" : "0",
"Data::Sah::Compiler::perl::TH::array" : "0.914",
"Data::Sah::Compiler::perl::TH::bool" : "0.914",
"Data::Sah::Compiler::perl::TH::date" : "0.914",
"Data::Sah::Compiler::perl::TH::duration" : "0.914",
"Data::Sah::Compiler::perl::TH::str" : "0.914",
"Date::Parse" : "0",
"Date::strftimeq" : "0",
"DateTime" : "0",
"DateTime::Format::Alami::EN" : "0.13",
"DateTime::Format::Alami::ID" : "0.13",
"DateTime::Format::Duration::ConciseHMS" : "0",
"DateTime::Format::Duration::ISO8601" : "0",
"DateTime::Format::Flexible" : "0",
"DateTime::Format::ISO8601::Format" : "0",
"DateTime::Format::Natural" : "0",
"Module::Installed::Tiny" : "0.011",
"POSIX" : "0",
"Perinci::CmdLine::Any" : "0.154",
"Perinci::CmdLine::Lite" : "1.924",
"Time::Duration::Parse" : "0",
"perl" : "5.010001",
"strict" : "0",
"warnings" : "0"
}
},
Data::Sah::Coerce::perl::To_duration::From_str::hms: '0'
Data::Sah::Coerce::perl::To_duration::From_str::human: '0'
Data::Sah::Coerce::perl::To_duration::From_str::iso8601: '0'
Data::Sah::Compiler::perl::TH::array: '0.914'
Data::Sah::Compiler::perl::TH::bool: '0.914'
Data::Sah::Compiler::perl::TH::date: '0.914'
Data::Sah::Compiler::perl::TH::duration: '0.914'
Data::Sah::Compiler::perl::TH::str: '0.914'
Date::Parse: '0'
Date::strftimeq: '0'
DateTime: '0'
DateTime::Format::Alami::EN: '0.13'
DateTime::Format::Alami::ID: '0.13'
DateTime::Format::Duration::ConciseHMS: '0'
DateTime::Format::Duration::ISO8601: '0'
DateTime::Format::Flexible: '0'
DateTime::Format::ISO8601::Format: '0'
DateTime::Format::Natural: '0'
Module::Installed::Tiny: '0.011'
POSIX: '0'
Perinci::CmdLine::Any: '0.154'
Perinci::CmdLine::Lite: '1.924'
Time::Duration::Parse: '0'
perl: '5.010001'
strict: '0'
warnings: '0'
resources:
bugtracker: https://rt.cpan.org/Public/Dist/Display.html?Name=App-DateUtils
Makefile.PL view on Meta::CPAN
"Data::Sah::Coerce::perl::To_duration::From_str::hms" => 0,
"Data::Sah::Coerce::perl::To_duration::From_str::human" => 0,
"Data::Sah::Coerce::perl::To_duration::From_str::iso8601" => 0,
"Data::Sah::Compiler::perl::TH::array" => "0.914",
"Data::Sah::Compiler::perl::TH::bool" => "0.914",
"Data::Sah::Compiler::perl::TH::date" => "0.914",
"Data::Sah::Compiler::perl::TH::duration" => "0.914",
"Data::Sah::Compiler::perl::TH::str" => "0.914",
"Date::Parse" => 0,
"Date::strftimeq" => 0,
"DateTime" => 0,
"DateTime::Format::Alami::EN" => "0.13",
"DateTime::Format::Alami::ID" => "0.13",
"DateTime::Format::Duration::ConciseHMS" => 0,
"DateTime::Format::Duration::ISO8601" => 0,
"DateTime::Format::Flexible" => 0,
"DateTime::Format::ISO8601::Format" => 0,
"DateTime::Format::Natural" => 0,
"Module::Installed::Tiny" => "0.011",
"POSIX" => 0,
"Perinci::CmdLine::Any" => "0.154",
"Perinci::CmdLine::Lite" => "1.924",
"Time::Duration::Parse" => 0,
"strict" => 0,
"warnings" => 0
},
"TEST_REQUIRES" => {
"File::Spec" => 0,
Makefile.PL view on Meta::CPAN
"Data::Sah::Coerce::perl::To_duration::From_str::hms" => 0,
"Data::Sah::Coerce::perl::To_duration::From_str::human" => 0,
"Data::Sah::Coerce::perl::To_duration::From_str::iso8601" => 0,
"Data::Sah::Compiler::perl::TH::array" => "0.914",
"Data::Sah::Compiler::perl::TH::bool" => "0.914",
"Data::Sah::Compiler::perl::TH::date" => "0.914",
"Data::Sah::Compiler::perl::TH::duration" => "0.914",
"Data::Sah::Compiler::perl::TH::str" => "0.914",
"Date::Parse" => 0,
"Date::strftimeq" => 0,
"DateTime" => 0,
"DateTime::Format::Alami::EN" => "0.13",
"DateTime::Format::Alami::ID" => "0.13",
"DateTime::Format::Duration::ConciseHMS" => 0,
"DateTime::Format::Duration::ISO8601" => 0,
"DateTime::Format::Flexible" => 0,
"DateTime::Format::ISO8601::Format" => 0,
"DateTime::Format::Natural" => 0,
"File::Spec" => 0,
"IO::Handle" => 0,
"IPC::Open3" => 0,
"Module::Installed::Tiny" => "0.011",
"POSIX" => 0,
"Perinci::CmdLine::Any" => "0.154",
"Perinci::CmdLine::Lite" => "1.924",
"Test::More" => 0,
"Time::Duration::Parse" => 0,
"strict" => 0,
parse_date(dates => ["23 sep 2015", "tomorrow", "foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible",
original => "23 sep 2015",
is_parseable => 1,
as_epoch => 1442966400,
as_datetime_obj => "2015-09-23T00:00:00",
as_datetime_obj_tz_local => "2015-09-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2015-09-22T17:00:00Z",
},
{
module => "DateTime::Format::Flexible",
original => "tomorrow",
is_parseable => 1,
as_epoch => 1709856000,
as_datetime_obj => "2024-03-08T00:00:00",
as_datetime_obj_tz_local => "2024-03-08T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-03-07T17:00:00Z",
},
{
module => "DateTime::Format::Flexible",
original => "foo",
is_parseable => 0,
error_msg => "Invalid date format: foo at /home/u1/perl5/perlbrew/perls/perl-5.38.2/lib/site_perl/5.38.2/Perinci/Access.pm line 81. ",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
Arguments ('*' denotes required arguments):
* all_modules => *bool*
Parse using all installed modules and return all the result at once.
* dates* => *array[str]*
(No description)
* module => *str* (default: "DateTime::Format::Flexible")
(No description)
* time_zone => *str*
(No description)
Returns an enveloped result (an array).
First element ($status_code) is an integer containing HTTP-like status
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_date_using_df_alami_en
Usage:
parse_date_using_df_alami_en(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Alami::EN.
Examples:
* Example #1:
parse_date_using_df_alami_en(dates => ["23 May"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "23 May",
is_parseable => 1,
as_epoch => 1716422400,
as_datetime_obj => "2024-05-23T00:00:00",
as_datetime_obj_tz_local => "2024-05-23T07:00:00+07:00",
as_datetime_obj_tz_utc => "2024-05-23T00:00:00Z",
pattern => "p_dateymd",
},
],
{
parse_date_using_df_alami_en(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_epoch",
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_date_using_df_alami_id
Usage:
parse_date_using_df_alami_id(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Alami::ID.
Examples:
* Example #1:
parse_date_using_df_alami_id(dates => ["23 Mei"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "23 Mei",
is_parseable => 1,
as_epoch => 1716422400,
as_datetime_obj => "2024-05-23T00:00:00",
as_datetime_obj_tz_local => "2024-05-23T07:00:00+07:00",
as_datetime_obj_tz_utc => "2024-05-23T00:00:00Z",
pattern => "p_dateymd",
},
],
{
parse_date_using_df_alami_id(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_epoch",
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_date_using_df_flexible
Usage:
parse_date_using_df_flexible(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Flexible.
Examples:
* Example #1:
parse_date_using_df_flexible(dates => ["23rd Jun"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible",
original => "23rd Jun",
is_parseable => 1,
as_epoch => 1719100800,
as_datetime_obj => "2024-06-23T00:00:00",
as_datetime_obj_tz_local => "2024-06-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-06-22T17:00:00Z",
},
],
{
"table.fields" => [
parse_date_using_df_flexible(dates => ["23 Dez"], lang => "de");
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible(de)",
original => "23 Dez",
is_parseable => 1,
as_epoch => 1734912000,
as_datetime_obj => "2024-12-23T00:00:00",
as_datetime_obj_tz_local => "2024-12-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-12-22T17:00:00Z",
},
],
{
"table.fields" => [
parse_date_using_df_flexible(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible",
original => "foo",
is_parseable => 0,
error_msg => "Invalid date format: foo at /home/u1/perl5/perlbrew/perls/perl-5.38.2/lib/site_perl/5.38.2/Perinci/Access.pm line 81. ",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_date_using_df_natural
Usage:
parse_date_using_df_natural(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Natural.
Examples:
* Example #1:
parse_date_using_df_natural(dates => ["23rd Jun"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "23rd Jun",
is_parseable => 1,
as_epoch => 1719100800,
as_datetime_obj => "2024-06-23T00:00:00",
as_datetime_obj_tz_local => "2024-06-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-06-22T17:00:00Z",
},
],
{
"table.fields" => [
parse_date_using_df_natural(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "foo",
is_parseable => 0,
error_msg => "'foo' does not parse (perhaps you have some garbage?)",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_duration_using_df_alami_en
Usage:
parse_duration_using_df_alami_en(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse duration string(s) using DateTime::Format::Alami::EN.
Examples:
* Example #1:
parse_duration_using_df_alami_en(durations => ["2h, 3mins"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "2h, 3mins",
is_parseable => 1,
as_secs => 7380,
as_dtdur_obj => "PT2H3M",
},
],
{
"table.fields" => [
"module",
"original",
parse_duration_using_df_alami_en(durations => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_secs",
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_duration_using_df_alami_id
Usage:
parse_duration_using_df_alami_id(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse duration string(s) using DateTime::Format::Alami::ID.
Examples:
* Example #1:
parse_duration_using_df_alami_id(durations => ["2j, 3mnt"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "2j, 3mnt",
is_parseable => 1,
as_secs => 7380,
as_dtdur_obj => "PT2H3M",
},
],
{
"table.fields" => [
"module",
"original",
parse_duration_using_df_alami_id(durations => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_secs",
information, much like how HTTP response headers provide additional
metadata.
Return value: (any)
parse_duration_using_df_natural
Usage:
parse_duration_using_df_natural(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse duration string(s) using DateTime::Format::Natural.
Examples:
* Example #1:
parse_duration_using_df_natural(durations => ["for 2 weeks"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "for 2 weeks",
is_parseable => 1,
as_secs => 1209600.000768,
as_dtdur_obj => "P14DT0.000768S",
date2 => "2024-03-21T09:10:21",
date1 => "2024-03-07T09:10:21",
},
],
{
"table.fields" => [
parse_duration_using_df_natural(durations => ["from 23 Jun to 29 Jun"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "from 23 Jun to 29 Jun",
is_parseable => 1,
as_secs => 9757178.285926,
as_dtdur_obj => "P3M21DT14H49M38.285926S",
date1 => "2024-03-07T09:10:21",
date2 => "2024-06-29T00:00:00",
},
],
{
"table.fields" => [
parse_duration_using_df_natural(durations => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "foo",
is_parseable => 0,
error_msg => "'foo' does not parse (perhaps you have some garbage?)",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
[@Author::PERLANCAR]
:version=0.610
[Prereqs]
perl=5.010001
strict=0
warnings=0
Date::Parse=0
Date::strftimeq=0
DateTime=0
DateTime::Format::Alami::EN=0.13
DateTime::Format::Alami::ID=0.13
DateTime::Format::Duration::ConciseHMS=0
DateTime::Format::Duration::ISO8601=0
DateTime::Format::Flexible=0
DateTime::Format::ISO8601::Format=0
DateTime::Format::Natural=0
Module::Installed::Tiny=0.011
POSIX=0
Time::Duration::Parse=0
[Prereqs / DevelopX_spec]
-phase=develop
-relationship=x_spec
Rinci=1.1.102
lib/App/DateUtils.pm view on Meta::CPAN
my %all_modules_arg = (
all_modules => {
summary => 'Parse using all installed modules and '.
'return all the result at once',
schema => ['bool*', is=>1],
cmdline_aliases => {a=>{}},
},
);
my @parse_date_modules = (
#'DateTime::Format::Alami::EN',
#'DateTime::Format::Alami::ID',
'DateTime::Format::Flexible',
'DateTime::Format::Flexible(de)',
'DateTime::Format::Flexible(es)',
'DateTime::Format::Natural',
'Date::Parse',
);
my @parse_duration_modules = (
#'DateTime::Format::Alami::EN',
#'DateTime::Format::Alami::ID',
'DateTime::Format::Natural',
'Time::Duration::Parse',
);
$SPEC{parse_date} = {
v => 1.1,
summary => 'Parse date string(s) using one of several modules',
args => {
module => {
schema => ['str*', in=>\@parse_date_modules],
default => 'DateTime::Format::Flexible',
cmdline_aliases => {m=>{}},
},
%all_modules_arg,
%time_zone_arg,
%dates_arg,
},
examples => [
{
argv => ['23 sep 2015','tomorrow','foo'],
},
],
};
sub parse_date {
require DateTime::Format::ISO8601::Format;
my %args = @_;
my %mods; # val = 1 if installed
if ($args{all_modules}) {
require Module::Installed::Tiny;
for my $mod0 (@parse_date_modules) {
(my $mod = $mod0) =~ s/\(.+//;
$mods{$mod0} = Module::Installed::Tiny::module_installed($mod) ?
1:0;
lib/App/DateUtils.pm view on Meta::CPAN
} else {
%mods = ($args{module} => 1);
}
my @res;
for my $mod (sort keys %mods) {
my $mod_is_installed = $mods{$mod};
my $parser;
if ($mod_is_installed) {
if ($mod eq 'DateTime::Format::Alami::EN') {
require DateTime::Format::Alami::EN;
$parser = DateTime::Format::Alami::EN->new(
( time_zone => $args{time_zone} ) x
!!(defined($args{time_zone})),
);
} elsif ($mod eq 'DateTime::Format::Alami::ID') {
require DateTime::Format::Alami::ID;
$parser = DateTime::Format::Alami::ID->new(
( time_zone => $args{time_zone} ) x
!!(defined($args{time_zone})),
);
} elsif ($mod =~ /^DateTime::Format::Flexible/) {
require DateTime::Format::Flexible;
$parser = DateTime::Format::Flexible->new(
);
} elsif ($mod eq 'DateTime::Format::Natural') {
require DateTime::Format::Natural;
$parser = DateTime::Format::Natural->new(
( time_zone => $args{time_zone} ) x
!!(defined($args{time_zone})),
);
} elsif ($mod eq 'Date::Parse') {
require Date::Parse;
require DateTime; # to show as_datetime_obj
} else {
return [400, "Unknown module '$mod'"];
}
}
DATE:
for my $date (@{ $args{dates} }) {
my $rec = { original => $date, module => $mod };
unless ($mod_is_installed) {
$rec->{error_msg} = "module not installed";
goto PUSH_RESULT;
}
if ($mod =~ /^DateTime::Format::Alami/) {
my $res;
eval { $res = $parser->parse_datetime($date, {format=>'combined'}) };
if ($@) {
$rec->{is_parseable} = 0;
} else {
$rec->{is_parseable} = 1;
$rec->{as_epoch} = $res->{epoch};
$rec->{as_datetime_obj} = "$res->{DateTime}";
$rec->{as_datetime_obj_tz_local} = DateTime::Format::ISO8601::Format->new->format_datetime($res->{DateTime}->set_time_zone("local"));
$rec->{as_datetime_obj_tz_utc} = DateTime::Format::ISO8601::Format->new->format_datetime($res->{DateTime}->set_time_zone("UTC"));
$rec->{pattern} = $res->{pattern};
}
} elsif ($mod =~ /^DateTime::Format::Flexible/) {
my $dt;
my %opts;
$opts{lang} = [$1] if $mod =~ /\((\w+)\)$/;
eval { $dt = $parser->parse_datetime(
$date,
%opts,
) };
my $err = $@;
if (!$err) {
$rec->{is_parseable} = 1;
$rec->{as_epoch} = $dt->epoch;
$rec->{as_datetime_obj} = "$dt";
$rec->{as_datetime_obj_tz_local} = DateTime::Format::ISO8601::Format->new->format_datetime($dt->set_time_zone("local"));
$rec->{as_datetime_obj_tz_utc} = DateTime::Format::ISO8601::Format->new->format_datetime($dt->set_time_zone("UTC"));
} else {
$err =~ s/\n/ /g;
$rec->{is_parseable} = 0;
$rec->{error_msg} = $err;
}
} elsif ($mod =~ /^DateTime::Format::Natural/) {
my $dt = $parser->parse_datetime($date);
if ($parser->success) {
$rec->{is_parseable} = 1;
$rec->{as_epoch} = $dt->epoch;
$rec->{as_datetime_obj} = "$dt";
$rec->{as_datetime_obj_tz_local} = DateTime::Format::ISO8601::Format->new->format_datetime($dt->set_time_zone("local"));
$rec->{as_datetime_obj_tz_utc} = DateTime::Format::ISO8601::Format->new->format_datetime($dt->set_time_zone("UTC"));
} else {
$rec->{is_parseable} = 0;
$rec->{error_msg} = $parser->error;
}
} elsif ($mod eq 'Date::Parse') {
my $time = Date::Parse::str2time($date);
if (defined $time) {
$rec->{is_parseable} = 1;
$rec->{as_epoch} = $time;
my $dt = DateTime->from_epoch(epoch => $time);
$rec->{as_datetime_obj} = "$dt";
$rec->{as_datetime_obj_tz_local} = DateTime::Format::ISO8601::Format->new->format_datetime($dt->set_time_zone("local"));
$rec->{as_datetime_obj_tz_utc} = DateTime::Format::ISO8601::Format->new->format_datetime($dt->set_time_zone("UTC"));
} else {
$rec->{is_parseable} = 0;
}
}
PUSH_RESULT:
push @res, $rec;
} # for dates
} # for mods
[200, "OK", \@res, {'table.fields'=>[qw/module original is_parseable as_epoch as_datetime_obj as_datetime_obj_tz_local as_datetime_obj_tz_utc error_msg/]}];
}
$SPEC{parse_date_using_df_flexible} = {
v => 1.1,
summary => 'Parse date string(s) using DateTime::Format::Flexible',
args => {
%time_zone_arg,
%dates_arg,
lang => {
schema => ['str*', in=>[qw/de en es/]],
default => 'en',
},
},
examples => [
{args => {dates => ['23rd Jun']}},
{args => {dates => ['23 Dez'], lang=>'de'}},
{args => {dates => ['foo']}},
],
};
sub parse_date_using_df_flexible {
my %args = @_;
my $lang = $args{lang};
my $module = 'DateTime::Format::Flexible';
$module .= "(de)" if $lang eq 'de';
$module .= "(es)" if $lang eq 'es';
parse_date(module=>$module, %args);
}
$SPEC{parse_date_using_df_natural} = {
v => 1.1,
summary => 'Parse date string(s) using DateTime::Format::Natural',
args => {
%time_zone_arg,
%dates_arg,
},
examples => [
{args => {dates => ['23rd Jun']}},
{args => {dates => ['foo']}},
],
links => [
{summary => 'The official CLI for DateTime::Format::Natural', url=>'dateparse'},
],
};
sub parse_date_using_df_natural {
my %args = @_;
parse_date(module=>'DateTime::Format::Natural', %args);
}
$SPEC{parse_date_using_df_alami_en} = {
v => 1.1,
summary => 'Parse date string(s) using DateTime::Format::Alami::EN',
args => {
%time_zone_arg,
%dates_arg,
},
examples => [
{args => {dates => ['23 May']}},
{args => {dates => ['foo']}},
],
};
sub parse_date_using_df_alami_en {
my %args = @_;
parse_date(module=>'DateTime::Format::Alami::EN', %args);
}
$SPEC{parse_date_using_df_alami_id} = {
v => 1.1,
summary => 'Parse date string(s) using DateTime::Format::Alami::ID',
args => {
%time_zone_arg,
%dates_arg,
},
examples => [
{args => {dates => ['23 Mei']}},
{args => {dates => ['foo']}},
],
};
sub parse_date_using_df_alami_id {
my %args = @_;
parse_date(module=>'DateTime::Format::Alami::ID', %args);
}
$SPEC{parse_duration} = {
v => 1.1,
summary => 'Parse duration string(s) using one of several modules',
args => {
module => {
schema => ['str*', in=>\@parse_duration_modules],
default => 'Time::Duration::Parse',
cmdline_aliases => {m=>{}},
lib/App/DateUtils.pm view on Meta::CPAN
} else {
%mods = ($args{module} => 1);
}
my @res;
for my $mod (sort keys %mods) {
my $mod_is_installed = $mods{$mod};
my $parser;
if ($mod_is_installed) {
if ($mod eq 'DateTime::Format::Alami::EN') {
require DateTime::Format::Alami::EN;
$parser = DateTime::Format::Alami::EN->new();
} elsif ($mod eq 'DateTime::Format::Alami::ID') {
require DateTime::Format::Alami::ID;
$parser = DateTime::Format::Alami::ID->new();
} elsif ($mod eq 'DateTime::Format::Natural') {
require DateTime::Format::Natural;
$parser = DateTime::Format::Natural->new();
} elsif ($mod eq 'Time::Duration::Parse') {
require Time::Duration::Parse;
}
}
DURATION:
for my $dur (@{ $args{durations} }) {
my $rec = { original => $dur, module => $mod };
unless ($mod_is_installed) {
$rec->{error_msg} = "module not installed";
goto PUSH_RESULT;
}
if ($mod =~ /^DateTime::Format::Alami/) {
my $res;
eval { $res = $parser->parse_datetime_duration($dur, {format=>'combined'}) };
if ($@) {
$rec->{is_parseable} = 0;
} else {
require DateTime::Format::Duration::ISO8601;
my $dtdurf = DateTime::Format::Duration::ISO8601->new;
$rec->{is_parseable} = 1;
$rec->{as_dtdur_obj} = $dtdurf->format_duration($res->{Duration});
$rec->{as_secs} = $res->{seconds};
}
} elsif ($mod =~ /^DateTime::Format::Natural/) {
my @dt = $parser->parse_datetime_duration($dur);
if (@dt > 1) {
require DateTime::Format::Duration::ISO8601;
my $dtdurf = DateTime::Format::Duration::ISO8601->new;
my $dtdur = $dt[1]->subtract_datetime($dt[0]);
$rec->{is_parseable} = 1;
$rec->{date1} = "$dt[0]";
$rec->{date2} = "$dt[1]";
$rec->{as_dtdur_obj} = $dtdurf->format_duration($dtdur);
$rec->{as_secs} =
$dtdur->years * 365.25*86400 +
$dtdur->months * 30.4375*86400 +
$dtdur->weeks * 7*86400 +
$dtdur->days * 86400 +
lib/App/DateUtils.pm view on Meta::CPAN
PUSH_RESULT:
push @res, $rec;
} # for durations
} # for modules
[200, "OK", \@res, {'table.fields'=>[qw/module original is_parseable as_secs as_dtdur_obj error_msg/]}];
}
$SPEC{parse_duration_using_df_alami_en} = {
v => 1.1,
summary => 'Parse duration string(s) using DateTime::Format::Alami::EN',
args => {
%durations_arg,
},
examples => [
{args => {durations => ['2h, 3mins']}},
{args => {durations => ['foo']}},
],
};
sub parse_duration_using_df_alami_en {
my %args = @_;
parse_duration(module=>'DateTime::Format::Alami::EN', %args);
}
$SPEC{parse_duration_using_df_alami_id} = {
v => 1.1,
summary => 'Parse duration string(s) using DateTime::Format::Alami::ID',
args => {
%durations_arg,
},
examples => [
{args => {durations => ['2j, 3mnt']}},
{args => {durations => ['foo']}},
],
};
sub parse_duration_using_df_alami_id {
my %args = @_;
parse_duration(module=>'DateTime::Format::Alami::ID', %args);
}
$SPEC{parse_duration_using_df_natural} = {
v => 1.1,
summary => 'Parse duration string(s) using DateTime::Format::Natural',
args => {
%durations_arg,
},
examples => [
{args => {durations => ['for 2 weeks']}},
{args => {durations => ['from 23 Jun to 29 Jun']}},
{args => {durations => ['foo']}},
],
};
sub parse_duration_using_df_natural {
my %args = @_;
parse_duration(module=>'DateTime::Format::Natural', %args);
}
$SPEC{parse_duration_using_td_parse} = {
v => 1.1,
summary => 'Parse duration string(s) using Time::Duration::Parse',
args => {
%durations_arg,
},
examples => [
{args => {durations => ['2 days 13 hours']}},
lib/App/DateUtils.pm view on Meta::CPAN
my %args = @_;
parse_duration(module=>'Time::Duration::Parse', %args);
}
$SPEC{dateconv} = {
v => 1.1,
summary => 'Convert date from one format to another',
args => {
date => {
schema => ['date*', {
'x.perl.coerce_to' => 'DateTime',
'x.perl.coerce_rules' => ['From_str::iso8601', 'From_str::natural'],
}],
req => 1,
pos => 0,
},
to => {
schema => ['str*', in=>[qw/epoch ymd iso8601 ALL/]],
default => 'epoch',
cmdline_aliases => {
a => {is_flag=>1, summary => 'Shortcut for --to=ALL', code => sub {$_[0]{to} = 'ALL'}},
lib/App/DateUtils.pm view on Meta::CPAN
sub dateconv {
my %args = @_;
my $date = $args{date};
my $to = $args{to};
if ($to eq 'epoch') {
return $date->epoch;
} elsif ($to eq 'ymd') {
return $date->ymd;
} elsif ($to eq 'iso8601') {
require DateTime::Format::ISO8601::Format;
return DateTime::Format::ISO8601::Format->new->format_datetime($date);
} elsif ($to eq 'ALL') {
return {
epoch => $date->epoch,
ymd => $date->ymd,
iso8601 => do {
require DateTime::Format::ISO8601::Format;
DateTime::Format::ISO8601::Format->new->format_datetime($date);
},
};
} else {
die "Unknown format '$to'";
}
}
$SPEC{strftime} = {
v => 1.1,
summary => 'Format date using strftime()',
args => {
format => {
schema => 'str*',
req => 1,
pos => 0,
},
date => {
schema => ['date*', {
'x.perl.coerce_to' => 'DateTime',
'x.perl.coerce_rules' => ['From_str::iso8601', 'From_str::natural'],
}],
pos => 1,
},
},
result_naked => 1,
examples => [
{
summary => 'Format current time as yyyy-mm-dd',
args => {format => '%Y-%m-%d'},
test => 0,
},
{
summary => 'Format a specific time as yyyy-mm-dd',
args => {format => '%Y-%m-%d', date => 'tomorrow'},
test => 0,
},
],
};
sub strftime {
require DateTime;
require POSIX;
my %args = @_;
my $format = $args{format};
my $date = $args{date} // DateTime->now;
POSIX::strftime($format, localtime($date->epoch));
}
$SPEC{strftimeq} = {
v => 1.1,
summary => 'Format date using strftimeq()',
description => <<'_',
strftimeq() is like POSIX's strftime(), but allows an extra conversion `%(...)q`
lib/App/DateUtils.pm view on Meta::CPAN
_
args => {
format => {
schema => 'str*',
req => 1,
pos => 0,
},
date => {
schema => ['date*', {
'x.perl.coerce_to' => 'DateTime',
'x.perl.coerce_rules' => ['From_str::iso8601', 'From_str::natural'],
}],
pos => 1,
},
},
result_naked => 1,
examples => [
{
summary => 'Format current time as yyyy-mm-dd but add "Sun" when the date is Sunday',
args => {format => '%Y-%m-%d%( require Date::DayOfWeek; Date::DayOfWeek::dayofweek($_[3], $_[4]+1, $_[5]+1900) == 0 ? "sun":"" )q'},
test => 0,
},
],
};
sub strftimeq {
require DateTime;
require Date::strftimeq;
require POSIX;
my %args = @_;
my $format = $args{format};
my $date = $args{date} // DateTime->now;
Date::strftimeq::strftimeq($format, localtime($date->epoch));
}
$SPEC{durconv} = {
v => 1.1,
summary => 'Convert duration from one format to another',
args => {
duration => {
schema => ['duration*', {
'x.perl.coerce_to' => 'DateTime::Duration',
}],
req => 1,
pos => 0,
},
to => {
schema => ['str*', in=>[qw/secs hash iso8601 ALL/]],
default => 'secs',
cmdline_aliases => {
a => {is_flag=>1, summary => 'Shortcut for --to=ALL', code => sub {$_[0]{to} = 'ALL'}},
},
lib/App/DateUtils.pm view on Meta::CPAN
seconds => $dur->seconds,
nanoseconds => $dur->nanoseconds,
};
for (keys %$h) {
delete $h->{$_} if $h->{$_} == 0;
}
return $h;
};
my $code_iso8601 = sub {
require DateTime::Format::Duration::ISO8601;
DateTime::Format::Duration::ISO8601->new->format_duration($dur);
};
if ($to eq 'secs') {
return $code_secs->();
} elsif ($to eq 'hash') {
return $code_hash->();
} elsif ($to eq 'hash') {
return $code_hash->();
} elsif ($to eq 'iso8601') {
return $code_iso8601->();
lib/App/DateUtils.pm view on Meta::CPAN
}
}
$SPEC{datediff} = {
v => 1.1,
summary => 'Diff (subtract) two dates, show as ISO8601 duration',
args => {
date1 => {
schema => ['date*', {
'x.perl.coerce_rules' => ['From_str::natural','From_str::iso8601','From_float::epoch'],
'x.perl.coerce_to' => 'DateTime',
}],
req => 1,
pos => 0,
},
date2 => {
schema => ['date*', {
'x.perl.coerce_rules' => ['From_str::natural','From_str::iso8601','From_float::epoch'],
'x.perl.coerce_to' => 'DateTime',
}],
req => 1,
pos => 1,
},
as => {
schema => ['str*', in=>['iso8601', 'concise_hms', 'hms', 'seconds']],
default => 'iso8601',
},
},
result_naked => 1,
lib/App/DateUtils.pm view on Meta::CPAN
my $dur = $date1->subtract_datetime($date2);
if ($as eq 'seconds') {
$dur->years * 365.25 * 86400 +
$dur->months * 30.5 * 86400 +
$dur->days * 86400 +
$dur->hours * 3600 +
$dur->minutes * 60 +
$dur->seconds;
} elsif ($as eq 'concise_hms' || $as eq 'hms') {
require DateTime::Format::Duration::ConciseHMS;
DateTime::Format::Duration::ConciseHMS->format_duration($dur);
} else {
require DateTime::Format::Duration::ISO8601;
DateTime::Format::Duration::ISO8601->format_duration($dur);
}
}
1;
# ABSTRACT: An assortment of date-/time-related CLI utilities
__END__
=pod
lib/App/DateUtils.pm view on Meta::CPAN
parse_date(dates => ["23 sep 2015", "tomorrow", "foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible",
original => "23 sep 2015",
is_parseable => 1,
as_epoch => 1442966400,
as_datetime_obj => "2015-09-23T00:00:00",
as_datetime_obj_tz_local => "2015-09-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2015-09-22T17:00:00Z",
},
{
module => "DateTime::Format::Flexible",
original => "tomorrow",
is_parseable => 1,
as_epoch => 1709856000,
as_datetime_obj => "2024-03-08T00:00:00",
as_datetime_obj_tz_local => "2024-03-08T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-03-07T17:00:00Z",
},
{
module => "DateTime::Format::Flexible",
original => "foo",
is_parseable => 0,
error_msg => "Invalid date format: foo at /home/u1/perl5/perlbrew/perls/perl-5.38.2/lib/site_perl/5.38.2/Perinci/Access.pm line 81. ",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
lib/App/DateUtils.pm view on Meta::CPAN
=over 4
=item * B<all_modules> => I<bool>
Parse using all installed modules and return all the result at once.
=item * B<dates>* => I<array[str]>
(No description)
=item * B<module> => I<str> (default: "DateTime::Format::Flexible")
(No description)
=item * B<time_zone> => I<str>
(No description)
=back
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_date_using_df_alami_en
Usage:
parse_date_using_df_alami_en(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Alami::EN.
Examples:
=over
=item * Example #1:
parse_date_using_df_alami_en(dates => ["23 May"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "23 May",
is_parseable => 1,
as_epoch => 1716422400,
as_datetime_obj => "2024-05-23T00:00:00",
as_datetime_obj_tz_local => "2024-05-23T07:00:00+07:00",
as_datetime_obj_tz_utc => "2024-05-23T00:00:00Z",
pattern => "p_dateymd",
},
],
{
lib/App/DateUtils.pm view on Meta::CPAN
parse_date_using_df_alami_en(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_epoch",
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_date_using_df_alami_id
Usage:
parse_date_using_df_alami_id(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Alami::ID.
Examples:
=over
=item * Example #1:
parse_date_using_df_alami_id(dates => ["23 Mei"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "23 Mei",
is_parseable => 1,
as_epoch => 1716422400,
as_datetime_obj => "2024-05-23T00:00:00",
as_datetime_obj_tz_local => "2024-05-23T07:00:00+07:00",
as_datetime_obj_tz_utc => "2024-05-23T00:00:00Z",
pattern => "p_dateymd",
},
],
{
lib/App/DateUtils.pm view on Meta::CPAN
parse_date_using_df_alami_id(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_epoch",
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_date_using_df_flexible
Usage:
parse_date_using_df_flexible(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Flexible.
Examples:
=over
=item * Example #1:
parse_date_using_df_flexible(dates => ["23rd Jun"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible",
original => "23rd Jun",
is_parseable => 1,
as_epoch => 1719100800,
as_datetime_obj => "2024-06-23T00:00:00",
as_datetime_obj_tz_local => "2024-06-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-06-22T17:00:00Z",
},
],
{
"table.fields" => [
lib/App/DateUtils.pm view on Meta::CPAN
parse_date_using_df_flexible(dates => ["23 Dez"], lang => "de");
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible(de)",
original => "23 Dez",
is_parseable => 1,
as_epoch => 1734912000,
as_datetime_obj => "2024-12-23T00:00:00",
as_datetime_obj_tz_local => "2024-12-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-12-22T17:00:00Z",
},
],
{
"table.fields" => [
lib/App/DateUtils.pm view on Meta::CPAN
parse_date_using_df_flexible(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Flexible",
original => "foo",
is_parseable => 0,
error_msg => "Invalid date format: foo at /home/u1/perl5/perlbrew/perls/perl-5.38.2/lib/site_perl/5.38.2/Perinci/Access.pm line 81. ",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_date_using_df_natural
Usage:
parse_date_using_df_natural(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse date string(s) using DateTime::Format::Natural.
Examples:
=over
=item * Example #1:
parse_date_using_df_natural(dates => ["23rd Jun"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "23rd Jun",
is_parseable => 1,
as_epoch => 1719100800,
as_datetime_obj => "2024-06-23T00:00:00",
as_datetime_obj_tz_local => "2024-06-23T00:00:00+07:00",
as_datetime_obj_tz_utc => "2024-06-22T17:00:00Z",
},
],
{
"table.fields" => [
lib/App/DateUtils.pm view on Meta::CPAN
parse_date_using_df_natural(dates => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "foo",
is_parseable => 0,
error_msg => "'foo' does not parse (perhaps you have some garbage?)",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_duration_using_df_alami_en
Usage:
parse_duration_using_df_alami_en(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse duration string(s) using DateTime::Format::Alami::EN.
Examples:
=over
=item * Example #1:
parse_duration_using_df_alami_en(durations => ["2h, 3mins"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "2h, 3mins",
is_parseable => 1,
as_secs => 7380,
as_dtdur_obj => "PT2H3M",
},
],
{
"table.fields" => [
"module",
"original",
lib/App/DateUtils.pm view on Meta::CPAN
parse_duration_using_df_alami_en(durations => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::EN",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_secs",
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_duration_using_df_alami_id
Usage:
parse_duration_using_df_alami_id(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse duration string(s) using DateTime::Format::Alami::ID.
Examples:
=over
=item * Example #1:
parse_duration_using_df_alami_id(durations => ["2j, 3mnt"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "2j, 3mnt",
is_parseable => 1,
as_secs => 7380,
as_dtdur_obj => "PT2H3M",
},
],
{
"table.fields" => [
"module",
"original",
lib/App/DateUtils.pm view on Meta::CPAN
parse_duration_using_df_alami_id(durations => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Alami::ID",
original => "foo",
is_parseable => 0,
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
"as_secs",
lib/App/DateUtils.pm view on Meta::CPAN
Return value: (any)
=head2 parse_duration_using_df_natural
Usage:
parse_duration_using_df_natural(%args) -> [$status_code, $reason, $payload, \%result_meta]
Parse duration string(s) using DateTime::Format::Natural.
Examples:
=over
=item * Example #1:
parse_duration_using_df_natural(durations => ["for 2 weeks"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "for 2 weeks",
is_parseable => 1,
as_secs => 1209600.000768,
as_dtdur_obj => "P14DT0.000768S",
date2 => "2024-03-21T09:10:21",
date1 => "2024-03-07T09:10:21",
},
],
{
"table.fields" => [
lib/App/DateUtils.pm view on Meta::CPAN
parse_duration_using_df_natural(durations => ["from 23 Jun to 29 Jun"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "from 23 Jun to 29 Jun",
is_parseable => 1,
as_secs => 9757178.285926,
as_dtdur_obj => "P3M21DT14H49M38.285926S",
date1 => "2024-03-07T09:10:21",
date2 => "2024-06-29T00:00:00",
},
],
{
"table.fields" => [
lib/App/DateUtils.pm view on Meta::CPAN
parse_duration_using_df_natural(durations => ["foo"]);
Result:
[
200,
"OK",
[
{
module => "DateTime::Format::Natural",
original => "foo",
is_parseable => 0,
error_msg => "'foo' does not parse (perhaps you have some garbage?)",
},
],
{
"table.fields" => [
"module",
"original",
"is_parseable",
script/parse-date view on Meta::CPAN
=item B<--dates-json>=I<s>
See C<--date>.
Can also be specified as the 1st command-line argument and onwards.
=item B<--module>=I<s>, B<-m>
Default value:
"DateTime::Format::Flexible"
Valid values:
["DateTime::Format::Flexible","DateTime::Format::Flexible(de)","DateTime::Format::Flexible(es)","DateTime::Format::Natural","Date::Parse"]
=item B<--time-zone>=I<s>, B<--timezone>
(No description)
=back
=head2 Output options
script/parse-date view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-date '23 sep 2015' tomorrow foo
+----------------------------+-------------+--------------+------------+---------------------+---------------------------+------------------------+------------------------------------------------------------------------------------------------------...
| module | original | is_parseable | as_epoch | as_datetime_obj | as_datetime_obj_tz_local | as_datetime_obj_tz_utc | error_msg ...
+----------------------------+-------------+--------------+------------+---------------------+---------------------------+------------------------+------------------------------------------------------------------------------------------------------...
| DateTime::Format::Flexible | 23 sep 2015 | 1 | 1442966400 | 2015-09-23T00:00:00 | 2015-09-23T00:00:00+07:00 | 2015-09-22T17:00:00Z | ...
| DateTime::Format::Flexible | tomorrow | 1 | 1709856000 | 2024-03-08T00:00:00 | 2024-03-08T00:00:00+07:00 | 2024-03-07T17:00:00Z | ...
| DateTime::Format::Flexible | foo | 0 | | | | | Invalid date format: foo at /home/u1/perl5/perlbrew/perls/perl-5.38.2/lib/site_perl/5.38.2/Perinci/Cm...
+----------------------------+-------------+--------------+------------+---------------------+---------------------------+------------------------+------------------------------------------------------------------------------------------------------...
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
script/parse-date-using-df-alami-en view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_date_using_df_alami_en",
program_name => "parse-date-using-df-alami-en",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse date string(s) using DateTime::Format::Alami::EN
# PODNAME: parse-date-using-df-alami-en
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-date-using-df-alami-en - Parse date string(s) using DateTime::Format::Alami::EN
=head1 VERSION
This document describes version 0.128 of parse-date-using-df-alami-en (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-date-using-df-alami-en> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-date-using-df-alami-en> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-date-using-df-alami-en view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-date-using-df-alami-en '23 May'
+-----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+-----------+
| module | original | is_parseable | as_epoch | as_datetime_obj | as_datetime_obj_tz_local | as_datetime_obj_tz_utc | pattern |
+-----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+-----------+
| DateTime::Format::Alami::EN | 23 May | 1 | 1716422400 | 2024-05-23T00:00:00 | 2024-05-23T07:00:00+07:00 | 2024-05-23T00:00:00Z | p_dateymd |
+-----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+-----------+
=head2 Example #2
% parse-date-using-df-alami-en foo
+-----------------------------+----------+--------------+
| module | original | is_parseable |
+-----------------------------+----------+--------------+
| DateTime::Format::Alami::EN | foo | 0 |
+-----------------------------+----------+--------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
script/parse-date-using-df-alami-id view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_date_using_df_alami_id",
program_name => "parse-date-using-df-alami-id",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse date string(s) using DateTime::Format::Alami::ID
# PODNAME: parse-date-using-df-alami-id
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-date-using-df-alami-id - Parse date string(s) using DateTime::Format::Alami::ID
=head1 VERSION
This document describes version 0.128 of parse-date-using-df-alami-id (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-date-using-df-alami-id> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-date-using-df-alami-id> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-date-using-df-alami-id view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-date-using-df-alami-id '23 Mei'
+-----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+-----------+
| module | original | is_parseable | as_epoch | as_datetime_obj | as_datetime_obj_tz_local | as_datetime_obj_tz_utc | pattern |
+-----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+-----------+
| DateTime::Format::Alami::ID | 23 Mei | 1 | 1716422400 | 2024-05-23T00:00:00 | 2024-05-23T07:00:00+07:00 | 2024-05-23T00:00:00Z | p_dateymd |
+-----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+-----------+
=head2 Example #2
% parse-date-using-df-alami-id foo
+-----------------------------+----------+--------------+
| module | original | is_parseable |
+-----------------------------+----------+--------------+
| DateTime::Format::Alami::ID | foo | 0 |
+-----------------------------+----------+--------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
script/parse-date-using-df-flexible view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_date_using_df_flexible",
program_name => "parse-date-using-df-flexible",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse date string(s) using DateTime::Format::Flexible
# PODNAME: parse-date-using-df-flexible
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-date-using-df-flexible - Parse date string(s) using DateTime::Format::Flexible
=head1 VERSION
This document describes version 0.128 of parse-date-using-df-flexible (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-date-using-df-flexible> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-date-using-df-flexible> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-date-using-df-flexible view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-date-using-df-flexible '23rd Jun'
+----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
| module | original | is_parseable | as_epoch | as_datetime_obj | as_datetime_obj_tz_local | as_datetime_obj_tz_utc |
+----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
| DateTime::Format::Flexible | 23rd Jun | 1 | 1719100800 | 2024-06-23T00:00:00 | 2024-06-23T00:00:00+07:00 | 2024-06-22T17:00:00Z |
+----------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
=head2 Example #2
% parse-date-using-df-flexible '23 Dez' --lang de
+--------------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
| module | original | is_parseable | as_epoch | as_datetime_obj | as_datetime_obj_tz_local | as_datetime_obj_tz_utc |
+--------------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
| DateTime::Format::Flexible(de) | 23 Dez | 1 | 1734912000 | 2024-12-23T00:00:00 | 2024-12-23T00:00:00+07:00 | 2024-12-22T17:00:00Z |
+--------------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
=head2 Example #3
% parse-date-using-df-flexible foo
+----------------------------+----------+--------------+------------------------------------------------------------------------------------------------------------------------------+
| module | original | is_parseable | error_msg |
+----------------------------+----------+--------------+------------------------------------------------------------------------------------------------------------------------------+
| DateTime::Format::Flexible | foo | 0 | Invalid date format: foo at /home/u1/perl5/perlbrew/perls/perl-5.38.2/lib/site_perl/5.38.2/Perinci/CmdLine/POD.pm line 505. |
+----------------------------+----------+--------------+------------------------------------------------------------------------------------------------------------------------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
script/parse-date-using-df-natural view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_date_using_df_natural",
program_name => "parse-date-using-df-natural",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse date string(s) using DateTime::Format::Natural
# PODNAME: parse-date-using-df-natural
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-date-using-df-natural - Parse date string(s) using DateTime::Format::Natural
=head1 VERSION
This document describes version 0.128 of parse-date-using-df-natural (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-date-using-df-natural> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-date-using-df-natural> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-date-using-df-natural view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-date-using-df-natural '23rd Jun'
+---------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
| module | original | is_parseable | as_epoch | as_datetime_obj | as_datetime_obj_tz_local | as_datetime_obj_tz_utc |
+---------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
| DateTime::Format::Natural | 23rd Jun | 1 | 1719100800 | 2024-06-23T00:00:00 | 2024-06-23T00:00:00+07:00 | 2024-06-22T17:00:00Z |
+---------------------------+----------+--------------+------------+---------------------+---------------------------+------------------------+
=head2 Example #2
% parse-date-using-df-natural foo
+---------------------------+----------+--------------+-------------------------------------------------------+
| module | original | is_parseable | error_msg |
+---------------------------+----------+--------------+-------------------------------------------------------+
| DateTime::Format::Natural | foo | 0 | 'foo' does not parse (perhaps you have some garbage?) |
+---------------------------+----------+--------------+-------------------------------------------------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
=head1 SEE ALSO
L<dateparse>. The official CLI for DateTime::Format::Natural.
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 CONTRIBUTING
To contribute, you can send patches by email/via RT, or send pull requests on
GitHub.
script/parse-duration view on Meta::CPAN
Can also be specified as the 1st command-line argument and onwards.
=item B<--module>=I<s>, B<-m>
Default value:
"Time::Duration::Parse"
Valid values:
["DateTime::Format::Natural","Time::Duration::Parse"]
=back
=head2 Output options
=over
=item B<--format>=I<s>
Choose output format, e.g. json, text.
script/parse-duration-using-df-alami-en view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_duration_using_df_alami_en",
program_name => "parse-duration-using-df-alami-en",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse duration string(s) using DateTime::Format::Alami::EN
# PODNAME: parse-duration-using-df-alami-en
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-duration-using-df-alami-en - Parse duration string(s) using DateTime::Format::Alami::EN
=head1 VERSION
This document describes version 0.128 of parse-duration-using-df-alami-en (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-duration-using-df-alami-en> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-duration-using-df-alami-en> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-duration-using-df-alami-en view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-duration-using-df-alami-en '2h, 3mins'
+-----------------------------+-----------+--------------+---------+--------------+
| module | original | is_parseable | as_secs | as_dtdur_obj |
+-----------------------------+-----------+--------------+---------+--------------+
| DateTime::Format::Alami::EN | 2h, 3mins | 1 | 7380 | PT2H3M |
+-----------------------------+-----------+--------------+---------+--------------+
=head2 Example #2
% parse-duration-using-df-alami-en foo
+-----------------------------+----------+--------------+
| module | original | is_parseable |
+-----------------------------+----------+--------------+
| DateTime::Format::Alami::EN | foo | 0 |
+-----------------------------+----------+--------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
script/parse-duration-using-df-alami-id view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_duration_using_df_alami_id",
program_name => "parse-duration-using-df-alami-id",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse duration string(s) using DateTime::Format::Alami::ID
# PODNAME: parse-duration-using-df-alami-id
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-duration-using-df-alami-id - Parse duration string(s) using DateTime::Format::Alami::ID
=head1 VERSION
This document describes version 0.128 of parse-duration-using-df-alami-id (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-duration-using-df-alami-id> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-duration-using-df-alami-id> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-duration-using-df-alami-id view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-duration-using-df-alami-id '2j, 3mnt'
+-----------------------------+----------+--------------+---------+--------------+
| module | original | is_parseable | as_secs | as_dtdur_obj |
+-----------------------------+----------+--------------+---------+--------------+
| DateTime::Format::Alami::ID | 2j, 3mnt | 1 | 7380 | PT2H3M |
+-----------------------------+----------+--------------+---------+--------------+
=head2 Example #2
% parse-duration-using-df-alami-id foo
+-----------------------------+----------+--------------+
| module | original | is_parseable |
+-----------------------------+----------+--------------+
| DateTime::Format::Alami::ID | foo | 0 |
+-----------------------------+----------+--------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
script/parse-duration-using-df-natural view on Meta::CPAN
my $cmdline = Perinci::CmdLine::Any->new(
url => "/App/DateUtils/parse_duration_using_df_natural",
program_name => "parse-duration-using-df-natural",
read_config => 0,
read_env => 0,
);
$cmdline->run;
# ABSTRACT: Parse duration string(s) using DateTime::Format::Natural
# PODNAME: parse-duration-using-df-natural
__END__
=pod
=encoding UTF-8
=head1 NAME
parse-duration-using-df-natural - Parse duration string(s) using DateTime::Format::Natural
=head1 VERSION
This document describes version 0.128 of parse-duration-using-df-natural (from Perl distribution App-DateUtils), released on 2024-03-07.
=head1 SYNOPSIS
B<parse-duration-using-df-natural> B<L<--help|/"--help, -h, -?">> (or B<L<-h|/"--help, -h, -?">>, B<L<-?|/"--help, -h, -?">>)
B<parse-duration-using-df-natural> B<L<--version|/"--version, -v">> (or B<L<-v|/"--version, -v">>)
script/parse-duration-using-df-natural view on Meta::CPAN
For fish and zsh, install L<shcompgen> as described above.
=head1 EXAMPLES
=head2 Example #1
% parse-duration-using-df-natural 'for 2 weeks'
+---------------------------+-------------+--------------+----------------+----------------+---------------------+---------------------+
| module | original | is_parseable | as_secs | as_dtdur_obj | date1 | date2 |
+---------------------------+-------------+--------------+----------------+----------------+---------------------+---------------------+
| DateTime::Format::Natural | for 2 weeks | 1 | 1209600.001317 | P14DT0.001317S | 2024-03-07T09:10:23 | 2024-03-21T09:10:23 |
+---------------------------+-------------+--------------+----------------+----------------+---------------------+---------------------+
=head2 Example #2
% parse-duration-using-df-natural 'from 23 Jun to 29 Jun'
+---------------------------+-----------------------+--------------+----------------+-------------------------+---------------------+---------------------+
| module | original | is_parseable | as_secs | as_dtdur_obj | date1 | date2 |
+---------------------------+-----------------------+--------------+----------------+-------------------------+---------------------+---------------------+
| DateTime::Format::Natural | from 23 Jun to 29 Jun | 1 | 9757176.418893 | P3M21DT14H49M36.418893S | 2024-03-07T09:10:23 | 2024-06-29T00:00:00 |
+---------------------------+-----------------------+--------------+----------------+-------------------------+---------------------+---------------------+
=head2 Example #3
% parse-duration-using-df-natural foo
+---------------------------+----------+--------------+-------------------------------------------------------+
| module | original | is_parseable | error_msg |
+---------------------------+----------+--------------+-------------------------------------------------------+
| DateTime::Format::Natural | foo | 0 | 'foo' does not parse (perhaps you have some garbage?) |
+---------------------------+----------+--------------+-------------------------------------------------------+
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-DateUtils>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-DateUtils>.
( run in 0.461 second using v1.01-cache-2.11-cpan-05444aca049 )