After testing a few alternatives, it seems to be that the issue is with DateTime::Set->from_recurrence. Manually populating a set seems to work.

</#!/usr/bin/perl -w
use strict;
use diagnostics;
use DateTime;
use DateTime::Set;

my $date = DateTime->today();
my $date2 = $date->clone();
$date2->add('days' => 14 );
my $set1 = DateTime::Set->from_datetimes( dates => [ $date, $date2 ]);
my $iter = $set1->iterator;
while( my $d = $iter->next ) {
        print $d->datetime, "\n";
}
my $date3 = $date->clone();
$date3->add('days' => 7);
print $set1->contains( $date3 ),"\n"; # gives 0 correct!

my $biweekly = DateTime::Set->from_recurrence(
        'recurrence' => sub {
                return $_[0]->truncate('to' => 'day')->add('days' => 1
+4)
        },
        'after' => $date
);
my $set4 = DateTime::Set->from_datetimes( dates => [ $date3 ] );
print $biweekly->contains( $set4 ), "\n"; # gives 1 wrong!
print $set4->contains( $biweekly ), "\n"; # gives a warning
[download]

You said you had a solution already, but you could create the recurring dates yourself and then it should (hopefully) work.

Maybe I am misunderstanding the problem; your iterator works, adding 14 days each time. But in your test code, you are adding just 7 days and the "in-between" weeks properly fail.

the "in-between" weeks properly fail.

No, the second call to Test::More::is:

is($biweekly->contains($date), 0, $date->ymd . ' is *NOT* the bi-weekl
+y set');
[download]

succeeds only if the call to contains returns 0, i.e., if the DateTime::Set object $biweekly does not contain the specified date (which it shouldn’t). But the call to contains is actually (and incorrectly) returning 1, thereby indicating that the object does contain the given date. So, the test fails because the call to contains returns the wrong answer in this case.

To the OP: I’ve been playing with the code, but haven’t found any way of making it work correctly. So, either the module is buggy, or, at the least, it is poorly documented.

I did notice that you are calling the contains method with a scalar, whereas the module documentation says it takes a list. But putting the argument into an array and passing that to the function makes no difference to the result of the tests. :-(

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

I agree, the documentation for that module is murky and confusing. I also played around with it for a while without success. DateTime::Event::ICal has a cleaner API for creating the DateTime::Set object. This replacement makes it work, leaving the rest of the original code alone.

use DateTime::Event::ICal;

my $biweekly = DateTime::Event::ICal->recur( 
        dtstart  => DateTime->today(),
        freq     => 'weekly',
        interval => 2,
);
[download]

Thanks; I did read that too fleetingly.

I dare come again out of the wood...

It seems that it is important that a DateTime::Set has both start and end point.

Here is my today's attempt with and without an end point and the output below is different (correct if end point is defined):

#!/usr/bin/perl
use strict;
use warnings;

use DateTime;
use DateTime::Set;

my $start = DateTime->today();
my $end   = DateTime->today()->add('days' => 90); 

my $biweekly = DateTime::Set->from_recurrence(
    'recurrence' => sub {
          return $_[0]->add('days' => 14)->truncate('to' => 'day')
        },
     'start' => $start,
     'end' => $end, # !!! This is critical.
);

my $iter = $biweekly->iterator;
print "This is the set with defined 'end': ", $/;
while ( my $dt = $iter->next )
{
    print $dt->datetime, $/;
};
print $/;

print 'TESTING whether Date is in set...', $/;
my $date = DateTime->today();
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;

print $/;
print "This is the begin of the set with 'end' commented out: ", $/;

$biweekly = DateTime::Set->from_recurrence(
    'recurrence' => sub {
          return $_[0]->add('days' => 14)->truncate('to' => 'day')
        },
     'start' => $start,
     # 'end' => $end, # !!! This is critical.
);

$iter = $biweekly->iterator;
while ( my $dt = $iter->next )
{
        last if $dt > $end;  # to avoid the infinite loop.
        print $dt->datetime, $/;
};
print $/;

print 'TESTING whether Date is in set...', $/;
$date = DateTime->today();
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
[download]

The output:

C:\Perl\bin>perl N:\Perle\Learn\DateTime\pm_1033231_orig_analyse_003_h
+.pl
This is the set with defined 'end':
2013-05-14T00:00:00
2013-05-28T00:00:00
2013-06-11T00:00:00
2013-06-25T00:00:00
2013-07-09T00:00:00
2013-07-23T00:00:00
2013-08-06T00:00:00

TESTING whether Date is in set...
1 2013-05-14
0 2013-05-21
1 2013-05-28
0 2013-06-04
1 2013-06-11
0 2013-06-18

This is the begin of the set with 'end' commented out:
2013-05-14T00:00:00
2013-05-28T00:00:00
2013-06-11T00:00:00
2013-06-25T00:00:00
2013-07-09T00:00:00
2013-07-23T00:00:00
2013-08-06T00:00:00

TESTING whether Date is in set...
1 2013-05-14
1 2013-05-21
1 2013-05-28
1 2013-06-04
1 2013-06-11
1 2013-06-18
[download]

Completely misunderstood the problem. Please ignore.

The problem is in the truncate('to' => 'day') step. What you need is to truncate to "14th day", which is not that easy.

Do you think you can do with DateTime::Event::Recurrence or DateTime::Event::ICal? These modules provide a large set of recurrence modes.

#!/usr/bin/perl
use strict;
use warnings;
use DateTime::Event::Recurrence;

print "DateTime::Event::Recurrence: ", $/;

my $start = DateTime->today();
my $biweekly = DateTime::Event::Recurrence->daily(
    interval => 14,
    start    => $start,
);

print 'TESTING whether Date is in set...', $/;
my $date = DateTime->today();
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
$date->add('days' => 7);
print $biweekly->contains($date), ' ', $date->ymd, $/;
[download]

DateTime::Event::Recurrence: 
TESTING whether Date is in set...
1 2013-05-15
0 2013-05-22
1 2013-05-29
0 2013-06-05
1 2013-06-12
0 2013-06-19
[download]

Thank you very much fglock. Two more questions if you don't mind :-)

First: would you generally recommend to use DateTime::Event::Recurrence and DateTime::Event::ICal
instead of DateTime::Set ?

Second: not to promote my hack :-) but just to understand the things better: the code of the OP seems to work with DateTime::Set if the end point is defined ( Re^3: Determine if a given DateTime is a member of a DateTime::Set ) - is it just a coincidence? do you think it will break under other constellation?

Thanks again.

DateTime::Set is fine to use, but calendar math has these mysterious details, and recurrence specifications are particularly hard.

The specialised "DateTime::Event" subclasses can make life easier. DateTime::Event::Sunrise and DateTime::Event::Cron are other nice examples.

About the endpoint that makes it work: when both endpoints of the set are known, it triggers an optimisation that pre-calculates the whole set. The internal representation then changes to a list. This "fixes" the problem, because no further recurrence math is involved.